Remarques :

Automatisez l'application de patches pour Apache Tomcat ou une technologie tierce avec OCI Fleet Application Management

Introduction

Le service Oracle Cloud Infrastructure (OCI) Fleet Application Management permet aux équipes informatiques d'automatiser le repérage de logiciels et les opérations de correctifs pour tous les logiciels déployés dans OCI. Le service fournit des runbooks prédéfinis pour le repérage et l'application de patches aux technologies Oracle, notamment Oracle WebLogic Server, Oracle Linux, etc. En outre, les runbooks personnalisés et les fonctionnalités d'utilisation de votre propre produit vous permettent de définir votre ou vos technologies à repérer et à corriger automatiquement par le service.

Dans ce tutoriel, nous utilisons Apache Tomcat comme exemple d'une technologie tierce populaire que vous pourriez souvent avoir besoin de corriger. Les sections suivantes fournissent des instructions détaillées et des exemples de code réutilisables pour vous aider à ajouter Apache Tomcat à repérer et à appliquer automatiquement des patches à l'aide d'OCI Fleet Application Management. Vous pouvez utiliser le même processus pour tout produit tiers auquel vous souhaitez appliquer des patches avec le service.

Remarque : nous décrivons le processus à l'aide de la console OCI, mais vous pouvez également utiliser l'API ou l'interface de ligne de commande Oracle Cloud Infrastructure (interface de ligne de commande OCI). Pour plus d'informations sur OCI Fleet Application Management, reportez-vous à Gestion des applications de parc.

Introduction à l'application de patches à Apache Tomcat

La fonctionnalité Utilisation de votre propre produit facilite l'intégration de nouveaux produits dans OCI Fleet Application Management, tels que les logiciels, technologies ou composants d'application tiers. Cette fonctionnalité permet de centraliser la conformité des correctifs et d'autres opérations de cycle de vie sur ces différents composants à l'aide du service.

A l'aide de la fonctionnalité Apportez votre propre produit, vous créerez d'abord votre produit personnalisé dans le service, ainsi que sa stratégie de conformité et les patches disponibles. Ensuite, à l'aide de classeurs personnalisés, vous allez créer les classeurs de repérage et d'application de patches, ce qui vous permettra d'automatiser la gestion de la conformité.

Objectifs

Tâche 1 : créer un produit

  1. Connectez-vous à la console OCI, accédez à Observation et gestion et sélectionnez Gestion des applications de parc.

  2. Cliquez sur Administration.

  3. Sous Gestion des métadonnées, cliquez sur Produits et sur Créer un produit.

    Création de produit 1

  4. Saisissez les informations suivantes pour le nouveau produit.

    • Nom du produit : entrez le nom du produit, en évitant les informations confidentielles telles que les clés, etc.
    • Version(s) : entrez la version.
    • Types de patch (facultatif) : sélectionnez le type de patch.
    • Produits compatibles (Facultatif) : ajoutez des produits compatibles.
    • Composants (Facultatif) : sélectionnez des composants.
    • Noms d'informations d'identification (facultatif) : sélectionnez le nom des informations d'identification.

    Création de produit 2

Tâche 2 : Définir une règle de stratégie de conformité des patches

Une stratégie de conformité des patches logiciels est créée automatiquement pour chaque nouveau produit. La stratégie par défaut ne contient aucune règle de stratégie. Vous pouvez modifier la stratégie pour ajouter des règles afin d'indiquer la condition à évaluer si une cible spécifique est conforme (si elle est vraie) ou non conforme (autre). Vous pouvez utiliser différents attributs de produit pour définir les règles, telles que la version du produit, le type de patch, la gravité du patch, les critères de sélection de patch et le délai de grâce. Si vous ne créez pas de règles de stratégie, le statut de conformité des patches est indéterminé.

  1. Accédez à la console OCI, accédez à Administration et cliquez sur Stratégie de conformité.

  2. Sélectionnez la stratégie de conformité du produit à modifier. (Syntaxe : Product name Compliance Policy).

  3. Cliquez sur Créer une règle.

  4. Entrez la version du produit et les autres attributs à utiliser dans la condition.

    Règle de politique de conformité 1

    Par exemple, les règles de stratégie peuvent avoir la définition suivante :

    • Nom de la règle : entrez Apache Tomcat.
    • Version du produit : sélectionnez 10.1 et versions supérieures.
    • Type de patch : sélectionnez Correctif critique.
    • Gravité : sélectionnez CriticalPatch.
    • Sélection de patch : sélectionnez Niveau de patch.

    Règle de politique de conformité 2

