Hinweis:

Automatisieren Sie das Patching für Apache Tomcat oder eine Technologie von Drittanbietern mit OCI Fleet Application Management

Einführung

Mit dem Oracle Cloud Infrastructure (OCI) Fleet Application Management-Service können IT-Teams Software-Discovery und Patchvorgänge für jede in OCI bereitgestellte Software automatisieren. Der Service bietet vordefinierte Runbooks für das Erkennen und Patchen von Oracle-Technologien, einschließlich Oracle WebLogic Server, Oracle Linux und mehr. Außerdem können Sie mit den benutzerdefinierten Runbooks und den Funktionen Bring Your Own Product definieren, dass Ihr Produkt oder Ihre Technologien automatisch vom Service erkannt und gepatcht werden.

In diesem Tutorial verwenden wir Apache Tomcat als Beispiel für eine beliebte Drittanbietertechnologie, die Sie möglicherweise häufig patchen müssen. Die folgenden Abschnitte enthalten Schritt-für-Schritt-Anweisungen und wiederverwendbare Codebeispiele, die Sie beim Hinzufügen von Apache Tomcat zur automatischen Erkennung und Einspielen von Patches mit OCI Fleet Application Management unterstützen. Sie können denselben Prozess für jedes Drittanbieterprodukt verwenden, das Sie mit dem Service patchen möchten.

Hinweis: Wir beschreiben den Prozess mit der OCI-Konsole. Sie können jedoch auch die Oracle Cloud Infrastructure-Befehlszeilenschnittstelle (OCI-CLI) oder API verwenden. Informationen zum OCI Fleet Application Management finden Sie unter Flottenanwendungsmanagement.

Erste Schritte mit dem Patching von Apache Tomcat

Die Funktion Bring Your Own Product erleichtert die Integration neuer Produkte in OCI Fleet Application Management, wie Software, Technologien oder Anwendungskomponenten von Drittanbietern. Diese Funktion ermöglicht die Zentralisierung der Patchcompliance und anderer Lebenszyklusvorgänge über diese verschiedenen Komponenten hinweg mit dem Service.

Mit der Funktion Bring Your Own Product erstellen Sie zuerst Ihr benutzerdefiniertes Produkt im Service zusammen mit der Compliance-Policy und den verfügbaren Patches. Als Nächstes erstellen Sie mit benutzerdefinierten Runbooks sowohl die Discovery- als auch die Patching-Runbooks, sodass Sie die Complianceverwaltung in Zukunft automatisieren können.

Ziele

Aufgabe 1: Produkt erstellen

  1. Melden Sie sich bei der OCI-Konsole an, navigieren Sie zu Beobachtbarkeit und Management, und wählen Sie Flottenanwendungsmanagement aus.

  2. Klicken Sie auf Administration.

  3. Klicken Sie unter Metadatenverwaltung auf Produkte und Produkt erstellen.

    Produkterstellung 1

  4. Geben Sie die folgenden Informationen für das neue Produkt ein.

    • Produktname: Geben Sie den Produktnamen ein, und vermeiden Sie vertrauliche Informationen wie Schlüssel usw.
    • Version(en): Geben Sie die Version ein.
    • Patchtypen (Optional): Wählen Sie den Patchtyp aus.
    • Kompatible Produkte (Optional): Fügen Sie kompatible Produkte hinzu.
    • Komponenten (Optional): Wählen Sie Komponenten aus.
    • Zugangsdatennamen (Optional): Wählen Sie den Zugangsdatennamen aus.

    Produkterstellung 2

Aufgabe 2: Regel für Patchcompliance-Policys definieren

