Softwareupdates (im Allgemeinen)

Hallo,
ich habe mir neu Leap 15.2 installiert und wüsste gern was der am besten geeignete Weg ist, jeweils neueste Paketversionen zu bekommen.
Der mitgelieferte Firefox ist mit 78.4 zwar völlig in Ordnung, um Web-Anwendungen zu testen, hätte ich gern auch die neueste Version. Bekomme ich die im Packman Repository oder gibt es einen besseren Weg?

Besten Dank im Voraus.

Die openSUSE Philosophie ist, eine einmal ausgelieferte Version einer Software nicht durch eine höhere Version zu erneuern.

Auf gut deutsch:
Die beim Erscheinen der openSUSE Version ausgelieferte Version einer Software bleibt in der Version erhalten, nur bugfixes und Updates dieser Version werden eingepflegt.

Allerdings bestätigen auch Ausnahmen die Regel:
Da z.B. Mozilla eine andere Update-Politik verfolgt, werden hier auch die Versionen, sobald sie nicht mehr unterstützt werden, mit neueren Versionen ersetzt.
Leap benutzt beim Firefox die sogenannten ESR Versionen, da diese längeren Support haben.
Siehe z.B.:

zypper se -s mozillafirefox
Repository-Daten werden geladen...
Installierte Pakete werden gelesen...

S  | Name                               | Typ        | Version             | Arch   | Repository
---+------------------------------------+------------+---------------------+--------+-----------
i+ | MozillaFirefox                     | Paket      | 78.4.1-lp152.2.27.1 | x86_64 | OSS-Update
v  | MozillaFirefox                     | Paket      | 78.4.0-lp152.2.24.1 | x86_64 | OSS-Update
v  | MozillaFirefox                     | Paket      | 78.3.0-lp152.2.21.1 | x86_64 | OSS-Update
v  | MozillaFirefox                     | Paket      | 78.2.0-lp152.2.18.1 | x86_64 | OSS-Update
v  | MozillaFirefox                     | Paket      | 78.1.0-lp152.2.15.1 | x86_64 | OSS-Update
v  | MozillaFirefox                     | Paket      | 78.1.0-lp152.2.12.1 | x86_64 | OSS-Update
v  | MozillaFirefox                     | Paket      | 78.0.2-lp152.2.9.1  | x86_64 | OSS-Update
v  | MozillaFirefox                     | Paket      | 78.0.1-lp152.2.5.1  | x86_64 | OSS-Update
v  | MozillaFirefox                     | Paket      | 68.9.0-lp152.1.1    | x86_64 | OSS

Leap wurde mit Firefox-ESR 68 ausgeliefert, ist nun bei Firefox 78.

Wenn du aktuelle Versionen des Firefox haben möchtest, binde Dir das Mozilla Repo ein:

zypper ar -f https://download.opensuse.org/repositories/mozilla/openSUSE_Leap_15.2/ mozilla

Einbinden allein genügt nicht, die Pakete müssen auch auf das Repo umgestellt werden:

zypper dup --allow-vendor-change --from https://download.opensuse.org/repositories/mozilla/openSUSE_Leap_15.2/

Das wird alle installierten Pakete auf die Pakete aus dem mozilla-Repo umstellen.

Aber:
Das ist kein offizielles Repo, es kann auch mal Probleme geben.

Jetzt liegt es an dir.

Bei anderen Pakete würde ich an deiner Stelle erst einmal die Finger von lassen…

Übrigens:
weniger Repos sind oft mehr, ersparen dir viele Probleme.
Es muss auch nicht immer das aktuellste sein.

Zunächst mal vielen Dank für die freundliche Hilfe. Der beschriebene Weg hat auch auf Anhieb geklappt. Nach Wechsel des Repositories wurde auf Firefox 83 geupdatet.
Nun bekomme ich beim Aufruf über die GNOME-Toolbar aber das hier:

<toolbarbutton id="UITourTooltipClose" class="close-icon"
--------------^

An welcher Schraube muss ich drehen, dass Firefox richtig gestartet werden kann?

Poste:

zypper lr -d
zypper se -sir https://download.opensuse.org/repositories/mozilla/openSUSE_Leap_15.2/

Diese Meldung habe ich beim upgrade mehrmals erhalten. Wenn ich mich recht erinnere funktioniert das Kommando ‘firefox --ProfileManager’ in einem Konsolenfenster.

Hallo, hier die Ergebnisse der beiden Eingaben

Erstens;

gabriel@DESKTOP-AVD56CG:~> zypper lr -d
#  | Alias                            | Name                               | Aktiviert | GPG-Überprüfung | Aktualisierung | Priorität | Typ    | URI                                                                            | Dienst
---+----------------------------------+------------------------------------+-----------+-----------------+----------------+-----------+--------+--------------------------------------------------------------------------------+-------
 1 | Application:Geo                  | Application:Geo                    | Ja        | (r ) Ja         | Ja             |   99      | rpm-md | https://download.opensuse.org/repositories/Application:/Geo/openSUSE_Leap_15.2 | 
 2 | http-opensuse-guide.org-d042fbe8 | libdvdcss repository               | Ja        | (r ) Ja         | Ja             |   99      | rpm-md | http://opensuse-guide.org/repo/openSUSE_Leap_15.2/                             | 
 3 | http-packman.inode.at-921e38e9   | Packman Repository                 | Ja        | (r ) Ja         | Ja             |   99      | rpm-md | http://packman.inode.at/suse/openSUSE_Leap_15.2/                               | 
 4 | mozilla                          | mozilla                            | Ja        | (r ) Ja         | Ja             |   99      | rpm-md | https://download.opensuse.org/repositories/mozilla/openSUSE_Leap_15.2/         | 
 5 | openSUSE-Leap-15.2-1             | openSUSE-Leap-15.2-1               | Ja        | (r ) Ja         | Ja             |   99      | rpm-md | http://download.opensuse.org/distribution/leap/15.2/repo/oss                   | 
 6 | repo-debug                       | Debug Repository                   | Nein      | ----            | ----           |   99      | rpm-md | http://download.opensuse.org/debug/distribution/leap/15.2/repo/oss/            | 
 7 | repo-debug-non-oss               | Debug Repository (Non-OSS)         | Nein      | ----            | ----           |   99      | NONE   | http://download.opensuse.org/debug/distribution/leap/15.2/repo/non-oss/        | 
 8 | repo-debug-update                | Update Repository (Debug)          | Nein      | ----            | ----           |   99      | rpm-md | http://download.opensuse.org/debug/update/leap/15.2/oss/                       | 
 9 | repo-debug-update-non-oss        | Update Repository (Debug, Non-OSS) | Nein      | ----            | ----           |   99      | NONE   | http://download.opensuse.org/debug/update/leap/15.2/non-oss/                   | 
10 | repo-non-oss                     | Non-OSS Repository                 | Ja        | (r ) Ja         | Ja             |   99      | rpm-md | http://download.opensuse.org/distribution/leap/15.2/repo/non-oss/              | 
11 | repo-oss                         | Main Repository                    | Ja        | (r ) Ja         | Ja             |   99      | rpm-md | http://download.opensuse.org/distribution/leap/15.2/repo/oss/                  | 
12 | repo-source                      | Source Repository                  | Nein      | ----            | ----           |   99      | NONE   | http://download.opensuse.org/source/distribution/leap/15.2/repo/oss/           | 
13 | repo-source-non-oss              | Source Repository (Non-OSS)        | Nein      | ----            | ----           |   99      | NONE   | http://download.opensuse.org/source/distribution/leap/15.2/repo/non-oss/       | 
14 | repo-update                      | Main Update Repository             | Ja        | (r ) Ja         | Ja             |   99      | rpm-md | http://download.opensuse.org/update/leap/15.2/oss/                             | 
15 | repo-update-non-oss              | Update Repository (Non-Oss)        | Ja        | (r ) Ja         | Ja             |   99      | rpm-md | http://download.opensuse.org/update/leap/15.2/non-oss/                         | 
gabriel@DESKTOP-AVD56CG:~> 