Tâche 3 : créer des métadonnées de patch et télécharger le patch

Créez les métadonnées de patch pour faciliter l'application future de patch pour le produit que vous avez ajouté. Vous devez ensuite télécharger les patches disponibles vers OCI Object Storage. Selon la technologie et les types de patchs disponibles pour votre nouveau produit, vous pouvez télécharger un patch générique ou des packages spécifiques pour différentes configurations de système d'exploitation.

  1. Accédez à la console OCI, accédez à Gestion des applications de parc, cliquez sur Gestion du cycle de vie, puis sur Patchs.

  2. Cliquez sur Télécharger le patch.

  3. Saisissez les informations suivantes .

    • Nom de patch : entrez un nom.
    • Produit : sélectionnez un produit.
    • Gravité : sélectionnez une gravité.
    • Sélectionnez Patches dépendants pour indiquer les patches dépendants qui seront appliqués avec le patch en cours. Par exemple, dans le cas d'Apache Tomcat, le patch suivant peut être téléchargé en tant que apache-tomcat-10.1.25.tar.gz à partir d'ici : Référentiel central : org/apache/tomcat/tomcat/10.1.25.

    Télécharger un patch

Tâche 4 : création d'un classeur de repérage pour un produit

Le service utilise un classeur de repérage pour identifier le logiciel et la version du produit ajouté. Par exemple, dans le cas d'Apache Tomcat, le script runbook en Python pour la découverte et la collecte de détails sur les instances Apache Tomcat sur un système peut être le suivant :

Tâches dans le script du classeur de repérage

Le script effectue les tâches suivantes :

Répartition des tâches clés

  1. Localisez les instances Apache Tomcat.

  2. Extrayez les détails de la version d'Apache Tomcat.

    • Méthode (_get_details(path)) :
      • Exécute le script version.sh dans le répertoire bin de chaque chemin Apache Tomcat.
      • Analyse la sortie pour extraire les détails de clé (par exemple, le numéro de version) dans un dictionnaire.
      • Gère les erreurs : toutes les exceptions au cours de l'exécution ou de l'analyse sont ignorées en mode silencieux.
    • Sortie : renvoie un dictionnaire de métadonnées Apache Tomcat (par exemple, numéro de serveur).

  3. Extraire l'horodatage de modification du fichier.

    • Méthode _get_timestamp(file_path) :
      • Vérifie si un fichier donné existe et extrait son heure de dernière modification.
      • Formate l'horodatage au format dd-MMM-yyyy HH:mm:ss.
    • Sortie : renvoie l'horodatage formaté.

  4. Collectez les informations relatives à l'environnement Java.

    • Méthode _get_java_details() :
      • Utilise des commandes système pour extraire la version de Java et le chemin du répertoire de base Java.
        • Version de Java : obtenue avec java -version.
        • Chemin du répertoire de base Java : extrait des propriétés d'exécution java.
    • Sortie : renvoie un dictionnaire avec java_version et java_home.

  5. Créez un dictionnaire d'instances détaillé.

    • Méthode _instance(path) :
      • Crée un dictionnaire représentant une seule instance Apache Tomcat.
        • Détails du produit : nom, version, chemin cible, etc.
        • Patchs installés : inclut la version et la date de dernière modification du répertoire.
        • Propriétés Java : inclut java_version et java_home.
    • Sortie : renvoie un dictionnaire structuré pour l'instance Apache Tomcat.

  6. Repérez et agrégez toutes les instances.

    • Méthode _discovery_tomcat() :
      • Appelle _get_all_tomcats() pour rechercher les chemins Apache Tomcat.
      • Effectue une itération sur chaque chemin et appelle _instance(path) pour collecter les détails.
      • Regroupe toutes les instances dans une liste de cibles.
    • Sortie : renvoie un dictionnaire avec toutes les cibles repérées.

  7. Générer une sortie.

    • Ecrit les détails Apache Tomcat découverts dans un fichier JSON.
      • Emplacement : /opt/fams/.scripts/tomcat_discovery.json.
      • Format : format JSON d'impression complète.
    • Affiche également l'objet JSON sur la console pour une visibilité immédiate.