Für jedes neue Produkt wird automatisch eine Compliance-Policy für Softwarepatches erstellt. Die Standard-Policy enthält keine Policy-Regeln. Sie können die Policy bearbeiten, um Regeln hinzuzufügen und die Bedingung anzugeben, die ausgewertet werden soll, wenn ein bestimmtes Ziel konform (wenn wahr) oder nicht konform (else) ist. Mit verschiedenen Produktattributen können Sie die Regeln definieren, z.B. Produktversion, Patch-Typ, Patch-Dringlichkeit, Patch-Auswahlkriterien und Verlängerungsfrist. Der Patchcompliancestatus wird als Unbestimmt gemeldet, wenn Sie keine Policy-Regeln erstellen.

  1. Gehen Sie zur OCI-Konsole, navigieren Sie zu Administration, und klicken Sie auf Compliance-Policy.

  2. Wählen Sie die Compliance-Policy des Produkts aus, das Sie ändern müssen. (Syntax: Product name Compliance Policy).

  3. Klicken Sie auf Policy-Regel erstellen.

  4. Geben Sie die Produktversion und andere Attribute ein, die in der Bedingung verwendet werden sollen.

    Compliance-Policy-Regel 1

    Die Policy-Regeln können beispielsweise die folgende Definition aufweisen:

    • Regelname: Geben Sie Apache Tomcat ein.
    • Produktversion: Wählen Sie 10.1 und höher aus.
    • Patchtyp: Wählen Sie Kritischer Patch aus.
    • Schweregrad: Wählen Sie CriticalPatch aus.
    • Patchauswahl: Wählen Sie Patchebene aus.

    Compliance-Policy-Regel 2

Aufgabe 3: Patchmetadaten erstellen und Patch hochladen

Erstellen Sie die Patchmetadaten, um zukünftiges Patching für das hinzugefügte Produkt zu vereinfachen. Anschließend sollten Sie die verfügbaren Patches in OCI Object Storage hochladen. Je nach Technologie und den verfügbaren Patches für Ihr neues Produkt können Sie einen generischen Patch oder bestimmte Packages für verschiedene Betriebssystemkonfigurationen hochladen.

  1. Navigieren Sie zur OCI-Konsole, navigieren Sie zu Flottenanwendungsmanagement, und klicken Sie auf Lifecycle Management, Patches.

  2. Klicken Sie auf Patch hochladen.

  3. Geben Sie folgende Informationen ein.

    • Patchname: Geben Sie einen Namen ein.
    • Produkt: Wählen Sie ein Produkt aus.
    • Schweregrad: Wählen Sie einen Schweregrad aus.
    • Wählen Sie Abhängige Patches aus, um die abhängigen Patches anzugeben, die zusammen mit dem aktuellen Patch gepatcht werden sollen. Beispiel: Bei Apache Tomcat kann der folgende Patch als apache-tomcat-10.1.25.tar.gz von hier heruntergeladen werden: Central Repository: org/apache/tomcat/tomcat/10.1.25.

    Patch zum Hochladen

Aufgabe 4: Discovery-Runbook für ein Produkt erstellen

Der Service verwendet ein Discovery Runbook, um die Software und Version des hinzugefügten Produkts zu identifizieren. Beispiel: Im Fall von Apache Tomcat kann das Runbook-Skript in Python zum Erkennen und Sammeln von Details zu Apache Tomcat-Instanzen auf einem System wie folgt aussehen:

Aufgaben im Discovery Runbook-Skript

Das Skript führt folgende Schritte aus:

