Nota

Automatizza l'applicazione di patch per Apache Tomcat o una tecnologia di terze parti con OCI Fleet Application Management

Introduzione

Il servizio Oracle Cloud Infrastructure (OCI) Fleet Application Management consente ai team IT di automatizzare la ricerca automatica del software e le operazioni di patch per qualsiasi software distribuito in OCI. Il servizio fornisce runbook predefiniti per la ricerca e l'applicazione di patch alle tecnologie Oracle, tra cui Oracle WebLogic Server, Oracle Linux e altro ancora. Inoltre, i runbook personalizzati e le funzionalità Bring Your Own Product consentono di definire il prodotto o le tecnologie da scoprire e applicare automaticamente le patch al servizio.

In questo tutorial, stiamo utilizzando Apache Tomcat come esempio di una popolare tecnologia di terze parti che potrebbe essere necessario applicare patch. Le sezioni riportate di seguito forniscono istruzioni dettagliate ed esempi di codice riutilizzabili che consentono di aggiungere Apache Tomcat per la ricerca automatica e l'applicazione delle patch mediante OCI Fleet Application Management. È possibile utilizzare lo stesso processo per qualsiasi prodotto di terze parti a cui applicare le patch con il servizio.

Nota: il processo viene descritto utilizzando la console OCI, ma è anche possibile utilizzare l'interfaccia della riga di comando di Oracle Cloud Infrastructure (OCI CLI) o l'API. Per informazioni su OCI Fleet Application Management, vedere Fleet Application Management.

Introduzione all'applicazione di patch ad Apache Tomcat

La funzionalità Bring Your Own Product facilita l'integrazione di nuovi prodotti all'interno di OCI Fleet Application Management, come software, tecnologie o componenti applicativi di terze parti. Questa funzionalità consente di centralizzare la conformità delle patch e altre operazioni del ciclo di vita tra i vari componenti utilizzando il servizio.

Utilizzando la funzionalità Bring Your Own Product, creerai prima il tuo prodotto personalizzato nel servizio insieme ai suoi criteri di conformità e alle patch disponibili. Successivamente, utilizzando runbook personalizzati, creerai sia la ricerca automatica che i runbook di applicazione delle patch, consentendoti di automatizzare la gestione della conformità in futuro.

Obiettivi

Task 1: Creare un prodotto

  1. Eseguire il login alla console OCI, passare a Osservabilità e gestione e selezionare Gestione applicazioni flotta.

  2. Fare clic su Amministrazione.

  3. In Gestione metadati, fare clic su Prodotti e su Crea prodotto.

    Creazione prodotto 1

  4. Immettere le informazioni seguenti relative al nuovo prodotto.

    • Nome prodotto: immettere il nome del prodotto, evitando informazioni riservate quali le chiavi e così via.
    • Versione/i: immettere la versione.
    • Tipi di patch (Opzionale): selezionare il tipo di patch.
    • Prodotti compatibili (Facoltativo): aggiungere prodotti compatibili.
    • Componenti (Facoltativo): selezionare i componenti.
    • Nomi credenziali (Facoltativo): selezionare il nome della credenziale.

    Creazione prodotto 2

Task 2: definire una regola dei criteri di conformità delle patch

Un criterio di conformità delle patch software viene creato automaticamente per ogni nuovo prodotto. Il criterio predefinito non contiene regole dei criteri. È possibile modificare il criterio per aggiungere regole per specificare la condizione per valutare se una destinazione specifica è conforme (se true) o non conforme (else). È possibile utilizzare vari attributi prodotto per definire le regole, ad esempio la versione del prodotto, il tipo di patch, la severità della patch, i criteri di selezione delle patch e il periodo di tolleranza. Lo stato di conformità delle patch viene indicato come indeterminato se non si creano regole dei criteri.

  1. Andare a OCI Console, andare a Amministrazione e fare clic su Criterio di conformità.

  2. Selezionare il criterio di conformità del prodotto da modificare. (Sintassi: Product name Compliance Policy).

  3. Fare clic su Crea regola dei criteri.

  4. Immettere la versione del prodotto e gli altri attributi da utilizzare nella condizione.

    Regola dei criteri di conformità 1

    Ad esempio, le regole dei criteri possono avere la seguente definizione:

    • Nome regola: immettere Apache Tomcat.
    • Versione prodotto: selezionare 10.1 e versioni successive.
    • Tipo di patch: selezionare Patch critica.
    • Gravità: selezionare CriticalPatch.
    • Selezione patch: selezionare Livello patch.

    Regola dei criteri di conformità 2

