Note :

Automatiser l'application de correctifs pour Apache Tomcat ou une technologie de tierce partie avec la gestion des applications de flotte d'OCI

Présentation

Le service de gestion des applications du parc Oracle Cloud Infrastructure (OCI) permet aux équipes de TI d'automatiser la détection de logiciels et les opérations de correctifs pour tous les logiciels déployés dans OCI. Le service fournit des livres d'exécution prédéfinis pour détecter et appliquer des correctifs aux technologies Oracle, y compris Oracle WebLogic Server, Oracle Linux et plus encore. De plus, les carnets d'exécution personnalisés et les fonctions d'utilisation de votre propre produit vous permettent de définir vos produits ou technologies à détecter 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 étape par étape et des exemples de code réutilisables pour vous guider lors de l'ajout d'Apache Tomcat à détecter automatiquement et de l'application de correctifs à l'aide de la gestion des applications de flotte d'OCI. Vous pouvez utiliser le même processus pour tout produit de tierce partie à appliquer des correctifs au service.

Note : Nous décrivons le processus à l'aide de la console OCI, mais vous pouvez également utiliser l'interface de ligne de commande ou l'API Oracle Cloud Infrastructure. Pour plus d'informations sur la gestion d'application de parc OCI, voir Gestion d'application de parc.

Démarrer avec l'application de correctifs à Apache Tomcat

La fonction Utiliser son propre produit facilite l'intégration de nouveaux produits dans la gestion des applications du parc OCI, tels que des logiciels, des technologies ou des composants d'application de tierce partie. 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.

À l'aide de la fonction Utiliser son propre produit, vous allez d'abord créer votre produit personnalisé dans le service, ainsi que sa politique de conformité et les correctifs disponibles. Ensuite, à l'aide de livres d'exécution personnalisés, vous allez créer les livres d'exécution de détection et d'application de correctifs, ce qui vous permettra d'automatiser la gestion de la conformité à l'avenir.

Objectifs

Tâche 1 : Créer un produit

  1. Connectez-vous à la console OCI, naviguez jusqu'à Observabilité 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. Entrez 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 correctif (Facultatif) : Sélectionnez le type de correctif.
    • Produits compatibles (Facultatif) : Ajoutez des produits compatibles.
    • Composants (Facultatif) : Sélectionnez des composants.
    • Noms des données d'identification (Facultatif) : Sélectionnez le nom des données d'identification.

    Création de produit 2

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

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

  1. Allez à la console OCI, naviguez jusqu'à Administration et cliquez sur Politique de conformité.

  2. Sélectionnez la politique de conformité du produit que vous devez modifier. (Syntaxe : Politique de conformité des noms de produit).

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

  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 politique peuvent avoir la définition suivante :

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

    Règle de politique de conformité 2

Tâche 3 : Créer des métadonnées de correctif et charger le correctif

Créez les métadonnées du correctif pour faciliter l'application future de correctifs pour le produit que vous avez ajouté. Vous devez ensuite charger les correctifs disponibles dans le service de stockage d'objets pour OCI. Selon la technologie et les types de correctifs disponibles pour votre nouveau produit, vous pouvez charger un correctif générique ou des ensembles spécifiques pour différentes configurations de système d'exploitation.

  1. Allez à la console OCI, naviguez jusqu'à Gestion des applications de parc, cliquez sur Gestion du cycle de vie, puis sur Correctifs.

  2. Cliquez sur Charger le correctif.

  3. Entrez les informations suivantes .

    • Nom du correctif : Entrez un nom.
    • Produit : Sélectionnez un produit.
    • Gravité : Sélectionnez une gravité.
    • Sélectionnez Correctifs dépendants pour spécifier les correctifs dépendants qui seront corrigés avec le correctif courant. Par exemple, dans le cas d'Apache Tomcat, le correctif 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.

    Charger le correctif

Tâche 4 : Créer un Runbook Discovery pour un produit

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

Tâches dans le script de carnet d'exécution de détection

Le script effectue les tâches suivantes :

Répartition des tâches clés

  1. Localisez les instances Apache Tomcat.

  2. Extraire 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 chacun des chemins 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 lors de l'exécution ou de l'analyse sont ignorées silencieusement.
    • Sortie : Retourne un dictionnaire de métadonnées Apache Tomcat (par exemple, numéro de serveur).

  3. Extraire l'horodatage de modification de 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 : Retourne l'horodatage formaté.

  4. Collectez les détails de l'environnement Java.

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

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

    • Méthode _instance(path) :
      • Construit un dictionnaire représentant une seule instance Apache Tomcat.
        • Détails du produit : Nom, version, chemin cible, etc.
        • Correctifs 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 : Retourne un dictionnaire structuré pour l'instance Apache Tomcat.

  6. Détecter et agréger 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 : Retourne un dictionnaire avec toutes les cibles détectées.

  7. Générer la sortie.

    • Écrit les détails Apache Tomcat détectés dans un fichier JSON.
      • Emplacement : /opt/fams/.scripts/tomcat_discovery.json.
      • Format : JSON préimprimé.
    • Imprime également l'objet JSON dans la console pour une visibilité immédiate.