Aufschlüsselung wichtiger Aufgaben

  1. Suchen Sie Apache Tomcat-Instanzen.

  2. Apache Tomcat-Versionsdetails extrahieren.

    • Methode (_get_details(path)):
      • Führt das Skript version.sh im Bin-Verzeichnis jedes Apache Tomcat-Pfads aus.
      • Parst die Ausgabe, um Schlüsseldetails (z.B. Versionsnummer) in ein Dictionary zu extrahieren.
      • Behandelt Fehler: Alle Ausnahmen während der Ausführung oder des Parsingvorgangs werden stillschweigend ignoriert.
    • Ausgabe: Gibt ein Dictionary mit Apache Tomcat-Metadaten zurück (z.B. Servernummer).

  3. Zeitstempel für Dateiänderung abrufen.

    • Methode _get_timestamp(file_path):
      • Prüft, ob eine bestimmte Datei vorhanden ist, und ruft die letzte Änderungszeit ab.
      • Formatiert den Zeitstempel im Format dd-MMM-yyyy HH:mm:ss.
    • Ausgabe: Gibt den formatierten Zeitstempel zurück.

  4. Java-Umgebungsdetails erfassen

    • Methode _get_java_details():
      • verwendet Systembefehle zum Abrufen der Java-Version und des Java Home-Pfads.
        • Java-Version: Wird mit java -version abgerufen.
        • Java Home-Pfad: Aus den Java-Laufzeiteigenschaften extrahiert.
    • Ausgabe: Gibt ein Dictionary mit java_version und java_home zurück.

  5. Erstellen Sie ein detailliertes Instanz-Dictionary.

    • Methode _instance(path):
      • Erstellt ein Dictionary, das eine einzelne Apache Tomcat-Instanz darstellt.
        • Produktdetails: Name, Version, Zielpfad usw.
        • Installierte Patches: Enthält die Version und das Datum der letzten Änderung des Verzeichnisses.
        • Java-Eigenschaften: Umfasst java_version und java_home.
    • Ausgabe: Gibt ein strukturiertes Dictionary für die Apache Tomcat-Instanz zurück.

  6. Ermitteln und aggregieren Sie alle Instanzen.

    • Methode _discovery_tomcat():
      • Ruft _get_all_tomcats() auf, um Apache Tomcat-Pfade zu suchen.
      • Iteriert über jeden Pfad und ruft _instance(path) auf, um Details zu erfassen.
      • Aggregiert alle Instanzen in einer Zielliste.
    • Ausgabe: Gibt ein Dictionary mit allen erkannten Zielen zurück.

  7. Ausgabe generieren.

    • Schreibt die ermittelten Apache Tomcat-Details in eine JSON-Datei.
      • Speicherort: /opt/fams/.scripts/tomcat_discovery.json.
      • Format: Pretty-printed JSON.
    • Druckt außerdem das JSON-Objekt zur sofortigen Sichtbarkeit auf der Konsole.

Skriptablauf

  1. Apache Tomcat-Instanzen suchen: Die Methode _get_all_tomcats() scannt das Dateisystem.

  2. Details für jede Instanz abrufen: Die Methoden _get_details() und _instance() extrahieren relevante Metadaten.

  3. Java-Details erfassen: Die Methode _get_java_details() ruft die Java-Umgebungseigenschaften ab.

  4. Daten aggregieren: Die Methode _discovery_tomcat() kombiniert die Informationen für alle Instanzen.

  5. Ausgabe generieren: Die Ergebnisse werden im JSON-Format gespeichert und gedruckt.

    Beispielausgabe: 

    {

    "targets": [

        {
            "product": "Tomcat",
            "version": "9.0",
            "target\_name": "/usr/local/tomcat",
            "resource\_name": "",
            "components": [],
            "available\_patches": [],
            "installed\_patches": [
                {
                    "patch\_name": "9.0.50",
                    "patch\_applied\_dt": "19-Nov-2024 12:45:30",
                    "patch\_description": "",
                    "patch\_type": "",
                    "severity": ""
                }
            ],
            "properties": [
                {
                    "property\_name": "java\_home",
                    "property\_value": "/usr/lib/jvm/java-11-openjdk"
                },
                {
                    "property\_name": "java\_version",
                    "property\_value": "11"
                }
            ]
        }
    ]
}

  6. Fehlerhandling:

    • Silent-Fehler bei den meisten Ausnahmen (z. B. fehlende Dateien, Befehlsfehler).
    • Dieser Ansatz verhindert, dass das Skript vorzeitig beendet wird, kann jedoch Fehler während der Ausführung verdecken.

Beispiel: Apache Tomcat Discovery-Skript in Python

import json
import os
import subprocess
import datetime