Task 3: Creare metadati patch e caricare la patch

Creare i metadati della patch per semplificare l'applicazione delle patch future per il prodotto aggiunto. Dovresti quindi caricare le patch disponibili in OCI Object Storage. A seconda della tecnologia e dei tipi di patch disponibili per il nuovo prodotto, è possibile caricare una patch generica o pacchetti specifici per diverse configurazioni del sistema operativo.

  1. Andare a OCI Console, andare a Fleet Application Management, fare clic su Lifecycle Management, quindi su Patches.

  2. Fare clic su Carica patch.

  3. Immettere le informazioni riportate di seguito.

    • Nome patch: immettere un nome.
    • Prodotto: selezionare un prodotto.
    • Severità: selezionare una severità.
    • Selezionare Patch dipendenti per specificare le patch dipendenti a cui verrà applicata la patch insieme alla patch corrente. Ad esempio, nel caso di Apache Tomcat, la seguente patch può essere scaricata come apache-tomcat-10.1.25.tar.gz da qui: Repository centrale: org/apache/tomcat/tomcat/10.1.25.

    Carica patch

Task 4: Creare un Runbook Discovery per un prodotto

Il servizio utilizza un runbook di discovery per identificare il software e la versione del prodotto aggiunto. Ad esempio, nel caso di Apache Tomcat, lo script runbook in Python per la ricerca e la raccolta di dettagli sulle istanze Apache Tomcat in un sistema può essere il seguente:

Task nello script Runbook di ricerca automatica

Lo script esegue i task riportati di seguito.

Analisi stratificata task chiave

  1. Individuare le istanze Tomcat Apache.

  2. Estrai i dettagli della versione Apache Tomcat.

    • Metodo (_get_details(path)):
      • Esegue lo script version.sh nella directory bin di ogni percorso Apache Tomcat.
      • Analizza l'output per estrarre i dettagli della chiave (ad esempio, il numero di versione) in un dizionario.
      • Gestisce gli errori: eventuali eccezioni durante l'esecuzione o l'analisi vengono ignorate in silenzio.
    • Output: restituisce un dizionario dei metadati Apache Tomcat (ad esempio, il numero del server).

  3. Recupera l'indicatore orario di modifica file.

    • Metodo _get_timestamp(file_path):
      • Verifica se un determinato file esiste e recupera l'ora dell'ultima modifica.
      • Formatta l'indicatore orario in formato dd-MMM-yyyy HH:mm:ss.
    • Output: restituisce l'indicatore orario formattato.

  4. Raccogliere i dettagli dell'ambiente Java.

    • Metodo _get_java_details():
      • Utilizza i comandi di sistema per recuperare la versione Java e il percorso della home Java.
        • Versione Java: ottenuta con java -version.
        • Percorso della home Java: estratto dalle proprietà di runtime java.
    • Output: restituisce un dizionario con java_version e java_home.

  5. Creare un dizionario istanza dettagliato.

    • Metodo _instance(path):
      • Costruisce un dizionario che rappresenta una singola istanza Apache Tomcat.
        • Dettagli prodotto: nome, versione, percorso di destinazione e così via.
        • Patch installate: include la versione e la data dell'ultima modifica della directory.
        • Proprietà Java: include java_version e java_home.
    • Output: restituisce un dizionario strutturato per l'istanza Apache Tomcat.

  6. Trova e aggrega tutte le istanze.

    • Metodo _discovery_tomcat():
      • Chiama _get_all_tomcats() per trovare i percorsi Apache Tomcat.
      • Esegue l'iterazione su ogni percorso e chiama _instance(path) per raccogliere i dettagli.
      • Aggrega tutte le istanze in una lista di destinazioni.
    • Output: restituisce un dizionario con tutte le destinazioni trovate.

  7. Genera output.

    • Scrive i dettagli Apache Tomcat trovati in un file JSON.
      • Posizione: /opt/fams/.scripts/tomcat_discovery.json.
      • Formato: JSON ben stampato.
    • Stampa inoltre l'oggetto JSON nella console per una visibilità immediata.