Zweitens

gabriel@DESKTOP-AVD56CG:~> zypper se -sir https://download.opensuse.org/repositories/mozilla/openSUSE_Leap_15.2/Repository-Daten werden geladen...
Installierte Pakete werden gelesen...


S  | Name                             | Typ   | Version        | Arch   | Repository
---+----------------------------------+-------+----------------+--------+-----------
i+ | MozillaFirefox                   | Paket | 83.0-lp152.3.3 | x86_64 | mozilla
i  | MozillaFirefox-branding-openSUSE | Paket | 68-lp152.8.1   | x86_64 | mozilla
i+ | MozillaFirefox-debuginfo         | Paket | 83.0-lp152.3.3 | x86_64 | mozilla
i  | MozillaFirefox-debugsource       | Paket | 83.0-lp152.3.3 | x86_64 | mozilla
i+ | libfreebl3                       | Paket | 3.59-lp152.1.2 | x86_64 | mozilla
i+ | libfreebl3-hmac                  | Paket | 3.59-lp152.1.2 | x86_64 | mozilla
i+ | libsoftokn3                      | Paket | 3.59-lp152.1.2 | x86_64 | mozilla
i+ | libsoftokn3-hmac                 | Paket | 3.59-lp152.1.2 | x86_64 | mozilla
i+ | mozilla-nspr                     | Paket | 4.29-lp152.1.2 | x86_64 | mozilla
i+ | mozilla-nss                      | Paket | 3.59-lp152.1.2 | x86_64 | mozilla
i+ | mozilla-nss-certs                | Paket | 3.59-lp152.1.2 | x86_64 | mozilla
gabriel@DESKTOP-AVD56CG:~> 

Besten Dank im Voraus!

Hallo,
das Problem, das mit Firefox bestand konnte ich inzwischen lösen.
Allerdings habe ich das Problem, dass Updates nicht funktionieren, wenn ich (unter GNOME) SoftwareAktualisierungen aufrufe und ‘*Herunterladen’ *klicke. (s. Screenshot).
https://herrbandow.de/images/screen1220.png
Nach kurzem Abwarten ist der Button wieder anklickbar.
Ich hatte erwartet, dass ich dieselben Updates auch in Yast finden würde. Das ist aber nicht der Fall. Wie kann ich das beheben, ohne alle Updates über das Terminal zu erledigen?

Grüße aus der Uckermark

Evtl. das:
https://bugzilla.suse.com/show_bug.cgi?id=1179942

Benutze einfach als root:

zypper up

Da OpenSUSE Leap 15.2 auf SLED 15 SP2 basiert (oder umgekehrt) kann ich hier (hoffentlich) kompetent weiterhelfen.
Achtung: Nachfolgende Aussagen sind auf Basis von SLED15SP2, sollten aber auch für OpenSUSE Leap 15.2 gelten!

Der unter einem GNOME-Desktop empfohlene Weg zum Einspielen von Software Updates ist im Starthandbuch von OpenSUSE Leap 15.2 im Kapitel 10.4 und 10.5 beschrieben.
https://doc.opensuse.org/de/#opensuse-leap-152

Kapitel 10.4 beschreibt den “alten” Weg zum Einspielen von Softwareupdates via:

gpk-update-viewer

Gpk-update-viewer ist Bestandteil des Softwarepakets (RPM) gnome-packagekit. Gpk-update-viewer wird im Starthandbuch als “GNOME Package Updater” bezeichnet.

Kapitel 10.5 beschreibt den “neuen” Weg zum Einspielen von Softwareupdates via:

gnome-software

Gnome-Software ist Bestandteil des Softwarepakets (RPM) gnome-software. Gnome-Software wird im Starthandbuch als “GNOME Software” bezeichnet.

Gnome-Software wie auch gpk-update-viewer verwenden PackageKit für das Einspielen von Softwareupdates:
https://de.wikipedia.org/wiki/PackageKit

PackageKit wiederum verwendet bei OpenSUSE und SUSE Linux Enterprise (SLE) libzypp für das Einspielen von Softwareupdates.
https://de.wikipedia.org/wiki/Libzypp
Was wichtig zu wissen ist, aber nicht in der Dokumentation von OpenSUSE oder SUSE Linux Enterprise (SLE) ersichtlich ist:

a) gpk-update-viewer benötigt ein auf dem System installiertes RPM “Gnome-Software”, damit im Intervall von 24 Stunden vollautomatisch nach neuen erhältlichen, aber noch nicht installierten Softwareupdates gesucht werden kann.
https://forums.opensuse.org/showthread.php/544111-Understanding-the-GNOME-Package-Updater?p=2962375#post2962375

rpm -qa |grep -i gnome-software

gnome-software-3.34.2-3.8.x86_64
gnome-software-lang-3.34.2-3.8.noarch

Die Softwareupdate-Prozedur mit gpk-update-viewer ist im Kapitel 10.4 des Starthandbuchs ausreichend gut beschrieben.

b) gpk-update-viewer führt via PackageKit eine ONLINE-Installation der Softwareupdates durch. Die Softwareupdates werden heruntergeladen und im laufenden System direkt installiert. Solche ONLINE-Installationen können unberechenbare Auswirkungen auf zum Zeitpunkt der Update-Installation laufende Anwendungen haben. Deshalb wird die OFFLINE-Installation empfohlen.

c) GNOME-Software führt via PackageKit eine OFFLINE-Installation der Softwareupdates durch. Ich zitiere Kapitel 10.5 vom OpenSUSE Leap 15.2-Starthandbuch:

While the GNOME Package Updater updates packages within the running system (forcing you to restart the respective applications),
GNOME Software downloads the updates but only applies them at the next reboot of the system.

OFFLINE-Installationen erfolgen durch PackageKit mit Hilfe von Systemd und einem speziellen Aufstartmodus von Systemd, dem “system update mode”. Für mehr Informationen zum “system update mode” von Systemd siehe:

man systemd.offline-updates

Der Aufstartmodus “system update mode” wird verwendet für heikle Updates wie Firmware-Updates (über LVFS/fwupd). Und ist eben auch der ideale Modus zum Einspielen von Softwareupdates (über GNOME Software/PackageKit/libzypp). Nach dem Einspielen des letzten heiklen Updates wird der “system update mode” über einen Rechnerneustart verlassen und danach erfolgt der Rechnerstart im gewohnten Modus (zum Beispiel: GNOME-Desktop Anmeldemaske => gdm).

Im Aufstartmodus “system update mode” hat der Rechner keine Netzwerkverbindung (OFFLINE). Unter SLED15 SP2 benötigt libzypp aber zwingend eine Netzwerkverbindung, somit funktioniert das Einspielen von Softwareupdates per OFFLINE-Installation unter SLED15 SP2 nicht. Ich bezweifle schwer, dass das Einspielen von Softwareupdates per OFFLINE-Installation unter OpenSUSE Leap 15.2 funktionieren soll…

Die Auslösung und die erfolgreiche OFFLINE-Installation kann mit dem PackageKit-Befehl “pkcon” beobachtet respektive kontrolliert werden. Für die Fehlersuche können mit pkcon die Softwareupdates auch händisch im ONLINE- oder OFFLINE-Modus eingespielt werden. Für mehr Informationen zu pkcon siehe:

man pkcon

d) Voraussetzung für einen korrekt funktionierenden “alten” und “neuen” Weg für das Einspielen der Softwareupdates ist ein korrekt konfiguriertes PolKit/PolicyKit. Siehe dazu Kapitel 19 des Sicherheitshandbuch.

Vielen Dank für mich als Einsteiger sind das wertvolle Hinweise. Ich arbeite mich nach und nach in die Konfiguration ein und es macht Spaß. Toll, wenn man mit so ausführlichen Beschreibungen und Erläuterungen ein wenig an die Hand genommen wird.
Verstehe ich das richtig: Die Online-Updates via YaST bleiben von der Konfiguration von Gnome-Software völlig unberührt, oder?