class TOMCAT:
    def \_get\_all\_tomcats(self):
        command = ['find', '/', '-type', 'd', '-name', 'webapps']
        sp = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        tomcat\_paths = sp.stdout.decode("utf-8").strip().replace('/webapps', '').split('\n')
        tomcat\_paths=[path for path in tomcat\_paths if not 'backup' in path]
        return tomcat\_paths
    def \_get\_details(self, path):
        tomcat\_details = dict()
        try:
            command = f'{path}/bin/version.sh'
            sp = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            stdout, stderr = sp.communicate(timeout=10)
            info\_list = stdout.decode("utf-8")
            for line in info\_list.splitlines():
                if ':' in line:
                    key, value = line.split(':', 1)
                    tomcat\_details[key.strip()] = value.strip()
            return tomcat\_details
        except Exception as E:
           pass
    def \_get\_timestamp(self, file\_path):
        if os.path.exists(file\_path):
            timestamp = os.path.getmtime(file\_path)
            modified\_date = datetime.datetime.fromtimestamp(timestamp).strftime("%d-%b-%Y %H:%M:%S %z")
            return modified\_date
    def \_get\_java\_details(self):
        try:
            java\_details = dict()
            command = "java -version 2>&1 | head -n 1"
            sp = subprocess.run(command, shell=True, stdout=subprocess.PIPE)
            java\_version = sp.stdout.decode("utf-8").split('"')[1]
            # Getting Java Home
            command = "java -XshowSettings:properties -version 2>&1    | sed '/^[[:space:]]\*java\.home/!d;s/^[[:space:]]\*java\.home[[:space:]]\*=[[:space:]]\*//'"
            sp = subprocess.run(command, shell=True, stdout=subprocess.PIPE)
            java\_home = sp.stdout.decode("utf-8").replace("\n", '')
            java\_details['java\_home'] = java\_home
            java\_details['java\_version'] = java\_version.split('\_')[0]
            return java\_details
        except Exception as E:
            pass
    def \_instance(self, path):
        properties = []
        tomcat\_details = self.\_get\_details(path)
        instance = {"product": "Tomcat"}
        instance.update({"version": '.'.join(tomcat\_details['Server number'].split('.')[:2])})
        instance.update({"target\_name": path})
        instance.update({"resource\_name": ""})
        instance.update({"components": []})
        instance.update({"available\_patches": []})
        installed\_patches = [
            {
                "patch\_name": tomcat\_details['Server number'],
                "patch\_applied\_dt": self.\_get\_timestamp(path),
                "patch\_description": "",
                "patch\_type": "",
                "severity": ""
            }
        ]
        instance.update({"installed\_patches": installed\_patches})
        for key, value in self.\_get\_java\_details().items():
            properties.append({"property\_name": key, "property\_value": value})
        instance.update({"properties": properties})
        return instance
    def \_discovery\_tomcat(self):
        targets = []
        tomcat\_paths = self.\_get\_all\_tomcats()
        for path in tomcat\_paths:
            instances = targets.append(self.\_instance(path))
        discovery\_output = ({"targets": targets})
        return discovery\_output
if \_\_name\_\_ == "\_\_main\_\_":
    SCRIPTS\_DIR = "/opt/fams/.scripts"
    os.makedirs(SCRIPTS\_DIR, exist\_ok=True)
    tomcat = TOMCAT()
    tomcat\_output = tomcat.\_discovery\_tomcat()
    json\_obj = json.dumps(tomcat\_output, indent=4)
    print(json\_obj)
    with open("{}/tomcat\_discovery.json".format(SCRIPTS\_DIR), 'wb') as outfile:
        outfile.write(json\_obj.encode())

Nachdem alle Fehler behoben wurden, werden die Produkte mit einer Flotte oder mehreren Flotten verknüpft, um Discovery und Betrieb zu automatisieren. Sobald ein Produkt auf der Liste der zulässigen Benutzer für eine Flotte steht, findet und aktualisiert sein Standard-Discovery Runbook automatisch den Softwarebestand mit Zielen des bereitgestellten Produkts über alle verwalteten Ressourcen hinweg.