Flux de script

  1. Localiser les instances Apache Tomcat : la méthode _get_all_tomcats() analyse le système de fichiers.

  2. Extraire les détails de chaque instance : les méthodes _get_details() et _instance() extraient les métadonnées pertinentes.

  3. Collecter les détails Java : la méthode _get_java_details() extrait les propriétés d'environnement Java.

  4. Agréger les données : la méthode _discovery_tomcat() combine les informations pour toutes les instances.

  5. Générer une sortie : les résultats sont enregistrés au format JSON et imprimés.

    Exemple de sortie :

    {

    "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. Gestion des erreurs :

    • Echec silencieux pour la plupart des exceptions (par exemple, fichiers manquants, erreurs de commande).
    • Cette approche empêche l'interruption prématurée du script, mais risque d'obscurcir les erreurs lors de l'exécution.

Exemple : script de découverte Apache Tomcat en 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())

Après avoir traité toutes les erreurs, les produits sont associés à une flotte ou à plusieurs flottes pour automatiser la découverte et les opérations. Une fois qu'un produit figure sur la liste des utilisateurs autorisés pour un parc, son classeur de repérage par défaut recherche et met automatiquement à jour l'inventaire logiciel avec les cibles du produit déployé sur toutes les ressources gérées.

Pour créer un runbook, procédez comme suit :

  1. Accédez à la console OCI, accédez à Gestion des applications de parc et cliquez sur Actions et contrôles.

  2. Cliquez sur Runbooks et sur Create runbook.

  3. Entrez le nom, la description, l'opération de cycle de vie, le type de classeur d'exécution, puis sélectionnez le type de système d'exploitation et le temps de fin estimé.

    Création de classeur 1

  4. Créez votre runbook en utilisant le concepteur visuel, téléchargez un fichier YAML ou JSON ou référencez votre script d'automatisation existant via des tâches de script Bash ou Python dans le runbook. Par exemple, l'exemple fourni est un runbook permettant de découvrir Apache Tomcat.

    Création de classeur 2

  5. Pour les runbooks de type repérage, sélectionnez Marquer ceci comme tâche de sortie de repérage pour permettre au service de lire et d'analyser la sortie de la tâche afin de remplir l'inventaire logiciel.

    Remarque : le service peut analyser la sortie uniquement si le format de la sortie est basé sur le modèle de sortie de repérage.

    Tâche de sortie de repérage

    Voici la sortie JSON (runbook\_Apache Tomcat\_discovery.json) du produit.

    {
  "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. Ajoutez d'autres tâches pour personnaliser votre classeur selon vos besoins.

    Modification de la tâche

Tâche 5 : créer un classeur pour appliquer un patch

Reportez-vous à la tâche 4 pour créer un classeur personnalisé avec votre séquence d'application de patches.

Après avoir créé un produit avec ses patches disponibles et sa logique de repérage par défaut, vous pouvez désormais créer un classeur d'application de patches qui inclut la séquence d'automatisation propre à cette technologie et le processus informatique de votre organisation. Ensuite, vous définirez une programmation de maintenance pour définir le moment où le classeur serait déclenché pour appliquer des patches aux cibles non conformes identifiées dans votre parc.

Le script Bash (apache_tomcat_patching.sh) qui automatise le processus de mise à niveau d'une installation Apache Tomcat est le suivant. Vous pouvez également rechercher les tâches associées au script.

  1. Initialiser des variables

    • target_path : extrait d'un fichier target.json dans le répertoire DATA_DIR à l'aide de jq.
    • patches_file : cette variable peut être utilisée pour identifier de manière dynamique le dernier fichier patches.json du système.
    • patch_url : indique le répertoire des patches (/opt/fams/wls_patch).

  2. Afficher et analyser les détails de patch : lisez le contenu du fichier patches.json pour les éléments suivants :

    • Pour extraire la version de patch requise (required_version).
    • Détermine le nom de fichier du patch (file_name).

  3. Vérifier les fichiers requis

    • apache_tomcat_functions.sh:
      • Vérifiez la présence d'un script d'aide (apache_tomcat_functions.sh).
      • Si le fichier est manquant, le script se ferme avec une erreur.
    • Validation du chemin cible :
      • Vérifiez que le répertoire target_path existe.
      • S'il n'existe pas, le script se ferme avec une erreur.

  4. Vérifier la version en cours : exécutez le script version.sh d'Apache Tomcat pour extraire la version actuellement installée (curr_version).

  5. Préparation à une mise à niveau

    • Sauvegarder une installation existante : appelez create_backup pour sauvegarder l'installation Apache Tomcat existante.
    • Arrêter Tomcat : arrêtez Apache Tomcat à l'aide d'une fonction (stop_tomcat).

  6. Mise à niveau de l'installation d'Apache Tomcat

    • Extraire une nouvelle version : extrayez le nouveau package Apache Tomcat (file_name) dans le répertoire cible.
    • Copier les fichiers de configuration:
      • Copiez les fichiers critiques (par exemple, la configuration, les journaux) de l'ancienne installation vers une nouvelle à l'aide de copy_main_files.
      • Gérez les erreurs au cours de cette étape en restaurant la sauvegarde.
    • Renommer et finaliser : renommez le nouveau répertoire pour remplacer l'ancien répertoire d'installation.

  7. Valider et redémarrer

    • Vérifier la mise à niveau : vérifiez la version mise à niveau en exécutant à nouveau version.sh.
    • Redémarrer Apache Tomcat : démarrez Apache Tomcat à l'aide de start_tomcat.

  8. Traiter l'erreur

    • Fournissez des messages d'erreur significatifs à différentes étapes (par exemple, fichiers manquants, répertoire introuvable, échecs de mise à niveau).
    • Annulez les modifications si les opérations critiques échouent (par exemple, copier des fichiers ou renommer des répertoires).

Les fonctions clés utilisées sont :

Réalisation

Le script fournit une approche structurée et automatisée pour la mise à niveau d'une instance Apache Tomcat, la réduction des temps d'arrêt et la garantie d'un mécanisme d'annulation en cas de panne. Il s'appuie sur les fonctions prédéfinies (apache_tomcat_functions.sh) pour gérer des tâches telles que l'arrêt ou le démarrage d'Apache Tomcat et la gestion des fichiers.

Voici l'exemple de script Bash (apache\_tomcat\_patching.sh) avec les méthodes d'application des 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"
}