Ich empfehle die Finger von den YAST-Module: Online-Aktualisierung (YOU => Yast Online Update) und “Konfiguration der Online-Aktualisierung” zu lassen. Die Softwareaktualisierung per YAST-Modul “Konfiguration der Online-Aktualisierung” kann man ausschalten und vergessen.

Das automatische Einspielen von Softwareupdates per YAST-Modul “Konfiguration der Online-Aktualisierung” hat den Nachteil, dass der Zeitpunkt des Updates einspielen unpassend sein kann (PackageKit via cron-Job oder systemd). Wenn man genau in diesem Zeitpunkt den Rechner neustartet (reboot) oder herunterfährt (shutdown) könnte dies das System “brechen”, sprich das System ist beim nächsten Rechnerstart in einem nicht lauffähigen Zustand!

Ich verwende jetzt seit 13 Jahren SUSE Linux Enterprise Desktop und habe noch nie die beiden oben genannten YAST-Module eingesetzt!

Heute verwendet man für das Einspielen von Softwareupdates auf einem Desktoprechner mit einer modernen OpenSUSE- oder SUSE Linux Enterprise Desktop-Installation “GNOME Package Updater”.
In naher Zukunft wird man (hoffentlich) für das Einspielen von Softwareupdates das OFFLINE-Update-Verfahren von “GNOME Software” einsetzen (können).

Eine gute Angewohnheit ist es, regelmässig (alle 2/3 Monate) das Einspielen der Softwareupdates mit:

zypper list-updates

zu kontrollieren. Siehe dazu:

man zypper

Noch einige Tipps für Anfänger:

  • Installation der Softwareupdates optimieren in der Konfigurationsdatei:
    /etc/zypp/zypp.conf
    => Zum Beispiel: Ausschalten von Delta-RPM’s, Ausschalten der Installation von “Recommended Packages” und downloadMode = DownloadInAdvance

  • Beim Wechsel auf eine neuere Version von OpenSUSE Leap nach dem im Starthandbuch, Kapitel 13 “Upgrading the System and System Changes” beschriebenen Verfahren (Einsatz von Zypper empfohlen, siehe Kapitel 13.1.4), sollten alle auf dem System installierten Softwarepakete kontrolliert werden:
    https://doc.opensuse.org/de/

su

zypper ls

zypper lr -P

zypper list-updates

zypper packages --orphaned

zypper lifecycle

rpm -Va

rpmconfigcheck

Für zypper lifecycle siehe auch:
https://kofler.info/opensuse-15/

Für rpm siehe:

man rpm

Für rpmconfigcheck siehe Referenzhandbuch, Kapitel 2.2.2 “Managing Packages: Install, Update, and Uninstall”.

Das einfachste um zu updaten ist:

zypper up

Denn die ganzen Update-Tools können sich an einem Update verschlucken,

zypper up

nicht.

Besten Dank. Nun stehe ich nur leider vor der nächsten (doofen) Frage, auf die ich nocht so recht eine Antwort finde. Hier habe ich bereits nachgelesen https://de.opensuse.org/SDB:Zypper_benutzen#Pakete_aktualisieren
Der Versuch

sudo zypper up

bringt bei mir das folgende Ergebnis

abriel@localhost:~> sudo zypper up 
[sudo] Passwort für root:  
Repository-Daten werden geladen... 
Installierte Pakete werden gelesen... 
 
Die folgenden 12 Paketaktualisierungen werden NICHT installiert: 
  cups cups-client cups-config cups-filters ghostscript ghostscript-fonts-other 
  ghostscript-fonts-std ghostscript-fonts-std-converted ghostscript-x11 libcups2 
  libcupsimage2 parallel-printer-support 
 
Keine auszuführenden Aktionen. 


Warum werden die Pakete NICHT aktualisiert?

Weil die zwar eine höhere Versionsnummer haben, aber auf ein andere Repositiry ligen als die wovon die jetzitge Version installaliert ist.
zypper nimmt an das wenn du von einen bestimmte Repo installiert hast, das du da bleiben willst.

Also has du möglicherweise die 12 genannte Pakete nicht vom standard Repo, oder du hast ein Repo offen wo neuere Versionen angeboten werden.

Du könntest mal achauen auf welche Repos die Pakete zu finden sind und welche bei dir installiert ist; zB.

zypper se -s parallel-printer-support

Hier meine neuste Eigenentwicklung zum vollautomatischen Einspielen von Sicherheitsupdates auf Desktop-Rechnern unter SLED15SP2. Basierend auf dem bereits vorgestellten “system update mode”. Diese Update-Lösung sollte auch unter openSUSE Leap 15.2 und SLES15SP2 funktionieren. Diese Update-Lösung sollte auch für Server geeignet sein. Zum Beispiel: SLES15SP2 im 24h x 7 Tage-Dauerbetrieb.
**
Achtung: Das regelmässige, händische Einspielen aller nicht-sicherheitsrelevanter Updates ist zu empfehlen! **

Warnung: Die unten vorgestellte Update-Lösung ist noch sehr jung und könnte noch einige “Bugs” enthalten!

/usr/local/sbin/prepareUpdates.sh

#!/bin/bash 
######################################################## 
# /usr/local/sbin/prepareUpdates.sh                    # 
# GrandDixence, 25.05.2021                             # 
#                                                      # 
# Sicherheitsupdates herunterladen                     # 
#                                                      # 
######################################################## 
 
# Beginn 
echo "**************************************************************************" 
echo "Herunterladen der Sicherheitsupdates gestartet.." 
/usr/bin/date 
echo "--------------------------------------------------------------------------" 
 
# Updates der Software-Update-Werkzeuge herunterladen 
echo "Updates der Software-Update-Werkzeuge herunterladen.." 
echo " " 
/usr/bin/zypper --non-interactive patch --updatestack-only --auto-agree-with-licenses --auto-agree-with-product-licenses --with-interactive --download-only 
echo "--------------------------------------------------------------------------" 
 
# Sicherheitsupdates herunterladen 
echo "Sicherheitsupdates herunterladen..." 
echo " " 
/usr/bin/zypper --non-interactive patch --category security --auto-agree-with-licenses --auto-agree-with-product-licenses --with-interactive --download-only  
echo "--------------------------------------------------------------------------" 
 
# Müssen Updates der Software-Update-Werkzeuge installiert werden? 
echo "Feststellen, ob Updates der Software-Update-Werkzeuge installiert werden müssen..." 
EnableInstallUpdates=0 
/usr/bin/zypper patch-check --updatestack-only 
Rueckgabe=$? 
echo " " 
 
if  ${Rueckgabe} -eq 100 ]; 
then 
  EnableInstallUpdates=1; 
  echo "Es muss mindestens ein Update der Software-Update-Werkzeuge installiert werden!";  
else  
  echo "Es muss KEIN Update der Software-Update-Werkzeuge installiert werden."; 
fi; 
 
echo "--------------------------------------------------------------------------" 
 
# Müssen Sicherheitsupdates installiert werden? 
echo "Feststellen, ob Sicherheitsupdates installiert werden müssen..." 
/usr/bin/zypper patch-check 
Rueckgabe=$? 
echo " " 
 
if  ${Rueckgabe} -eq 101 ]; 
then 
  EnableInstallUpdates=1; 
  echo "Es muss mindestens ein Sicherheitsupdate installiert werden!"; 
  echo "--------------------------------------------------------------------------"; 
 
  # Alle zu installierenden Sicherheitsupdates auflisten 
  echo "Zu installierende Sicherheitsupdates:"; 
  echo " "; 
  /usr/bin/zypper list-patches --category security; 
else 
  echo "Es muss KEIN Sicherheitsupdate installiert werden."; 
fi; 
 
if  ${EnableInstallUpdates} -eq 1 ]; 
then 
  # System-Update-Modus einschalten 
  echo "--------------------------------------------------------------------------"; 
  echo "System-Update-Modus einschalten..."; 
  /usr/bin/ln -s /opt/ /security-update; 
  /usr/bin/ln -s /opt/ /system-update; 
 
  # Rechner-Neustart um 03:00 Uhr programmieren 
  echo " "; 
  echo "Rechner-Neustart um 03:00 Uhr programmieren..."; 
  /sbin/shutdown -r 03:00 "Rechner-Neustart zum Einspielen von Sicherheitsupdates wird um 03:00 Uhr durchgeführt"; 