So erstellen Sie ein Runbook:

  1. Gehen Sie zur OCI-Konsole, navigieren Sie zu Flottenanwendungsmanagement, und klicken Sie auf Aktionen und Steuerelemente.

  2. Klicken Sie auf Runbooks und Runbook erstellen.

  3. Geben Sie Name, Beschreibung, Lebenszyklusvorgang, Runbook-Typ ein, und wählen Sie Betriebssystemtyp und Geschätzte Abschlusszeit aus.

    Runbook-Erstellung 1

  4. Erstellen Sie Ihr Runbook mit dem visuellen Designer, laden Sie eine YAML- oder JSON-Datei hoch, oder referenzieren Sie Ihr vorhandenes Automatisierungsskript über Bash- oder Python-Skriptaufgaben im Runbook. Beispiel: Das bereitgestellte Beispiel ist ein Runbook zur Erkennung von Apache Tomcat.

    Runbook-Erstellung 2

  5. Wählen Sie für Runbooks mit Typ-Discovery die Option Als Discovery-Ausgabeaufgabe markieren aus, damit der Service die Ausgabe der Aufgabe lesen und parsen kann, um den Softwarebestand aufzufüllen.

    Hinweis: Der Service kann die Ausgabe nur dann parsen, wenn das Format der Ausgabe auf der Discovery-Ausgabevorlage basiert.

    Discovery-Ausgabeaufgabe

    Im Folgenden finden Sie die JSON-Ausgabe (runbook\_Apache Tomcat\_discovery.json) für das Produkt.

    {
  "id": "ocid1.famsrunbook.oc1.eu-frankfurt-1.xxxxxxxx",
  "displayName": "Apache Tomcat\_discovery",
  "description": null,
  "type": "USER\_DEFINED",
  "runbookRelevance": "PRODUCT",
  "operation": "DISCOVERY",
  "osType": "LINUX",
  "platform": "Apache Tomcat",
  "isDefault": false,
  "estimatedTime": "1",
  "lifecycleState": "INACTIVE",
  "lifecycleDetails": "{\"subState\":\"DRAFT\",\"message\":\"Draft runbook\"}",
  "timeCreated": "2024-11-19T13:03:20.376Z",
  "timeUpdated": "2024-11-19T13:03:20.376Z",
  "associations": {
    "tasks": [
      {
        "stepName": "Apache\_Tomcat\_discovery\_task",
        "associationType": "TASK",
        "taskRecordDetails": {
          "scope": "LOCAL",
          "executionDetails": {
            "executionType": "SCRIPT",
            "variables": null,
            "content": {
              "sourceType": "OBJECT\_STORAGE\_BUCKET",
              "namespaceName": "xxxxxx",
              "namespaceName": "xxxxxx",
              "bucketName": "demo\_bucket",
              "objectName": "apache\_tomcat\_discovery\_demo.zip",
              "checksum": "xxxxxxxxxxxxx"
            },
            "command": "unzip -o -q apache\_tomcat\_discovery\_demo.zip; chmod +x apache\_tomcat\_discovery.py ; python apache\_tomcat\_discovery.py",
            "credentials": []
          },
          "description": null,
          "platform": "Apache Tomcat",
          "isCopyToLibraryEnabled": false,
          "osType": "LINUX",
          "properties": {
            "numRetries": 0,
            "timeoutInSeconds": 3000
          },
          "isDiscoveryOutputTask": true,
          "isApplySubjectTask": false,
          "name": "Apache Tomcat\_discovery\_task"
        },
        "stepProperties": {
          "runOn": null,
          "condition": null,
          "actionOnFailure": "ABORT",
          "pauseDetails": null,
          "notificationPreferences": null
        },
        "outputVariableMappings": []
      }
    ],
    "groups": [
      {
        "type": "PARALLEL\_RESOURCE\_GROUP",
        "name": "Parallel\_resource\_container",
        "properties": {
          "runOn": null,
          "condition": null,
          "actionOnFailure": "ABORT",
          "pauseDetails": null,
          "notificationPreferences": null
        }
      }
    ],
    "executionWorkflowDetails": {
      "workflow": [
        {
          "groupName": "Parallel\_resource\_container",
          "type": "PARALLEL\_RESOURCE\_GROUP",
          "steps": [
            {
              "type": "TASK",
              "stepName": "Apache\_Tomcat\_discovery\_task"
            }
          ]
        }
      ]
    },
    "rollbackWorkflowDetails": null,
    "version": "1.0"
  },
  "compartmentId": "xxxxxx",
  "region": "xxxxxxx",
  "freeformTags": {},
  "definedTags": {
    "Oracle-Tags": {
      "CreatedBy": "xxxxxx",
      "CreatedOn": "2024-11-08T15:48:59.329Z"
    }
  },
  "systemTags": {}
}

  6. Fügen Sie weitere Aufgaben hinzu, um Ihr Runbook nach Bedarf anzupassen.

    Aufgabe bearbeiten

Aufgabe 5: Runbook zum Einspielen eines Patches erstellen

In Aufgabe 4 wird beschrieben, wie Sie ein benutzerdefiniertes Runbook mit Ihrer Patching-Sequenz erstellen.

