Note:
- Este tutorial requiere acceso a Oracle Cloud. Para registrarse para obtener una cuenta gratuita, consulte Introducción a la cuenta gratuita de Oracle Cloud Infrastructure.
- Utiliza valores de ejemplo para credenciales, arrendamiento y compartimentos de Oracle Cloud Infrastructure. Al finalizar la práctica, sustituya estos valores por otros específicos de su entorno en la nube.
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
- Automatiza la aplicación de parches para Apache Tomcat o una tecnología de terceros con OCI Fleet Application Management.
Tarea 1: Creación de un producto
-
Conéctese a la consola de OCI, vaya a Observación y gestión y seleccione Gestión de aplicaciones de conjunto.
-
Haga clic en Administración.
-
En Gestión de metadatos, haga clic en Productos y en Crear producto.
-
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.
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.
-
Vaya a la consola de OCI, vaya a Administración y haga clic en Política de conformidad.
-
Seleccione la política de conformidad del producto que necesita modificar. (Sintaxis: Product name Compliance Policy).
-
Haga clic en Crear regla de política.
-
Introduzca la versión del producto y otros atributos que se utilizarán en la condición.
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.
- Nombre de regla: introduzca
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.
-
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.
-
Haga clic en Cargar parche.
-
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.
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:
- Busca en el sistema de archivos las instancias de Apache Tomcat.
- Método (
_get_all_tomcats()
): localiza las instancias de Apache Tomcat.- Utiliza el comando find para buscar en el sistema de archivos directorios denominados webapps, que es característico de las instalaciones de Apache Tomcat.
- Elimina el sufijo
/webapps
para obtener la raíz de la ruta Tomcat de Apache. - Filtra las rutas que contienen copia de seguridad para evitar resultados redundantes o irrelevantes.
- Salida: devuelve una lista de rutas de instalación de Apache Tomcat.
- Extrae los detalles de la versión y los metadatos de cada instancia.
- Crea un diccionario de instancias detallado para una instancia de Apache Tomcat.
- Detecta y agrega todas las instancias de Apache Tomcat.
- Recopila información sobre el entorno Java asociado.
- Devuelve todos los datos en formato JSON que puede utilizar para la generación de informes o el procesamiento posterior.
- Gestiona errores.
Desglose de tareas clave
-
Localice las instancias de Apache Tomcat.
-
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.
- Ejecuta el script
- Salida: devuelve un diccionario de metadatos de Apache Tomcat (por ejemplo, número de servidor).
- Método (
-
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.
- Método
-
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.
- Versión de Java: se obtiene con
- Utiliza comandos del sistema para recuperar la versión de Java y la ruta del directorio raíz de Java.
- Salida: devuelve un diccionario con
java_version
yjava_home
.
- Método
-
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
yjava_home
.
- Crea un diccionario que representa una única instancia de Apache Tomcat.
- Salida: devuelve un diccionario estructurado para la instancia de Apache Tomcat.
- Método
-
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.
- Llama a
- Salida: devuelve un diccionario con todos los destinos detectados.
- Método
-
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.
- Ubicación:
- También imprime el objeto JSON en la consola para una visibilidad inmediata.
- Escribe los detalles de Apache Tomcat detectados en un archivo JSON.
Flujo de script
-
Ubicar instancias de Apache Tomcat: el método
_get_all_tomcats()
explora el sistema de archivos. -
Recuperar detalles para cada instancia: los métodos
_get_details()
y_instance()
extraen los metadatos relevantes. -
Recopilar detalles de Java: el método
_get_java_details()
recupera las propiedades del entorno Java. -
Agregar datos: el método
_discovery_tomcat()
combina la información de todas las instancias. -
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" } ] } ] }
-
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:
-
Vaya a la consola de OCI, vaya a Gestión de aplicaciones de conjunto y haga clic en Acciones y controles.
-
Haga clic en Libros de ejecución y en Crear libro de ejecución.
-
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.
-
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.
-
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.
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": {} }
-
Agregue más tareas para personalizar el runbook según sea necesario.
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.
-
Inicialización de variables
target_path
: esta extracción de un archivotarget.json
en el directorioDATA_DIR
mediantejq
.patches_file
: esta variable se puede utilizar para identificar dinámicamente el último archivopatches.json
del sistema.patch_url
: especifica el directorio para los parches (/opt/fams/wls_patch
).
-
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
).
- Para extraer la versión de parche necesaria (
-
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.
- Asegúrese de que haya una secuencia de comandos auxiliar (
- 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.
- Verifique que el directorio
-
Compruebe la versión actual: ejecute el script
version.sh
de Apache Tomcat para recuperar la versión instalada actualmente (curr_version
). -
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
).
- Copia de seguridad de la instalación existente: llame a
-
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.
- Copie los archivos críticos (por ejemplo, configuración, logs) de la instalación antigua a uno nuevo mediante
- Cambiar nombre y finalizar: cambie el nombre del nuevo directorio para sustituir el antiguo directorio de instalación.
- Extraer una nueva versión: extraiga el nuevo paquete de Apache Tomcat (
-
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
.
- Verificar el cambio de versión: vuelva a ejecutar
-
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:
stop_tomcat
: detiene el servicio Tomcat.create_backup
: crea una copia de seguridad del directorio Tomcat existente.copy_main_files
: transfiere los archivos necesarios de la instalación antigua a la nueva.start_tomcat
: inicia el servicio Tomcat actualizado.
¿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.
-
Vaya a la consola de OCI, vaya a Fleet Application Management, Fleets y haga clic en Create Fleet.
-
Introduzca el nombre y la descripción del conjunto y agregue recursos.
-
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
- Autores: Shabbir Hussain (personal técnico del miembro consultor), Fabio Bonisoli (mánager de productos de gestión de aplicaciones de la flota)
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.
Automate Patching for Apache Tomcat or a Third-Party Technology with OCI Fleet Application Management
G23642-01
December 2024