fi; 
 
# Ende 
echo "--------------------------------------------------------------------------" 
echo "Herunterladen der Sicherheitsupdates beendet." 
/usr/bin/date 
echo "**************************************************************************" 
 
if  ${EnableInstallUpdates} -eq 1 ]; 
then 
  echo "Es werden Updates beim nächsten Rechnerstart installiert!"; 
else  
  echo "Es werden KEINE Updates beim nächsten Rechnerstart installiert."; 
fi; 
 
echo "**************************************************************************"

/usr/local/sbin/installUpdates.sh

#!/bin/bash 
######################################################## 
# /usr/local/sbin/installUpdates.sh                    # 
# GrandDixence, 24.05.2021                             # 
#                                                      # 
# Sicherheitsupdates installieren                      # 
#                                                      # 
######################################################## 
 
# Beginn 
echo "**************************************************************************" 
echo "Installieren der Sicherheitsupdates gestartet.." 
/usr/bin/date 
echo "--------------------------------------------------------------------------" 
 
 
# System-Update-Modus abschalten 
echo "System-Update-Modus abschalten..." 
/usr/bin/rm /system-update 
/usr/bin/rm /security-update 
echo "--------------------------------------------------------------------------" 
 
# Software-Update-Werkzeuge aktualisieren 
echo "Software-Update-Werkzeuge aktualisieren..." 
echo " " 
/usr/bin/zypper --non-interactive patch --updatestack-only --auto-agree-with-licenses --auto-agree-with-product-licenses --with-interactive   
echo "--------------------------------------------------------------------------" 
 
# Sicherheitsupdates installieren 
echo "Sicherheitsupdates installieren..." 
echo " " 
/usr/bin/zypper --non-interactive patch --category security --auto-agree-with-licenses --auto-agree-with-product-licenses --with-interactive   
echo "--------------------------------------------------------------------------" 
 
# Ende 
echo "--------------------------------------------------------------------------" 
echo "Installieren der Sicherheitsupdates beendet." 
/usr/bin/date 
echo " " 
echo "6 Sekunden warten..." 
/usr/bin/sleep 6 
echo " "  
echo "Rechner-Neustart wird jetzt ausgelöst..." 
/usr/bin/systemctl reboot 
echo "**************************************************************************"

Zugriffsrechte setzen:

# chown root:root /usr/local/sbin/prepareUpdates.sh 
# chmod u=rwx,g=,o= /usr/local/sbin/prepareUpdates.sh 
 
# chown root:root /usr/local/sbin/installUpdates.sh 
# chmod u=rwx,g=,o= /usr/local/sbin/installUpdates.sh

/etc/systemd/system/prepareUpdates.service

[Unit] 
Description=Sicherheitsupdates herunterladen 
After=network-online.target 
Wants=network-online.target 
 
[Service] 
Type=oneshot 
ExecStart=/usr/local/sbin/prepareUpdates.sh 
RemainAfterExit=yes 
 
[Install] 
WantedBy=multi-user.target

Siehe:

man systemd.unit

man systemd.service

für mehr Informationen.

/etc/systemd/system/prepareUpdates.timer

[Unit] 
Description=Sicherheitsupdates herunterladen 
 
[Timer] 
OnCalendar=daily 
RandomizedDelaySec=2h 
Persistent=true 
 
[Install] 
WantedBy=timers.target

Siehe:

man systemd.timer

man systemd.time

für mehr Informationen.

Zugriffsrechte setzen:

# chown root:root /etc/systemd/system/prepareUpdates.service 
# chmod u=rw,g=r,o=r /etc/systemd/system/prepareUpdates.service 
 
# chown root:root /etc/systemd/system/prepareUpdates.timer 
# chmod u=rw,g=r,o=r /etc/systemd/system/prepareUpdates.timer

/usr/lib/systemd/system/installOfflineUpdates.service

[Unit] 
Description=Installation von Sicherheitsupdates mit Zypper im System-Update-Modus 
Documentation=man:systemd.offline-updates 
ConditionPathExists=/security-update 
DefaultDependencies=false 
Requires=sysinit.target dbus.socket 
After=sysinit.target system-update-pre.target dbus.socket systemd-journald.socket 
Before=shutdown.target system-update.target 
 
[Service] 
Type=oneshot 
ExecStart=/usr/local/sbin/installUpdates.sh 
StandardOutput=journal+console 
TimeoutStartSec=1800 
FailureAction=reboot

Siehe:

man systemd.offline-updates

man systemd.exec

für mehr Informationen.

Zugriffsrechte setzen:

# chown root:root /usr/lib/systemd/system/installOfflineUpdates.service 
# chmod u=rw,g=r,o=r /usr/lib/systemd/system/installOfflineUpdates.service

Symbolischer Link erstellen:

# cd /usr/lib/systemd/system/system-update.target.wants/ 
# ln -s ../installOfflineUpdates.service installOfflineUpdates.service

systemd/Journal korrekt konfigurieren:

# more /etc/systemd/journald.conf |grep -v ^# 
 
[Journal] 
Storage=persistent 
SystemMaxUse=300M 
 
# systemctl restart systemd-journald.service 
# systemctl status systemd-journald.service

Siehe:

man journald.conf

https://wiki.archlinux.org/title/Systemd/Journal

für mehr Informationen.

Timer aktivieren:

# systemctl enable prepareUpdates.timer 
# systemctl start prepareUpdates.timer

Timer kontrollieren:

# systemctl list-timers -all 
# systemctl status prepareUpdates.timer 
# journalctl -u prepareUpdates.timer

Dienste kontrollieren:

# systemctl status prepareUpdates.service 
# journalctl -u prepareUpdates.service 
 
# systemctl status installOfflineUpdates.service 
# journalctl -u installOfflineUpdates.service

Hier fehlerkorrigierte Versionen zu meinem letzten Beitrag:

/etc/systemd/system/prepareUpdates.timer

[Unit] 
Description=Sicherheitsupdates herunterladen 
  
[Timer] 
OnCalendar=hourly 
Persistent=true 
  
[Install] 
WantedBy=timers.target

/etc/systemd/system/prepareUpdates.service

[Unit] 
Description=Sicherheitsupdates herunterladen 
After=network-online.target 
Wants=network-online.target 
  
[Service] 
Type=oneshot 
ExecStart=/usr/local/sbin/prepareUpdates.sh 
TimeoutStartSec=1800

/usr/local/sbin/prepareUpdates.sh

#!/bin/bash 
######################################################## 
# /usr/local/sbin/prepareUpdates.sh                    # 
# GrandDixence, 26.05.2021                             # 
#                                                      # 
# Sicherheitsupdates herunterladen                     # 
#                                                      # 
######################################################## 
 
# Beginn 
echo "**************************************************************************" 
echo "Herunterladen der Sicherheitsupdates gestartet.." 
/usr/bin/date 
echo "--------------------------------------------------------------------------" 
echo "4 Minuten warten..." 
/usr/bin/sleep 240 
echo "--------------------------------------------------------------------------" 
 
# Updates der Software-Update-Werkzeuge herunterladen 
echo "Updates der Software-Update-Werkzeuge herunterladen.." 
echo " " 
/usr/bin/zypper --non-interactive patch --updatestack-only --auto-agree-with-licenses --auto-agree-with-product-licenses --with-interactive --download-only 
echo "--------------------------------------------------------------------------" 
 
# Sicherheitsupdates herunterladen 
echo "Sicherheitsupdates herunterladen..." 
echo " " 
/usr/bin/zypper --non-interactive patch --category security --auto-agree-with-licenses --auto-agree-with-product-licenses --with-interactive --download-only  
echo "--------------------------------------------------------------------------" 
 