Tâche 6 : création d'un parc

Créez un parc et affichez votre produit sur la liste d'autorisation associée pour découvrir son inventaire de logiciels, connaître le statut de conformité des correctifs logiciels et corriger la conformité des correctifs logiciels.

  1. Accédez à la console OCI, accédez à Gestion des applications de parc, à Parcs et cliquez sur Créer un parc.

  2. Entrez le nom et la description du parc, puis ajoutez des ressources.

  3. Activez la confirmation automatique des ressources de la cible.

Tâche 7 : corriger la conformité des patches logiciels

Cliquez sur Corriger maintenant pour corriger la conformité des patches logiciels pour un parc sur sa page de détails ou créez une programmation à partir de la page Programmations de la gestion du cycle de vie.

Si vous cliquez sur Corriger maintenant, le travail de conformité sera exécuté dans les 15 prochaines minutes, tandis que si vous sélectionnez l'option de programmation sur la page Programmations, vous pouvez créer un travail pour le futur ou définir une programmation récursive. En définissant une programmation de maintenance, indiquez à quel moment le classeur sera déclenché pour appliquer des patches aux cibles non conformes identifiées dans votre parc.

Remerciements

Ressources de formation supplémentaires

Explorez d'autres ateliers sur docs.oracle.com/learn ou accédez à d'autres contenus de formation gratuits sur le canal Oracle Learning YouTube. De plus, visitez le site education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir la documentation produit, consultez le site Oracle Help Center.