Nachdem Sie ein Produkt mit den verfügbaren Patches und der standardmäßigen Erkennungslogik erstellt haben, können Sie jetzt ein Runbook für das Patching erstellen, das die für diese Technologie spezifische Automatisierungssequenz und den IT-Prozess Ihres Unternehmens enthält. Anschließend definieren Sie einen Wartungsplan, um zu definieren, wann das Runbook ausgelöst wird, um nicht konforme Ziele zu patchen, die in Ihrer Flotte identifiziert werden.

Das Bash-Skript (apache_tomcat_patching.sh), mit dem das Upgrade einer Apache Tomcat-Installation automatisiert wird, lautet wie folgt. Außerdem finden Sie die Aufgaben, die dem Skript zugeordnet sind.

  1. Variablen initialisieren

    • target_path: Dieser Export aus einer target.json-Datei im Verzeichnis DATA_DIR mit jq.
    • patches_file: Mit dieser Variable kann die neueste patches.json-Datei im System dynamisch identifiziert werden.
    • patch_url: Gibt das Verzeichnis für Patches an (/opt/fams/wls_patch).

  2. Patchdetails anzeigen und parsen: Lesen Sie den Inhalt der Datei patches.json für Folgendes:

    • Um die erforderliche Patchversion zu extrahieren (required_version).
    • Bestimmt den Dateinamen des Patches (file_name).

  3. Erforderliche Dateien prüfen

    • apache_tomcat_functions.sh:
      • Stellen Sie sicher, dass ein Helper-Skript vorhanden ist (apache_tomcat_functions.sh).
      • Wenn die Datei fehlt, wird das Skript mit einem Fehler beendet.
    • Zielpfadvalidierung:
      • Stellen Sie sicher, dass das Verzeichnis target_path vorhanden ist.
      • Wenn es nicht vorhanden ist, wird das Skript mit einem Fehler beendet.

  4. Aktuelle Version prüfen: Führen Sie das Skript version.sh von Apache Tomcat aus, um die aktuell installierte Version abzurufen (curr_version).

  5. Upgrade vorbereiten

    • Vorhandene Installation sichern: Rufen Sie create_backup auf, um die vorhandene Apache Tomcat-Installation zu sichern.
    • Tomcat stoppen: Stoppen Sie Apache Tomcat mit einer Funktion (stop_tomcat).

  6. Apache Tomcat-Installation aktualisieren

    • Neue Version extrahieren: Extrahieren Sie das neue Apache Tomcat-Package (file_name) in das Zielverzeichnis.
    • Konfigurationsdateien kopieren:
      • Kopieren Sie kritische Dateien (z.B. Konfiguration, Logs) mit copy_main_files aus der alten Installation in eine neue.
      • Beheben Sie Fehler in diesem Schritt, indem Sie das Backup wiederherstellen.
    • Umbenennen und fertigstellen: Benennen Sie das neue Verzeichnis um, um das alte Installationsverzeichnis zu ersetzen.

  7. Validieren und neu starten

    • Upgrade prüfen: Prüfen Sie die upgegradete Version, indem Sie version.sh erneut ausführen.
    • Apache Tomcat neu starten: Starten Sie Apache Tomcat mit start_tomcat.

  8. Bearbeitungsfehler

    • Geben Sie aussagekräftige Fehlermeldungen in verschiedenen Phasen an (Beispiel: fehlende Dateien, Verzeichnis nicht gefunden, Upgradefehler).
    • Setzen Sie Änderungen zurück, wenn kritische Vorgänge nicht erfolgreich sind (z.B. Kopieren von Dateien oder Umbenennen von Verzeichnissen).

Folgende Hauptfunktionen werden verwendet:

Was bewirkt es?

Das Skript bietet einen strukturierten und automatisierten Ansatz für das Upgrade einer Apache Tomcat-Instanz, die Minimierung von Ausfallzeiten und die Gewährleistung eines Rollback-Mechanismus bei einem Ausfall. Sie basiert auf den vordefinierten Funktionen (apache_tomcat_functions.sh), um Aufgaben wie das Stoppen oder Starten von Apache Tomcat und die Dateiverarbeitung zu verwalten.

Im Folgenden finden Sie das Bash-(apache\_tomcat\_patching.sh-)Beispielskript mit den Methoden zum Einspielen von Patches.