# Müssen Updates der Software-Update-Werkzeuge installiert werden? 
echo "Feststellen, ob Updates der Software-Update-Werkzeuge installiert werden müssen..." 
EnableInstallUpdates=0 
/usr/bin/zypper patch-check --updatestack-only 
Rueckgabe=$? 
echo " " 
 
if  ${Rueckgabe} -eq 100 ]; 
then 
  EnableInstallUpdates=1; 
  echo "Es muss mindestens ein Update der Software-Update-Werkzeuge installiert werden!";  
else  
  echo "Es muss KEIN Update der Software-Update-Werkzeuge installiert werden."; 
fi; 
 
echo "--------------------------------------------------------------------------" 
 
# Müssen Sicherheitsupdates installiert werden? 
echo "Feststellen, ob Sicherheitsupdates installiert werden müssen..." 
/usr/bin/zypper patch-check 
Rueckgabe=$? 
echo " " 
 
if  ${Rueckgabe} -eq 101 ]; 
then 
  EnableInstallUpdates=1; 
  echo "Es muss mindestens ein Sicherheitsupdate installiert werden!"; 
  echo "--------------------------------------------------------------------------"; 
 
  # Alle zu installierenden Sicherheitsupdates auflisten 
  echo "Zu installierende Sicherheitsupdates:"; 
  echo " "; 
  /usr/bin/zypper list-patches --category security; 
else 
  echo "Es muss KEIN Sicherheitsupdate installiert werden."; 
fi; 
 
if  ${EnableInstallUpdates} -eq 1 ]; 
then 
  # System-Update-Modus einschalten 
  echo "--------------------------------------------------------------------------"; 
  echo "System-Update-Modus einschalten..."; 
  /usr/bin/ln -s /opt/ /security-update; 
  /usr/bin/ln -s /opt/ /system-update; 
 
  # Rechner-Neustart um 03:00 Uhr programmieren 
  echo " "; 
  echo "Rechner-Neustart um 03:00 Uhr programmieren..."; 
  /sbin/shutdown -r 03:00 "Rechner-Neustart zum Einspielen von Sicherheitsupdates wird um 03:00 Uhr durchgeführt"; 
fi; 
 
# Ende 
echo "--------------------------------------------------------------------------" 
echo "Herunterladen der Sicherheitsupdates beendet." 
/usr/bin/date 
echo "**************************************************************************" 
 
if  ${EnableInstallUpdates} -eq 1 ]; 
then 
  echo "Es werden Updates beim nächsten Rechnerstart installiert!"; 
else  
  echo "Es werden KEINE Updates beim nächsten Rechnerstart installiert."; 
fi; 
 
echo "**************************************************************************"

/usr/local/sbin/installUpdates.sh

#!/bin/bash 
######################################################## 
# /usr/local/sbin/installUpdates.sh                    # 
# GrandDixence, 02.06.2021                             # 
#                                                      # 
# Sicherheitsupdates installieren                      # 
#                                                      # 
######################################################## 
  
# Beginn 
echo "**************************************************************************" 
echo "Installieren der Sicherheitsupdates gestartet.." 
/usr/bin/date 
echo "--------------------------------------------------------------------------" 
  
# System-Update-Modus abschalten 
echo "System-Update-Modus abschalten..." 
/usr/bin/rm /system-update 
/usr/bin/rm /security-update 
echo "--------------------------------------------------------------------------" 
  
# Software-Update-Werkzeuge aktualisieren 
echo "Software-Update-Werkzeuge aktualisieren..." 
echo " " 
/usr/bin/zypper --no-refresh --non-interactive patch --updatestack-only --auto-agree-with-licenses --auto-agree-with-product-licenses --with-interactive   
echo "--------------------------------------------------------------------------" 
  
# Sicherheitsupdates installieren 
echo "Sicherheitsupdates installieren..." 
echo " " 
/usr/bin/zypper --no-refresh --non-interactive patch --category security --auto-agree-with-licenses --auto-agree-with-product-licenses --with-interactive   
echo "--------------------------------------------------------------------------" 
  
# Ende 
echo "--------------------------------------------------------------------------" 
echo "Installieren der Sicherheitsupdates beendet." 
/usr/bin/date 
echo " " 
echo "6 Sekunden warten..." 
/usr/bin/sleep 6 
echo " "   
echo "Rechner-Neustart wird jetzt ausgelöst..." 
/usr/bin/systemctl reboot 
echo "**************************************************************************"

Linux-Administrator:Innen testen alle Sicherheitsupdates in der Testumgebung ausgiebig, bevor die Produktivumgebung mit diesen neuen Sicherheitsupdates versorgt wird. Siehe dazu:
https://forums.opensuse.org/t/snapper-ein-verzeichnis-ausschliessen/149243/21

Beim Einsatz vom oben vorgestellten, vollautomatischen Update-Mechanismus gibt es drei Methoden für den Linux-Administrator, wie von zentraler Stelle aus, die Installation von Sicherheitsupdates in der Produktivumgebung auf mehreren Linux-Rechnern verhindert werden kann.

a) Einsatz des kostenpflichtigen SUSE Manager.
https://www.suse.com/de-de/products/suse-manager/

b) Einsatz des kostenlosen Uyuni. Der SUSE Manager basiert auf der kostenlosen Software Uyuni.
https://www.uyuni-project.org/

Zum Uyuni gibt es vom Benutzer “IT-Gulasch” drei informative Youtube-Videos, welche die Installation und Konfiguration von Uyuni zeigen.

c) Eigenes YUM-Paketdepot erstellen und betreiben. Alle Linuxrechnern in der Produktiv- und Testumgebung so konfigurieren, dass diese Rechnern nur Softwarepakete (RPM) aus dem eigenen YUM-Paketdepot installieren. Die Linuxrechnern der Produktiv- und Testumgebung dürfen keine offiziellen Paketdepots von (Open-)SUSE verwenden!

Nachfolgend wird aufgezeigt, wie man mit Shellskripten ein eigenes YUM-Paketdepot erstellt und betreibt. Die nachfolgenden Informationen basieren auf folgenden Grundlagen:

https://en.opensuse.org/SDB:Creating_YaST_installation_sources

https://www.suse.com/c/creating-yum-repository-and-publishing-it-smt/

https://www.golinuxhub.com/2018/06/how-to-configure-local-custom-repo-zypper-sles/

https://en.opensuse.org/openSUSE:Standards_Rpm_Metadata_UpdateInfo

Auf einem Referenzsystem ist das eigene YUM-Paketdepot wie auch die offiziellen Paketdepots von (Open-)SUSE eingebunden. Das Referenzsystem wird mit den zypper-Befehlen:

  • Alle verfügbaren Patches anzeigen.
    # zypper list-patches

  • Alle nicht installierten Sicherheits-Patches auflisten.
    # zypper list-patches --category security

  • Alle verfügbaren Patches auflisten, die vor einem bestimmten Datum veröffentlicht wurden.
    # zypper list-patches --date 2023-03-28

  • Informationen zu einem Patch anzeigen.
    # zypper patch-info SUSE-SLE-Module-Basesystem-15-SP4-2023-1670
    # zypper info -t patch SUSE-SLE-Module-Basesystem-15-SP4-2023-1617

  • Alle nicht installierten Sicherheits-Patches installieren.
    # zypper patch --category security

  • Ein einziger Patch installieren.
    # zypper install -t patch <Name des Patches>
    # zypper install -t patch SUSE-SLE-SERVER-12-SP2-2017-990

mit den gewünschten Patches versorgt (=> Softwareupdates und Sicherheitsupdates). Siehe dazu auch:

https://www.suse.com/c/patching-patch-sle-opensuse/

Hinweis: Bei der Installation von Patches werden immer Softwarepakete (RPM) installiert! Bei der Installation eines Patches werden die in den Patchdaten aufgeführten Softwarepakete installiert (RPM). Die Patchdaten findet man im YUM-Paketdepot in einer XML-Datei names updateinfo.xml im Unterverzeichnis repodata. Das Unterverzeichnis repodata enthält alle Metadaten des YUM-Paketdepot.

