Note:

Automatice la aplicación de parches para Apache Tomcat o una tecnología de terceros con OCI Fleet Application Management

Introducción

El servicio Oracle Cloud Infrastructure (OCI) Fleet Application Management permite a los equipos de TI automatizar las operaciones de detección de software y aplicación de parches para cualquier software desplegado en OCI. El servicio proporciona runbooks predefinidos para detectar y aplicar parches a tecnologías de Oracle, incluidos Oracle WebLogic Server, Oracle Linux, etc. Además, los runbooks personalizados y las capacidades Traiga su propio producto le permiten definir su producto o tecnologías para que el servicio los detecte y aplique parches automáticamente.

En este tutorial, estamos utilizando Apache Tomcat como un ejemplo de una tecnología de terceros popular que a menudo es necesario aplicar parches. En las siguientes secciones se proporcionan instrucciones paso a paso y ejemplos de código reutilizables para guiarle en la adición de Apache Tomcat para que se detecte automáticamente y la aplicación de parches mediante OCI Fleet Application Management. Puede utilizar el mismo proceso para cualquier producto de terceros al que desee aplicar parches con el servicio.

Nota: Estamos describiendo el proceso mediante la consola de OCI, pero también puede utilizar la interfaz de línea de comandos (CLI de OCI) o la API de Oracle Cloud Infrastructure. Para obtener información sobre OCI Fleet Application Management, consulte Fleet Application Management.

Introducción a la aplicación de parches a Apache Tomcat

La capacidad Traiga su propio producto facilita la integración de nuevos productos en OCI Fleet Application Management, como software, tecnologías o componentes de aplicaciones de terceros. Esta capacidad permite centralizar la conformidad de parches y otras operaciones del ciclo de vida en estos distintos componentes mediante el servicio.

Con la capacidad Traiga su propio producto, primero creará su producto personalizado en el servicio junto con su política de conformidad y los parches disponibles. A continuación, mediante runbooks personalizados, creará tanto los runbooks de detección como los de aplicación de parches, lo que le permitirá automatizar la gestión del cumplimiento en el futuro.

Objetivos

Tarea 1: Creación de un producto

  1. Conéctese a la consola de OCI, vaya a Observación y gestión y seleccione Gestión de aplicaciones de conjunto.

  2. Haga clic en Administración.

  3. En Gestión de metadatos, haga clic en Productos y en Crear producto.

    Creación de producto 1

  4. Introduzca la siguiente información para el nuevo producto.

    • Nombre de producto: introduzca el nombre del producto, evitando cualquier información confidencial, como claves, etc.
    • Versiones: introduzca la versión.
    • Tipos de Parches (Opcional): seleccione el tipo de parche.
    • Productos compatibles (Opcional): agregue productos compatibles.
    • Componentes (Opcional): seleccione los componentes.
    • Nombres de credenciales (opcional): seleccione el nombre de la credencial.

    Creación de producto 2

Tarea 2: Definición de una regla de política de conformidad de parches

Se crea automáticamente una política de conformidad de parches de software para cada nuevo producto. La política por defecto no contiene ninguna regla de política. Puede editar la política para agregar reglas y especificar la condición para evaluar si un destino específico es compatible (si es verdadero) o no compatible (de lo contrario). Puede utilizar varios atributos de producto para definir las reglas, como la versión del producto, el tipo de parche, la gravedad del parche, los criterios de selección del parche y el período de gracia. El estado de conformidad del parche se informa como indeterminado si no crea reglas de política.

  1. Vaya a la consola de OCI, vaya a Administración y haga clic en Política de conformidad.

  2. Seleccione la política de conformidad del producto que necesita modificar. (Sintaxis: Product name Compliance Policy).

  3. Haga clic en Crear regla de política.

  4. Introduzca la versión del producto y otros atributos que se utilizarán en la condición.

    Regla de política de conformidad 1

    Por ejemplo, las reglas de política pueden tener la siguiente definición:

    • Nombre de regla: introduzca Apache Tomcat.
    • Versión del producto: seleccione 10.1 y versiones posteriores.
    • Tipo de parche: seleccione Parche crítico.
    • Severity (Gravedad): seleccione CriticalPatch.
    • Selección de parches: seleccione Nivel de parche.

    Regla 2 de política de conformidad