\#
target\_path=$(cat ${DATA\_DIR}/target.json | jq -r '.target.target\_name')
patches\_file="$(find / -type f -name 'patches.json' | tail -1)"
patch\_url=/opt/fams/wls\_patch
\#
echo "Details of patches.json from path $patches\_file"
cat $patches\_file
required\_version=$(jq -r '.patches[0].name' $patches\_file)
file\_name=$(jq -r '.patches[0].location.object\_name' $patches\_file)
echo "Checking for tomcat\_functions.sh file "
if [ -f ./apache\_tomcat\_functions.sh ]; then
  source ./apache\_tomcat\_functions.sh
  echo -e "apache\_tomcat\_functions.sh file exists \n"
else
  echo "apache\_tomcat\_functions.sh file does not exist..Exiting"
  exit 1
fi
echo "Checking if Target Path $target\_path exists"
if [ ! -d "$target\_path" ]; then
  echo "$target\_path doesnt exist.....Exiting"
  exit 1
else
  echo "$target\_path exists"
fi
script\_dir=/opt/fams/.scripts/
echo "Target Directory: " $target\_path
echo "Target Version Download location: " $patch\_url
echo "Target Patch: " $required\_version
\# directories where tomcat is installed
curr\_version=$(sh $target\_path/bin/version.sh | grep 'Server number:' | awk '{print $3}')
echo "\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*"
tomcat\_vars
if [ $curr\_version != "" ]; then
  echo -e "Version $curr\_version is currently installed in Target Path $target\_path \n"
  dir\_path=$(basename "$target\_path") #old tomcat directory
  #file\_name=$(basename "$patch\_url")  #zip filename for new version
  #Stopping tomcat
  stop\_tomcat $target\_path
  #killing process
  #kill\_tomcat
  echo "\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*"
  echo -e "Upgrading Tomcat $curr\_version to patch $required\_version.................\n"
  # Backing old tomcat
  cd $target\_path/..
  create\_backup $dir\_path
  # Downloading New Tomcat Version
  #      echo -e "Downloading Tomcat version $required\_version.......................\n"
  #      download\_required\_version $patch\_url
  #      echo "\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*"
  #      # Extracting tomcat directories
  echo -e "Extracting Tomcat version from $file\_name file ......................."
  tar -xf "$patch\_url/$file\_name"
  echo -e "  COMPLETED : Extracted successfully \n"
  # Copying important files from old tomcat to new tomcat directories
  tomcat\_dir=$(basename "$file\_name" .tar.gz) # new tomcat directory
  echo -e "Copying important files from $dir\_path directory to $tomcat\_dir ......................."
  copy\_main\_files $backup\_dir $tomcat\_dir
  status=$?
  if [ $status -eq 0 ]; then
    # Renaming tomcat directory
    echo -e "Renaming $tomcat\_dir directory to $dir\_path......................."
    mv $tomcat\_dir $target\_path
  else
    echo -e "Process failed while Copying important files from $dir\_path directory to $tomcat\_dir.\n"
    mv $backup\_dir $dir\_path
    exit 1
  fi
  if [ $? -eq 0 ]; then
    upgraded\_version=$(sh $target\_path/bin/version.sh | grep 'Server number:' | awk '{print $3}')
    echo -e "  COMPLETED : Renaming directory \n"
    echo -e "Successfully upgraded tomcat to $upgraded\_version from $curr\_version \n"
    # Starting tomcat
    echo -e "Starting Tomcat......................."
    start\_tomcat $target\_path
  else
    echo -e "Process failed while renaming $tomcat\_dir directory to $target\_path.\n"
    exit 1
  fi
else
  echo -e "Required version is empty, Exiting \n"
  exit 1
