Softwareupdates (im Allgemeinen)

[GrandDixence2]

Linux-Administrator:Innen testen alle Sicherheitsupdates in der Testumgebung ausgiebig, bevor die Produktivumgebung mit diesen neuen Sicherheitsupdates versorgt wird. Siehe dazu:

snapper ein verzeichnis ausschliessen.

Backups sollten regelmässig ab einem virenfreien Bootmedium erstellt werden. Moderne USB-Wechselmedien sind so schnell, dass inkrementelle und differenzielle Backups überflüssig sind. Also in Privathaushalten immer brav und regelmässig Vollbackups auf USB-Wechselmedien erstellen. Siehe dazu: https://community.upc.ch/d/19812-drosselung-bei-grossen-downloads/4 Snapshots sind nützlich um rasch und unkompliziert versehentlich modifzierte oder gelöschte Dateien und Verzeichnisse wiederherzustellen…

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.

SUSE Manager: Verwaltung Ihrer softwaredefinierten...

b) Einsatz des kostenlosen Uyuni. Der SUSE Manager basiert auf der kostenlosen Software Uyuni.

Uyuni

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

• Teil 1
  https://www.youtube.com/watch?v=uYizgKZf8CY

• Teil 2
  https://www.youtube.com/watch?v=xoK1Lgbopbw

• Teil 3
  https://www.youtube.com/watch?v=LVBy5pPwTJs

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

Creating a YUM Repository and Publishing it with SMT

How to configure local customised repository for zypper based installation in...

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:

About Patching: What is a Patch in SLE and 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:

ffmpeg-4 und libaom-av1

Liebe Community! Ich möchte gern endlich den av1 codec (encode) in ffmpeg zum laufen kriegen. Meine Version ist 4.4, aktuell , von Packman: Version in zypper: Informationen zu Paket ffmpeg-4: Repository : Packman_15.3 Name : ffmpeg-4 Version : 4.4-pm153.2.9 Arch : x86_64 Anbieter : http://packman.links2linux.de Installierte Größe : 2,2 MiB Installiert : Ja Status : aktuell ffmpeg version 4.4 Copyright (c) 2…

• 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