Flusso script

  1. Individuare le istanze Apache Tomcat: il metodo _get_all_tomcats() esegue la scansione del file system.

  2. Recupera dettagli per ogni istanza: i metodi _get_details() e _instance() estraggono i metadati pertinenti.

  3. Raccogliere i dettagli Java: il metodo _get_java_details() recupera le proprietà dell'ambiente Java.

  4. Dati aggregati: il metodo _discovery_tomcat() combina le informazioni per tutte le istanze.

  5. Genera output: i risultati vengono salvati in formato JSON e stampati.

    Output di esempio:

    {

    "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. Gestione errori:

    • Errore silenzioso per la maggior parte delle eccezioni (ad esempio, file mancanti, errori di comando).
    • Questo approccio impedisce che lo script termini prematuramente, ma potrebbe oscurare gli errori durante l'esecuzione.

Esempio: script di ricerca automatica Apache Tomcat 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())

Dopo aver gestito tutti gli errori, i prodotti vengono associati a una o più flotte per automatizzare la ricerca automatica e le operazioni. Una volta che un prodotto è incluso nell'elenco di utenti consentiti per una flotta, il relativo runbook di ricerca automatica predefinito individuerà e aggiornerà automaticamente l'inventario software con le destinazioni del prodotto distribuito in tutte le risorse gestite.