fi
#done
stop\_tomcat(){
tomcat\_dir=$1
echo "Stopping Tomcat Service"
sh $tomcat\_dir/bin/shutdown.sh
}
start\_tomcat(){
tomcat\_dir=$1
echo "Starting Tomcat Service"
sh $tomcat\_dir/bin/startup.sh
}
kill\_tomcat(){
  myarray=( `ps aux | grep tomcat | awk '{print $2}'` )
  for i in "${myarray[@]}"
    do
      echo "Killing Process $i"
      kill -9 $i
  done
}
tomcat\_vars(){
\#  curr\_ver=$(jq --arg ident "$dir" -r '.targets[] | select(.target\_name == $ident) |.version' $script\_dir/tomcat\_discovery.json)
\#  echo "Current Version: "$curr\_version
  tomcat\_home=$(jq -r '.targets[].target\_name' $script\_dir/tomcat\_discovery.json)
  echo "Tomcat Home: "$tomcat\_home
}
create\_backup(){
  dir\_path=$1
\#  curr\_version=$2
  echo "  Backing up directory: $dir\_path"
  prefix=backup
  backup\_dir="${dir\_path}\_${prefix}"
  mkdir -p "$backup\_dir"
  cp -r  "$dir\_path"/\* "$backup\_dir"/
  if [ "$?" -eq 0 ]; then
    echo -e "  COMPLETED : Backup directory $backup\_dir created \n"
    rm -r "$dir\_path"
  fi
}
download\_required\_version(){
  download\_url=$1
  wget -nc $download\_url
}
copy\_main\_files(){
  old\_tomcat=$1
  new\_tomcat=$2
  cp -r ./$old\_tomcat/conf/\* ./$new\_tomcat/conf/
  cp -r ./$old\_tomcat/webapps/\*  ./$new\_tomcat/webapps/
  if [ "$?" -eq 0 ]; then
    echo -e "  COMPLETED : Copying files into directory \n"
    return 0  # Success
  else
    return 1  # Failure
  fi
}
copy\_rollback\_files(){
  old\_tomcat=$1
  new\_tomcat=$2
  cp -r $old\_tomcat/conf/\* /$new\_tomcat/conf/
  cp -r $old\_tomcat/webapps/\*  /$new\_tomcat/webapps/
  echo -e "  COMPLETED : Copying files into directory \n"
}
create\_rollback\_backup(){
  curr\_tomcat=$1
  rollback\_tomcat=$2
  echo "  Backing up directory: $dir\_path"
  prefix=$curr\_version
  backup\_dir="${curr\_tomcat}\_${prefix}"
  mkdir -p "$backup\_dir"
  cp -r  "$dir\_path"/\* "$backup\_dir"/
  echo -e "  COMPLETED : Backup directory $backup\_dir created \n"
  rm -r "$dir\_path"
}

Aufgabe 6: Flotte erstellen

Erstellen Sie eine Flotte, und bringen Sie Ihr Produkt auf die zugehörige Ausnahmeliste, um das Softwareinventar zu ermitteln, den Compliancestatus des Softwarepatches zu kennen und die Compliance des Softwarepatches zu beheben.

  1. Gehen Sie zur OCI-Konsole, navigieren Sie zu Flottenanwendungsmanagement, Flotten, und klicken Sie auf Flotte erstellen.

  2. Geben Sie den Namen und die Beschreibung für die Flotte ein, und fügen Sie Ressourcen hinzu.

  3. Aktivieren Sie die automatische Bestätigung der Zielressourcen.

Aufgabe 7: Beheben der Softwarepatchcompliance

Klicken Sie auf Jetzt beheben, um die Softwarepatchcompliance für eine Flotte auf der Detailseite zu beheben, oder erstellen Sie auf der Seite Zeitpläne des Lebenszyklusmanagements einen Zeitplan.

Wenn Sie auf Jetzt beheben klicken, wird der Compliancejob in den nächsten 15 Minuten ausgeführt. Wenn Sie die Zeitplanoption auf der Seite Zeitpläne auswählen, können Sie einen Job für die Zukunft erstellen oder einen rekursiven Zeitplan festlegen. Geben Sie durch Definieren eines Wartungsplans an, wann das Runbook ausgelöst werden soll, um nicht konforme Ziele zu patchen, die in Ihrer Flotte identifiziert werden.

Danksagungen

Weitere Lernressourcen

Sehen Sie sich andere Übungen zu docs.oracle.com/learn an, oder greifen Sie im Oracle Learning YouTube-Channel auf weitere kostenlose Lerninhalte zu. Besuchen Sie außerdem education.oracle.com/learning-explorer, um Oracle Learning Explorer zu werden.

Die Produktdokumentation finden Sie im Oracle Help Center.