Mit den nachfolgend vorgestellten Shellskripten werden alle auf dem Referenzsystem installierten Softwarepakete (RPM) lokal auf den Rechner heruntergeladen (downloadUpdates.sh) und dem eigenen YUM-Paketdepot hinzugefügt (addUpdates.sh).

Voraussetzungen für den Einsatz der nachfolgend vorgestellten Shellskripte sind:

  • Die vorgängige Installation einiger Softwarepakete
    # zypper install p7zip
    # zypper install createrepo_c

  • Eigener GPG-Schlüssel für das Signieren von eigenen Softwarepakete (RPM) erstellt und auf dem Referenzsystem und allen Linuxrechnern der Produktiv- und Testumgebung installiert.

    Der eigene GPG-Schlüssel wird in die RPM-Paketverwaltung mit diesem Befehl importiert:

    # rpm --import <Pfad zum eigenen, öffentlichen GPG-Schlüssel>

    In das System der RPM-Paketverwaltung darf nur der öffentliche GPG-Schlüssel importiert werden! Keinesfalls den privaten GPG-Schlüssel importieren!

    Für mehr Informationen zum Einsatz von GPG-Schlüsseln in der RPM-Paketverwaltung siehe:

    # man rpmkeys
    # man rpmsign

    und hier:

https://forums.opensuse.org/t/ffmpeg-4-und-libaom-av1/150124

  • Vollautomatische Installation von Sicherheitsupdates mit den vorgängig vorgestellten Systemd-Diensten auf allen Linuxrechnern der Produktiv- und Testumgebung eingerichtet und konfiguriert.

  • Auf dem Referenzsystem wie auch auf allen Linuxrechnern der Test- und Produktivumgebung ist das eigene YUM-Paketdepot eingebunden:

    Mit zypper oder YAST2 das YUM-Paketdepot einhängen.

    Im YAST2 die Option “Automatisch aktualisieren” für das YUM-Paketdepot einschalten.

    Im YAST2 dem YUM-Paketdepot die Priorität 98 vergeben. Wichtig: Alle offiziellen (Standard-)Update-Paketdepots von (Open-)SUSE erhalten ebenfalls die Priorität 98!

Die Erstellung und Aktualisierung des eigenen YUM-Paketdepots mit den nachfolgenden Shellskripten geht wie folgt auf dem Referenzsystem:

  • Neue Softwarepakete (RPM) herunterladen:
    # /usr/local/sbin/downloadUpdates.sh

  • Neue Softwarepakete (RPM) dem YUM-Paketdepot hinzufügen
    # /usr/local/sbin/addUpdates.sh

Zur Verteilung und Aktualisierung des eigenen YUM-Paketdepot auf den Linux-Rechnern der Testumgebung gibt es zwei Methoden:

  • Offline-Methode: Neu erstelltes 7z-Archiv per USB-Memorystick auf die Linuxrechnern der Testumgebung kopieren. Das neu erstellte 7z-Archiv auf den Linuxrechnern der Testumgebung entpacken. Das 7z-Archiv enthält das eigene YUM-Paketdepot.

  • Online-Methode: Das YUM-Paketdepot mit rsync per SSH vom Referenzsystem auf die Linuxrechnern der Testumgebung synchronisieren. Alternative: Einsatz einer HTTPS-, HTTP-, FTP- oder SMB-Netzwerkablage.

Nach dem erfolgreichen und mangelfreien Testen der neuen Sicherheitsupdates erfolgt die Verteilung und Aktualisierung des eigenen YUM-Paketdepot auf den Linux-Rechnern der Produktivumgebung mit den oben vorgestellten Methoden.

Die nachfolgend vorgestellten Shellskripte wurden für SUSE Linux Enterprise Desktop 15 SP4 geschrieben (SLED15 SP4). Mit Anpassung der offiziellen Paketdepoteinträgen sollten diese Shellskripte auch unter OpenSUSE Leap 15.4 funktionstüchtig sein. Da diese Shellskripte erst einige Tage alt sind, könnten sie noch den einten oder anderen Programmierfehler enthalten!

# ls -alh /usr/local/sbin/
insgesamt 64K
drwxr-xr-x  2 root root  288  1. Apr 10:39 .
drwxr-xr-x 10 root root  103 15. Mär 2022  ..
-rwx------  1 root root 9.6K  1. Apr 10:37 addUpdates.sh
-rwx------  1 root root 5.4K  1. Apr 10:37 downloadUpdates.sh
#!/bin/bash
################################################################################
# /usr/local/sbin/downloadUpdates.sh
#
# Im YUM-Paketdepot fehlende Softwarepakete suchen und herunterladen
#
# GrandDixence, 01.04.2023
#
################################################################################


echo "-------------------------------------------------------------------------"
echo "Start von downloadUpdates.sh"
echo "-------------------------------------------------------------------------"

echo " "
echo "Variablen einlesen..."
paketDepot=mycompany-desktop-SLED15-SP4

downloadListe=/tmp/rpmDownloadListe.txt
rpmListe=/tmp/rpmUpdateListe.txt
downloadVerzeichnis=/tmp/RPM

echo " "
echo "Alle Standard-Paketdepots ausschalten..."
/usr/bin/zypper modifyrepo --disable SLE-Module-Basesystem15-SP4-Pool
/usr/bin/zypper modifyrepo --disable SLE-Module-Basesystem15-SP4-Updates
/usr/bin/zypper modifyrepo --disable SLE-Module-Desktop-Applications15-SP4-Pool
/usr/bin/zypper modifyrepo --disable SLE-Module-Desktop-Applications15-SP4-Updates
/usr/bin/zypper modifyrepo --disable SLE-Module-DevTools15-SP4-Pool
/usr/bin/zypper modifyrepo --disable SLE-Module-DevTools15-SP4-Updates
/usr/bin/zypper modifyrepo --disable SLE-Product-SLED15-SP4-Pool
/usr/bin/zypper modifyrepo --disable SLE-Product-SLED15-SP4-Updates
/usr/bin/zypper modifyrepo --disable SLE-Product-WE15-SP4-Pool
/usr/bin/zypper modifyrepo --disable SLE-Product-WE15-SP4-Updates
echo "Alle Standard-Paketdepots ausgeschaltet."

echo " "
echo "Kontrolle:"
echo "--------------------------------------------------------------------------------------------------------"
/usr/bin/zypper lr --show-enabled-only --sort-by-name
echo "--------------------------------------------------------------------------------------------------------"

echo " "
echo "Alle im YUM-Paketdepot fehlende Softwarepakete suchen..."
/usr/bin/zypper packages --installed-only |grep -v -i ${paketDepot} |grep \| |grep -v ^S > ${rpmListe}

echo " "
echo "Alle im YUM-Paketdepot fehlende Softwarepakete werden in der Textdatei:"
echo " " 
echo "${rpmListe}"
echo " " 
echo "aufgeführt."
echo " "
echo "Hier deren Inhalt:"
echo "--------------------------------------------------------------------------------------------------------"
cat ${rpmListe}
echo "--------------------------------------------------------------------------------------------------------"

echo " "
echo "Alle Standard-Paketdepots einschalten..."
/usr/bin/zypper modifyrepo --enable SLE-Module-Basesystem15-SP4-Pool
/usr/bin/zypper modifyrepo --enable SLE-Module-Basesystem15-SP4-Updates
/usr/bin/zypper modifyrepo --enable SLE-Module-Desktop-Applications15-SP4-Pool
/usr/bin/zypper modifyrepo --enable SLE-Module-Desktop-Applications15-SP4-Updates
/usr/bin/zypper modifyrepo --enable SLE-Module-DevTools15-SP4-Pool
/usr/bin/zypper modifyrepo --enable SLE-Module-DevTools15-SP4-Updates
/usr/bin/zypper modifyrepo --enable SLE-Product-SLED15-SP4-Pool
/usr/bin/zypper modifyrepo --enable SLE-Product-SLED15-SP4-Updates
/usr/bin/zypper modifyrepo --enable SLE-Product-WE15-SP4-Pool
/usr/bin/zypper modifyrepo --enable SLE-Product-WE15-SP4-Updates
echo "Alle Standard-Paketdepots wurden eingeschaltet."