Flux de script

  1. Localiser les instances Apache Tomcat : La méthode _get_all_tomcats() balaye 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 de l'environnement Java.

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

  5. Générer la 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. Traitement des erreurs :

    • Échec silencieux pour la plupart des exceptions (par exemple, fichiers manquants, erreurs de commande).
    • Cette approche empêche la fin prématurée du script, mais peut masquer 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 à un parc ou à plusieurs parcs pour automatiser la détection et les opérations. Une fois qu'un produit figure sur la liste des utilisateurs autorisés pour un parc, son dossier d'exploration par défaut recherche et met à jour automatiquement l'inventaire logiciel avec les cibles du produit déployé sur toutes les ressources gérées.

Voici la marche à suivre pour créer un dossier d'exécution :

  1. Allez à la console OCI, naviguez jusqu'à Gestion des applications de parc, puis cliquez sur Actions et contrôles.

  2. Cliquez sur Livres d'exécution et sur Créer un livre d'exécution.

  3. Entrez Nom, Description, Opération de cycle de vie, Type d'exécution et sélectionnez Type de système d'exploitation et Heure d'achèvement estimative.

    Création de dossier d'exécution 1

  4. Créez votre dossier d'exécution à l'aide du concepteur visuel, chargez un fichier YAML ou JSON ou référencez votre script d'automatisation existant au moyen de tâches de script Bash ou Python dans le dossier d'exécution. Par exemple, l'exemple fourni est un runbook pour découvrir Apache Tomcat.

    Création de Runbook 2

  5. Pour les carnets d'exécution de type détection, sélectionnez Marquer cela comme tâche de sortie de détection pour permettre au service de lire et d'analyser la sortie de la tâche afin d'alimenter l'inventaire logiciel.

    Note : Le service ne peut analyser la sortie que si le format de la sortie est basé sur le modèle de sortie de détection.

    Tâche de sortie de détection

    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 dossier d'exécution selon les besoins.

    Modifier une tâche

Tâche 5 : Créer un Runbook pour l'application d'un correctif

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

Après avoir créé un produit avec ses correctifs disponibles et sa logique de détection par défaut, vous pouvez maintenant créer un dossier d'exécution pour l'application de correctifs qui inclut la séquence d'automatisation propre à cette technologie et le processus informatique de votre organisation. Vous définirez ensuite un programme de maintenance pour définir à quel moment le dossier d'exécution sera déclenché pour appliquer des correctifs aux cibles non conformes qui sont 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 trouver les tâches associées au script.

  1. Initialiser les variables

    • target_path : Cette extraction à partir 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 dynamiquement le dernier fichier patches.json dans le système.
    • patch_url : Indique le répertoire des correctifs (/opt/fams/wls_patch).

  2. Afficher et analyser les détails du correctif : Lisez le contenu du fichier patches.json pour les informations suivantes :

    • Pour extraire la version de correctif requise (required_version).
    • Pour déterminer le nom de fichier du correctif (file_name).

  3. Vérifier les fichiers obligatoires

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

  4. Vérifiez la version courante : Exécutez le script version.sh d'Apache Tomcat pour extraire la version actuellement installée (curr_version).

  5. Préparer une mise à niveau

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

  6. Mettre à niveau l'installation d'Apache Tomcat

    • Extraire une nouvelle version : Extrayez le nouvel ensemble 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.
      • Traitez 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érifiez la mise à niveau : Vérifiez la version mise à niveau en exécutant à nouveau version.sh.
    • Redémarrez 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 en cas d'échec des opérations critiques (par exemple, copier des fichiers ou renommer des répertoires).

Fonctions clés utilisées :

Qu'est-ce qu'il accomplit?

Le script fournit une approche structurée et automatisée pour mettre à niveau une instance Apache Tomcat, minimiser les temps d'arrêt et assurer un mécanisme de repositionnement en cas de défaillance. 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 le traitement des fichiers.

Voici l'exemple de script Bash (apache\_tomcat\_patching.sh) avec les méthodes d'application des correctifs.

\#
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éer un parc

Créez un parc et obtenez votre produit sur la liste d'autorisation correspondante pour découvrir son inventaire de logiciels, connaître l'état de conformité des correctifs logiciels et corriger la conformité des correctifs logiciels.

  1. Allez à la console OCI, naviguez jusqu'à Gestion des applications de flotte, Fleets et cliquez sur Créer un parc.

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

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

Tâche 7 : Corriger la conformité du correctif logiciel

Cliquez sur Corriger maintenant pour corriger la conformité des correctifs logiciels pour un parc dans la page de détails de celui-ci ou créez un programme à partir de la page Programmes de la gestion du cycle de vie.

Si vous cliquez sur Corriger maintenant, la tâche de conformité s'exécutera dans les 15 prochaines minutes, alors que si vous sélectionnez l'option de programmation dans la page Programmes, vous pouvez créer une tâche pour l'avenir ou définir un programme récursif. En définissant un programme de maintenance, indiquez à quel moment le dossier d'exécution sera déclenché pour appliquer des correctifs aux cibles non conformes identifiées dans votre parc.

Confirmation

Autres ressources d'apprentissage

Explorez d'autres laboratoires sur la page docs.oracle.com/learn ou accédez à plus de contenu d'apprentissage gratuit sur le canal YouTube d'Oracle Learning. De plus, visitez education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour obtenir de la documentation sur le produit, visitez Oracle Help Center.