Tarea 3: Creación de Metadatos de Parches y Carga del Parche

Cree los metadatos del parche para facilitar la aplicación de parches en el futuro para el producto que ha agregado. A continuación, debe cargar los parches disponibles en OCI Object Storage. En función de la tecnología y los tipos de parches disponibles para el nuevo producto, puede cargar un parche genérico o paquetes específicos para diferentes configuraciones del sistema operativo.

  1. Vaya a la consola de OCI, vaya a Gestión de aplicaciones de conjunto, haga clic en Gestión del ciclo de vida y, a continuación, en Parches.

  2. Haga clic en Cargar parche.

  3. Introduzca la siguiente información.

    • Nombre de parche: introduzca un nombre.
    • Producto: seleccione un producto.
    • Severity: seleccione una gravedad.
    • Seleccione Parches dependientes para especificar los parches dependientes a los que se aplicarán parches junto con el parche actual. Por ejemplo, en el caso de Apache Tomcat, el siguiente parche se puede descargar como apache-tomcat-10.1.25.tar.gz desde aquí: Central Repository: org/apache/tomcat/tomcat/10.1.25.

    Cargar Parche

Tarea 4: Creación de un libro de ejecución de detección para un producto

El servicio utiliza un runbook de detección para identificar el software y la versión del producto agregado. Por ejemplo, en el caso de Apache Tomcat, el script runbook en Python para detectar y recopilar detalles sobre las instancias de Apache Tomcat en un sistema puede ser el siguiente:

Tareas en la secuencia de comandos del libro de ejecución de detección

La secuencia de comandos realiza las siguientes tareas:

Desglose de tareas clave

  1. Localice las instancias de Apache Tomcat.

  2. Extraiga los detalles de la versión de Apache Tomcat.

    • Método (_get_details(path)):
      • Ejecuta el script version.sh en el directorio bin de cada una de las rutas de Apache Tomcat.
      • Analiza la salida para extraer detalles clave (por ejemplo, número de versión) en un diccionario.
      • Maneja errores: cualquier excepción durante la ejecución o el análisis se ignora de forma silenciosa.
    • Salida: devuelve un diccionario de metadatos de Apache Tomcat (por ejemplo, número de servidor).

  3. Recuperar registro de hora de modificación de archivo.

    • Método _get_timestamp(file_path):
      • Comprueba si existe un archivo determinado y recupera su última hora de modificación.
      • Aplica formato al registro de hora en formato dd-MMM-yyyy HH:mm:ss.
    • Salida: devuelve el registro de hora formateado.

  4. Recopile los detalles del entorno Java.

    • Método _get_java_details():
      • Utiliza comandos del sistema para recuperar la versión de Java y la ruta del directorio raíz de Java.
        • Versión de Java: se obtiene con java -version.
        • Ruta de acceso del directorio raíz de Java: se extrae de las propiedades de tiempo de ejecución de java.
    • Salida: devuelve un diccionario con java_version y java_home.

  5. Cree un diccionario de instancia detallado.

    • Método _instance(path):
      • Crea un diccionario que representa una única instancia de Apache Tomcat.
        • Detalles del producto: nombre, versión, ruta de destino, etc.
        • Parches instalados: incluye la versión y la fecha de la última modificación del directorio.
        • Propiedades de Java: incluye java_version y java_home.
    • Salida: devuelve un diccionario estructurado para la instancia de Apache Tomcat.

  6. Detectar y agregar todas las instancias.

    • Método _discovery_tomcat():
      • Llama a _get_all_tomcats() para buscar rutas de Apache Tomcat.
      • Itera por cada ruta y llama a _instance(path) para recopilar detalles.
      • Agrega todas las instancias a una lista de destinos.
    • Salida: devuelve un diccionario con todos los destinos detectados.

  7. Generar salida.

    • Escribe los detalles de Apache Tomcat detectados en un archivo JSON.
      • Ubicación: /opt/fams/.scripts/tomcat_discovery.json.
      • Formato: JSON con impresión bonita.
    • También imprime el objeto JSON en la consola para una visibilidad inmediata.