echo " "
echo "Kontrolle:"
echo "--------------------------------------------------------------------------------------------------------"
/usr/bin/zypper lr --show-enabled-only --sort-by-name 
echo "--------------------------------------------------------------------------------------------------------"
echo " "

if [ -d "${downloadVerzeichnis}" ];
then  
  echo "Verzeichnis für die Ablage der heruntergeladenen Softwarepakete löschen...";
  /usr/bin/rm -R ${downloadVerzeichnis} &> /dev/null;
fi;

echo "Verzeichnis für die Ablage der heruntergeladenen Softwarepakete erstellen..."
/usr/bin/mkdir -p ${downloadVerzeichnis}

echo " " 
echo "Herunterladen der im YUM-Paketdepot fehlenden Softwarepakete starten."
echo "Die heruntergeladenen Softwarepakete werden im Verzeichnis:"
echo " "
echo "${downloadVerzeichnis}"
echo " "
echo "abgelegt."

while IFS= read -r zeile
do
  echo " "
  echo "******************************************************************************************************"
  softwarePaket=`echo ${zeile} | /usr/bin/awk '{print $5}'`
  echo "Softwarepaket herunterladen:   ${softwarePaket}"
  /usr/bin/zypper --pkg-cache-dir=${downloadVerzeichnis} download ${softwarePaket}
done < ${rpmListe}

echo "******************************************************************************************************"
echo "Herunterladen der fehlenden Softwarepakete beendet."

echo " "
echo "Alle heruntergeladenen Softwarepakete suchen..." 
/usr/bin/find ${downloadVerzeichnis} -type f -name "*.rpm" > ${downloadListe}

echo " "
echo "Alle heruntergeladenen Softwarepakete werden in der Textdatei:"
echo " " 
echo "${downloadListe}"
echo " "
echo "aufgeführt."

echo " "
echo "Softwarepakete ins oberste Verzeichnis verschieben..."

while IFS= read -r zeile
do
  softwarePaket=`/usr/bin/basename ${zeile}`
  echo "Softwarepaket verschieben:   ${softwarePaket}"
  /usr/bin/mv --no-clobber ${zeile} ${downloadVerzeichnis}/${softwarePaket}
done < ${downloadListe}

echo " "
echo "Alle heruntergeladenen Softwarepakete wurden ins Verzeichnis:"
echo "${downloadVerzeichnis}"
echo "verschoben."

echo "Ende von downloadUpdates.sh"
echo "-------------------------------------------------------------------------"
#!/bin/bash
################################################################################
# /usr/local/sbin/addUpdates.sh
#
# Im YUM-Paketdepot fehlende Softwarepakete ins Paketdepot aufnehmen
#
# GrandDixence, 01.04.2023
#
################################################################################


echo "-------------------------------------------------------------------------"
echo "Start von addUpdates.sh"
echo "-------------------------------------------------------------------------"

echo " "
echo "Variablen einlesen..."
organisation=MYCOMPANY
email=granddixence@mycompany.com

paketDepot=mycompany-desktop-SLED15-SP4
cpuArchitektur=x86_64
yumVerzeichnis=/home/Installation/SLED15/YUM

downloadVerzeichnis=/tmp/RPM
paketDepotVerzeichnis=${yumVerzeichnis}/${paketDepot}
addNoArchListe=/tmp/rpmAddNoArchListe.txt
addArchListe=/tmp/rpmAddArchListe.txt
patchListe=${paketDepotVerzeichnis}/patchListe.txt
updateInfoListe=${paketDepotVerzeichnis}/updateinfo.xml
archivVerzeichnis=${yumVerzeichnis}/Archiv
kopfZeileDatei=/tmp/rpmKopfZeileDatei.txt

jahr=`/usr/bin/date +"%Y"`
monat=`/usr/bin/date +"%m"`
tag=`/usr/bin/date +"%d"`

stunde=`/usr/bin/date +"%H"`
minute=`/usr/bin/date +"%M"`
sekunde=`/usr/bin/date +"%S"`

echo " "
echo "Alle heruntergeladenen Softwarepakete suchen..." 
/usr/bin/find ${downloadVerzeichnis} -type f -name "*.noarch.rpm" > ${addNoArchListe}
/usr/bin/find ${downloadVerzeichnis} -type f -name "*.${cpuArchitektur}.rpm" > ${addArchListe}

echo " "
echo "Alle heruntergeladenen, CPU-Architektur-unabhängigen Softwarepakete (*.noarch.rpm) werden in der Textdatei:"
echo " " 
echo "${addNoArchListe}"
echo " "
echo "aufgeführt."
echo " "
echo "Hier deren Inhalt:"
echo "--------------------------------------------------------------------------------------------------------"
while IFS= read -r zeile
do
  softwarePaket=`/usr/bin/basename ${zeile}`
  echo "${softwarePaket}"
done < ${addNoArchListe}
echo "--------------------------------------------------------------------------------------------------------"

echo " "
echo "Alle heruntergeladenen, CPU-Architektur-abhängigen Softwarepakete (*.${cpuArchitektur}.rpm) werden in der Textdatei:"
echo " " 
echo "${addArchListe}"
echo " "
echo "aufgeführt."
echo " "
echo "Hier deren Inhalt:"
echo "--------------------------------------------------------------------------------------------------------"
while IFS= read -r zeile
do
  softwarePaket=`/usr/bin/basename ${zeile}`
  echo "${softwarePaket}"
done < ${addArchListe}
echo "--------------------------------------------------------------------------------------------------------"

echo " " 
echo "Unterverzeichnisse im Paketdepot erstellen..."

if [ ! -d "${paketDepotVerzeichnis}/rpm/noarch" ];
then
  echo " ";
  echo "Unterverzeichnis:";
  echo "${paketDepotVerzeichnis}/rpm/noarch";
  echo "im Paketdepot erstellen...";
  /usr/bin/mkdir -p ${paketDepotVerzeichnis}/rpm/noarch;
else
  echo " ";
  echo "Unterverzeichnis:";
  echo "${paketDepotVerzeichnis}/rpm/noarch";
  echo "existiert bereits im Paketdepot.";  
fi;

if [ ! -d "${paketDepotVerzeichnis}/rpm/${cpuArchitektur}" ];
then
  echo " ";
  echo "Unterverzeichnis:";
  echo "${paketDepotVerzeichnis}/rpm/${cpuArchitektur}";
  echo "im Paketdepot erstellen...";
  /usr/bin/mkdir -p ${paketDepotVerzeichnis}/rpm/${cpuArchitektur};
else
  echo " ";
  echo "Unterverzeichnis:";
  echo "${paketDepotVerzeichnis}/rpm/${cpuArchitektur}";
  echo "existiert bereits im Paketdepot.";
fi;

echo " " 
echo "Heruntergeladene CPU-Architektur-unabhängigen Softwarepakete (*.noarch.rpm) ins Paketdepot kopieren..."

while IFS= read -r zeile
do
  softwarePaketKurz=`/usr/bin/basename ${zeile}`
  echo "${softwarePaketKurz}"
  /usr/bin/cp ${zeile} ${paketDepotVerzeichnis}/rpm/noarch/
done < ${addNoArchListe}

echo " " 
echo "Heruntergeladene CPU-Architektur-abhängigen Softwarepakete (*.${cpuArchitektur}.rpm) ins Paketdepot kopieren..."

while IFS= read -r zeile
do
  softwarePaketKurz=`/usr/bin/basename ${zeile}`
  echo "${softwarePaketKurz}"
  /usr/bin/cp ${zeile} ${paketDepotVerzeichnis}/rpm/${cpuArchitektur}/
done < ${addArchListe}

echo " "
echo "Kopieraktion vollständig abgeschlossen."

echo "Patchliste erstellen..."
echo "${patchListe}"

echo " "
echo "Patchliste befüllen mit den CPU-Architektur-unabhängigen Softwarepakete (*.noarch.rpm)..."