Per creare un runbook, procedere come segue.

  1. Andare a OCI Console, andare a Gestione applicazioni flotta e fare clic su Azioni e controlli.

  2. Fare clic su Runbook e su Crea runbook.

  3. Immettere Nome, Descrizione, Operazione ciclo di vita, Tipo di registro di esecuzione e selezionare Tipo di sistema operativo e Tempo di completamento stimato.

    Creazione Runbook 1

  4. Crea il tuo runbook utilizzando il visual designer, carica un file YAML o JSON o fai riferimento al tuo script di automazione esistente tramite task di script Bash o Python all'interno del runbook. Ad esempio, l'esempio fornito è un runbook per scoprire Apache Tomcat.

    Creazione Runbook 2

  5. Per i runbook di tipo discovery, selezionare Contrassegna questo come task di output di ricerca automatica per consentire al servizio di leggere e analizzare l'output del task per popolare l'inventario software.

    Nota: il servizio può analizzare l'output solo se il formato dell'output è basato sul modello di output di ricerca automatica.

    Task di output ricerca automatica

    Di seguito è riportato l'output JSON (runbook\_Apache Tomcat\_discovery.json) per il prodotto.

    {
  "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. Aggiungere altri task per personalizzare il runbook in base alle esigenze.

    Modifica attività

Task 5: Creare un Runbook per l'applicazione di una patch

Fare riferimento al task 4 per creare un runbook personalizzato con la sequenza di applicazione delle patch.

Dopo aver creato un prodotto con le patch disponibili e la logica di ricerca automatica predefinita, è ora possibile creare un runbook per l'applicazione delle patch che includa la sequenza di automazione specifica di questa tecnologia e del processo IT della propria organizzazione. Quindi, definirete una pianificazione di manutenzione per definire quando il runbook verrà attivato per applicare patch alle destinazioni non conformi identificate nella vostra flotta.

Di seguito è riportato lo script Bash (apache_tomcat_patching.sh) che automatizza il processo di aggiornamento di un'installazione Apache Tomcat. Inoltre, è possibile trovare i task associati allo script.

  1. Inizializza variabili

    • target_path: questa estrazione viene eseguita da un file target.json nella directory DATA_DIR utilizzando jq.
    • patches_file: questa variabile può essere utilizzata per identificare in modo dinamico l'ultimo file patches.json del sistema.
    • patch_url: specifica la directory per le patch (/opt/fams/wls_patch).

  2. Visualizza e analizza dettagli patch: leggere il contenuto del file patches.json per:

    • Per estrarre la versione della patch richiesta (required_version).
    • Determinare il nome del file della patch (file_name).

  3. Controlla file necessari

    • apache_tomcat_functions.sh:
      • Verificare la presenza di uno script di supporto (apache_tomcat_functions.sh).
      • Se il file risulta mancante, lo script viene chiuso con un errore.
    • Convalida percorso destinazione:
      • Verificare che la directory target_path esista.
      • Se non esiste, lo script viene chiuso con un errore.

  4. Verifica la versione corrente: eseguire lo script version.sh di Apache Tomcat per recuperare la versione attualmente installata (curr_version).

  5. Preparazione per un upgrade

    • Eseguire il backup dell'installazione esistente: chiamare create_backup per eseguire il backup dell'installazione Apache Tomcat esistente.
    • Stop Tomcat: arrestare Apache Tomcat utilizzando una funzione (stop_tomcat).

  6. Aggiornamento dell'installazione Tomcat Apache

    • Estrazione di una nuova versione: estrarre il nuovo pacchetto Apache Tomcat (file_name) nella directory di destinazione.
    • Copia file di configurazione:
      • Copiare i file critici (ad esempio, configurazione, log) dalla vecchia installazione in una nuova utilizzando copy_main_files.
      • Gestire gli errori durante questo passo ripristinando il backup.
    • Rinomina e finalizza: rinominare la nuova directory per sostituire la vecchia directory di installazione.

  7. Convalida e riavvia

    • Verificare l'aggiornamento: controllare la versione aggiornata eseguendo di nuovo version.sh.
    • Riavviare Apache Tomcat: avviare Apache Tomcat utilizzando start_tomcat.

  8. Gestisci errore

    • Fornire messaggi di errore significativi in varie fasi (ad esempio, file mancanti, directory non trovata, errori di aggiornamento).
    • Eseguire il rollback delle modifiche in caso di errore delle operazioni critiche, ad esempio la copia dei file o la ridenominazione delle directory.

Le funzioni chiave utilizzate sono:

Descrizione

Lo script fornisce un approccio strutturato e automatizzato per l'aggiornamento di un'istanza Apache Tomcat, la riduzione dei tempi di inattività e la garanzia di un meccanismo di rollback in caso di errore. Si basa sulle funzioni predefinite (apache_tomcat_functions.sh) per gestire attività come l'arresto o l'avvio di Apache Tomcat e la gestione dei file.

Di seguito è riportato lo script Bash (apache\_tomcat\_patching.sh) di esempio con i metodi di applicazione delle patch.

\#
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"
}

Task 6: Creare una flotta

Crea una flotta e inserisci il tuo prodotto nella lista di inclusione correlata per scoprire il suo inventario software, conoscere lo stato di conformità delle patch software e correggere la conformità delle patch software.

  1. Andare alla console OCI, andare a Gestione applicazioni flotta, Flotta e fare clic su Crea flotta.

  2. Immettere il nome e la descrizione per la flotta e aggiungere risorse.

  3. Abilita la conferma automatica delle risorse della destinazione.

Task 7: Correggere la conformità alle patch software

Fare clic su Correggi ora per correggere la conformità delle patch software per una flotta nella relativa pagina dei dettagli o creare una pianificazione dalla pagina Pianificazioni di Gestione del ciclo di vita.

Se si fa clic su Correggi ora, il job di conformità verrà eseguito nei prossimi 15 minuti, mentre se si seleziona l'opzione di pianificazione nella pagina Programmi, è possibile creare un job per il futuro o impostare una pianificazione ricorsiva. Definendo una pianificazione di manutenzione, specificare quando verrà attivato il runbook per applicare patch alle destinazioni non conformi identificate nella flotta.

Conferme

Altre risorse di apprendimento

Esplora altri laboratori su docs.oracle.com/learn o accedi a più contenuti gratuiti sulla formazione su Oracle Learning YouTube channel. Inoltre, visita education.oracle.com/learning-explorer per diventare un Oracle Learning Explorer.

Per la documentazione del prodotto, visita l'Oracle Help Center.