Flujo de script

  1. Ubicar instancias de Apache Tomcat: el método _get_all_tomcats() explora el sistema de archivos.

  2. Recuperar detalles para cada instancia: los métodos _get_details() y _instance() extraen los metadatos relevantes.

  3. Recopilar detalles de Java: el método _get_java_details() recupera las propiedades del entorno Java.

  4. Agregar datos: el método _discovery_tomcat() combina la información de todas las instancias.

  5. Generar salida: los resultados se guardan en formato JSON y se imprimen.

    Salida de ejemplo:

    {

    "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. Gestión de Errores:

    • Fallo silencioso para la mayoría de las excepciones (por ejemplo, archivos faltantes, errores de comandos).
    • Este enfoque evita que la secuencia de comandos termine antes de tiempo, pero puede ocultar errores durante la ejecución.

Ejemplo: script de detección Tomcat de Apache 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())

Después de manejar todos los errores, los productos se asocian a una flota o a varias flotas para automatizar la detección y las operaciones. Una vez que un producto está en la lista de usuarios permitidos para un conjunto, su runbook de detección por defecto buscará y actualizará automáticamente el inventario de software con los destinos del producto desplegado en todos los recursos gestionados.

Para crear un runbook, realice los siguientes pasos:

  1. Vaya a la consola de OCI, vaya a Gestión de aplicaciones de conjunto y haga clic en Acciones y controles.

  2. Haga clic en Libros de ejecución y en Crear libro de ejecución.

  3. Introduzca Nombre, Descripción, Operación de ciclo de vida, Tipo de libro de ejecución y seleccione Tipo de sistema operativo y Tiempo de finalización estimado.

    Creación de libro de ejecución 1

  4. Cree su runbook con el diseñador visual, cargue un archivo YAML o JSON o haga referencia a su script de automatización existente mediante tareas de script de Bash o Python dentro del runbook. Por ejemplo, el ejemplo proporcionado es un runbook para detectar Apache Tomcat.

    Creación de libro de ejecución 2

  5. Para runbooks de detección de tipo, seleccione Marcar esto como tarea de salida de detección para permitir que el servicio lea y analice la salida de la tarea para rellenar el inventario de software.

    Nota: El servicio puede analizar la salida solo si el formato de la salida se basa en la plantilla de salida de detección.

    Tarea de salida de detección

    A continuación se muestra la salida de JSON (runbook\_Apache Tomcat\_discovery.json) para el producto.

    {
  "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. Agregue más tareas para personalizar el runbook según sea necesario.

    Editar Tarea

Tarea 5: Creación de un Runbook para la Aplicación de un Parche

Consulte la tarea 4 para crear un runbook personalizado con la secuencia de aplicación de parches.

Después de crear un producto con los parches disponibles y la lógica de detección por defecto, ahora puede crear un runbook para la aplicación de parches que incluya la secuencia de automatización específica para esta tecnología y el proceso de TI de su organización. A continuación, definirá un programa de mantenimiento para definir cuándo se dispararía el runbook para aplicar parches a los destinos no conformes identificados en el conjunto.

El script de Bash (apache_tomcat_patching.sh) que automatiza el proceso de actualización de una instalación de Apache Tomcat es el siguiente. Además, puede encontrar las tareas asociadas al script.

  1. Inicialización de variables

    • target_path: esta extracción de un archivo target.json en el directorio DATA_DIR mediante jq.
    • patches_file: esta variable se puede utilizar para identificar dinámicamente el último archivo patches.json del sistema.
    • patch_url: especifica el directorio para los parches (/opt/fams/wls_patch).

  2. Mostrar y analizar detalles de parche: lea el contenido del archivo patches.json para lo siguiente:

    • Para extraer la versión de parche necesaria (required_version).
    • Para determinar el nombre de archivo del parche (file_name).

  3. Comprobar archivos necesarios

    • apache_tomcat_functions.sh:
      • Asegúrese de que haya una secuencia de comandos auxiliar (apache_tomcat_functions.sh).
      • Si falta el archivo, la secuencia de comandos se cierra con un error.
    • Validación de ruta de destino:
      • Verifique que el directorio target_path existe.
      • Si no existe, la secuencia de comandos se cierra con un error.

  4. Compruebe la versión actual: ejecute el script version.sh de Apache Tomcat para recuperar la versión instalada actualmente (curr_version).

  5. Preparación para una actualización

    • Copia de seguridad de la instalación existente: llame a create_backup para realizar una copia de seguridad de la instalación existente de Apache Tomcat.
    • Parar Tomcat: pare Apache Tomcat mediante una función (stop_tomcat).

  6. Actualización de la instalación de Apache Tomcat

    • Extraer una nueva versión: extraiga el nuevo paquete de Apache Tomcat (file_name) en el directorio de destino.
    • Copiar Archivos de Configuración:
      • Copie los archivos críticos (por ejemplo, configuración, logs) de la instalación antigua a uno nuevo mediante copy_main_files.
      • Gestione los errores durante este paso mediante la restauración de la copia de seguridad.
    • Cambiar nombre y finalizar: cambie el nombre del nuevo directorio para sustituir el antiguo directorio de instalación.

  7. Validar y reiniciar

    • Verificar el cambio de versión: vuelva a ejecutar version.sh para comprobar la versión actualizada.
    • Reiniciar Apache Tomcat: inicie Apache Tomcat mediante start_tomcat.

  8. Manejar error

    • Proporcione mensajes de error significativos en varias etapas (por ejemplo, archivos faltantes, directorio no encontrado, fallos de actualización).
    • Anule los cambios si fallan las operaciones críticas (por ejemplo, copiar archivos o cambiar el nombre de directorios).

Las funciones clave utilizadas son:

¿Qué logra?

El script proporciona un enfoque estructurado y automatizado para actualizar una instancia de Apache Tomcat, minimizar el tiempo de inactividad y garantizar un mecanismo de rollback en caso de fallo. Se basa en las funciones predefinidas (apache_tomcat_functions.sh) para gestionar tareas como parar o iniciar Apache Tomcat y el manejo de archivos.

A continuación se muestra el script de Bash de ejemplo (apache\_tomcat\_patching.sh) con los métodos para aplicar parches.

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

Tarea 6: Creación de un conjunto

Cree una flota y coloque su producto en la lista de permitidos relacionada para descubrir su inventario de software, conocer el estado de conformidad del parche de software y corregir el cumplimiento del parche de software.

  1. Vaya a la consola de OCI, vaya a Fleet Application Management, Fleets y haga clic en Create Fleet.

  2. Introduzca el nombre y la descripción del conjunto y agregue recursos.

  3. Active la confirmación automática de los recursos del destino.

Tarea 7: Corrección del cumplimiento del parche de software

Haga clic en Corregir ahora para corregir la conformidad de parches de software para un conjunto en su página de detalles o cree un programa desde la página Programas de Gestión del ciclo de vida.

Si hace clic en Corregir ahora, el trabajo de conformidad se ejecutará en los próximos 15 minutos, mientras que si selecciona la opción de planificación en la página Programas, puede crear un trabajo para el futuro o definir un programa recursivo. Al definir un programa de mantenimiento, especifique cuándo se disparará el runbook para aplicar parches a los destinos no conformes identificados en el conjunto.

Agradecimientos

Más recursos de aprendizaje

Explore otros laboratorios en docs.oracle.com/learn o acceda a más contenido de formación gratuita en el canal YouTube de Oracle Learning. Además, visita education.oracle.com/learning-explorer para convertirte en un Oracle Learning Explorer.

Para obtener documentación sobre el producto, visite Oracle Help Center.