leereDatei="true"

while IFS= read -r zeile
do
  leereDatei="false"
done < ${addNoArchListe}

if [ ${leereDatei} = "false" ];
then
  echo "  <update from=\"${email}\" status=\"stable\" type=\"security\" version=\"1\">" >> ${patchListe};
  echo "    <id>${organisation}-J${jahr}M${monat}T${tag}_H${stunde}M${minute}S${sekunde}_noarch</id>" >> ${patchListe};
  echo "    <title>Forciertes Update vom Administrator</title>" >> ${patchListe};
  echo "    <severity>moderate</severity>" >> ${patchListe};
  echo "    <issued date=\"${jahr}-${monat}-${tag} ${stunde}:${minute}:${sekunde}\"/>" >> ${patchListe};
  echo "    <description>Forciertes Update aus dem eigenen YUM-Paketdepot.</description>" >> ${patchListe};
  echo "    <pkglist>" >> ${patchListe};
  echo "      <collection>" >> ${patchListe};  
fi;

while IFS= read -r zeile
do
  softwarePaketKurz=`/usr/bin/basename ${zeile}`
  echo "${softwarePaketKurz}"
  
  name=`/usr/bin/rpm -q --queryformat "%{NAME}" ${zeile}`
  version=`/usr/bin/rpm -q --queryformat "%{VERSION}" ${zeile}`
  release=`/usr/bin/rpm -q --queryformat "%{RELEASE}" ${zeile}`

  epochAbfrage=`/usr/bin/rpm -q --queryformat "%{EPOCH}" ${zeile}`	

  if [ ${epochAbfrage} = "(none)" ];
  then
    epoch=0;
  else
    epoch=${epochAbfrage};
  fi;
  
  echo "        <package name=\"${name}\" epoch=\"${epoch}\" version=\"${version}\" release=\"${release}\" arch=\"noarch\" src=\"noarch/${softwarePaketKurz}\">" >> ${patchListe}
  echo "          <filename>${softwarePaketKurz}</filename>" >> ${patchListe}
  echo "        </package>" >> ${patchListe}
done < ${addNoArchListe}

if [ ${leereDatei} = "false" ];
then
  echo "      </collection>" >> ${patchListe};
  echo "    </pkglist>" >> ${patchListe};      
  echo "  </update>" >> ${patchListe};  
fi;

echo " "
echo "Patchliste befüllen mit den CPU-Architektur-abhängigen Softwarepakete (*.${cpuArchitektur}.rpm)..."

leereDatei=true

while IFS= read -r zeile
do
  leereDatei=false
done < ${addArchListe}

if [ ${leereDatei} = "false" ];
then
  echo "  <update from=\"${email}\" status=\"stable\" type=\"security\" version=\"1\">" >> ${patchListe};
  echo "    <id>${organisation}-J${jahr}M${monat}T${tag}_H${stunde}M${minute}S${sekunde}_${cpuArchitektur}</id>" >> ${patchListe};
  echo "    <title>Forciertes Update vom Administrator</title>" >> ${patchListe};
  echo "    <severity>moderate</severity>" >> ${patchListe};
  echo "    <issued date=\"${jahr}-${monat}-${tag} ${stunde}:${minute}:${sekunde}\"/>" >> ${patchListe};
  echo "    <description>Forciertes Update aus dem eigenen YUM-Paketdepot.</description>" >> ${patchListe};
  echo "    <pkglist>" >> ${patchListe};
  echo "      <collection>" >> ${patchListe};
fi;

while IFS= read -r zeile
do
  softwarePaketKurz=`/usr/bin/basename ${zeile}`
  echo "${softwarePaketKurz}"
  
  name=`/usr/bin/rpm -q --queryformat "%{NAME}" ${zeile}`
  version=`/usr/bin/rpm -q --queryformat "%{VERSION}" ${zeile}`
  release=`/usr/bin/rpm -q --queryformat "%{RELEASE}" ${zeile}`  

  epochAbfrage=`/usr/bin/rpm -q --queryformat "%{EPOCH}" ${zeile}`	

  if [ ${epochAbfrage} = "(none)" ];
  then
    epoch=0;
  else
    epoch=${epochAbfrage};
  fi;

  echo "        <package name=\"${name}\" epoch=\"${epoch}\" version=\"${version}\" release=\"${release}\" arch=\"${cpuArchitektur}\" src=\"${cpuArchitektur}/${softwarePaketKurz}\">" >> ${patchListe}
  echo "          <filename>${softwarePaketKurz}</filename>" >> ${patchListe}
  echo "        </package>" >> ${patchListe}
done < ${addArchListe}

if [ ${leereDatei} = "false" ];
then
  echo "      </collection>" >> ${patchListe};
  echo "    </pkglist>" >> ${patchListe};      
  echo "  </update>" >> ${patchListe};   
fi;

echo "<updates>" > ${kopfZeileDatei}
cat ${kopfZeileDatei} ${patchListe} > ${updateInfoListe}
echo "</updates>" >> ${updateInfoListe}

echo "Patchliste erstellt."

echo " "
echo "Unterverzeichnis repodata im Paketdepot löschen..."
/usr/bin/rm -R ${paketDepotVerzeichnis}/repodata/

echo " "
echo "YUM-Paketdepot erstellen..."
/usr/bin/createrepo --no-database ${paketDepotVerzeichnis}/

echo " "
echo "YUM-Paketdepot um Patchliste ergänzen..."
/usr/bin/modifyrepo_c ${updateInfoListe} ${paketDepotVerzeichnis}/repodata

echo " "
echo "YUM-Paketdepot mit GPG-Schlüssel signieren..."
echo "Es folgt eine Abfrage für das Passwort des privaten GPG-Schlüssels!"
/usr/bin/gpg --armor --detach-sign ${paketDepotVerzeichnis}/repodata/repomd.xml

echo " "
echo "Öffentlicher GPG-Schlüssel dem YUM-Paketdepot hinzufügen..."
/usr/bin/gpg --armor --export > ${paketDepotVerzeichnis}/repodata/repomd.xml.key

echo " " 
echo "Archivverzeichnis für das Paketdepot erstellen..."

if [ ! -d "${archivVerzeichnis}/${jahr}" ];
then
  echo " ";
  echo "Archivverzeichnis:";
  echo "${archivVerzeichnis}/${jahr}";
  echo "erstellen...";
  /usr/bin/mkdir -p ${archivVerzeichnis}/${jahr};
else
  echo " ";
  echo "Archivverzeichnis:";
  echo "${archivVerzeichnis}/${jahr}";
  echo "existiert bereits.";  
fi;

echo " "
echo "YUM-Paketdepot in ein 7z-Archiv (*.7z) packen..."
/usr/bin/7zr a -mx=0 ${archivVerzeichnis}/${jahr}/${paketDepot}_J${jahr}M${monat}T${tag}.7z ${paketDepotVerzeichnis}

echo " "
echo "7z-Archiv erstellt:   ${archivVerzeichnis}/${jahr}/${paketDepot}_J${jahr}M${monat}T${tag}.7z"

echo " "
echo "Ende von addUpdates.sh"
echo "-------------------------------------------------------------------------"
exit 0

Kontrolle

Die Installation der Sicherheitsupdates aus dem eigenen YUM-Paketdepot regelmässig kontrollieren:

# zypper list-patches --category=security
# zypper list-patches --category=security --all

Alternativ kann auch YAST2-Online-Updater (YOU) für die Kontrolle eingesetzt werden.

Start von YOU: # you
Installation von YOU: # zypper install yast2-online-update-frontend

Diese Behauptung scheint mir übertrieben. Zumindest trifft sie für die von mir installierten und administrierten Leap- und Tumbleweed-Systeme nicht zu. Ich nutze beide Varianten intensiv seit 2014 und bin noch nie in die Verlegenheit gekommen, ein Sicherheitsupdate deinstallieren zu müssen. Falls ich mich täusche waren die Auswirkungen so gering, dass ich die Angelegenheit einfach vergessen habe.