Observação:

Automatize a aplicação de patches para o Apache Tomcat ou uma tecnologia de terceiros com o OCI Fleet Application Management

Introdução

O serviço Oracle Cloud Infrastructure (OCI) Fleet Application Management permite que as equipes de TI automatizem a descoberta de software e as operações de aplicação de patches para qualquer software implantado na OCI. O serviço fornece runbooks predefinidos para descobrir e aplicar patches às tecnologias Oracle, incluindo Oracle WebLogic Server, Oracle Linux e muito mais. Além disso, os runbooks personalizados e os recursos Traga Seu Próprio Produto permitem que você defina seu produto ou tecnologias a serem descobertos e corrigidos automaticamente pelo serviço.

Neste tutorial, estamos usando o Apache Tomcat como um exemplo de uma tecnologia popular de terceiros que você geralmente precisa corrigir. As seções a seguir fornecem instruções passo a passo e amostras de código reutilizáveis para orientá-lo sobre como adicionar o Apache Tomcat para ser descoberto automaticamente e aplicar patches usando o OCI Fleet Application Management. Você pode usar o mesmo processo para qualquer produto de terceiros que deseja corrigir com o serviço.

Observação: Estamos descrevendo o processo usando a Console do OCI, mas você também pode usar a Interface de Linha de Comando (CLI do OCI) ou a API do Oracle Cloud Infrastructure. Para obter informações sobre o OCI Fleet Application Management, consulte Fleet Application Management.

Conceitos Básicos de Aplicação de Patch no Apache Tomcat

O recurso Traga seu próprio produto facilita a integração de novos produtos no OCI Fleet Application Management, como software, tecnologias ou componentes de aplicativos de terceiros. Esse recurso permite a centralização da conformidade de patches e outras operações do ciclo de vida nesses vários componentes usando o serviço.

Usando o recurso Traga seu Próprio Produto, você primeiro criará seu produto personalizado no serviço junto com sua política de conformidade e patches disponíveis. Em seguida, usando runbooks personalizados, você criará os runbooks de descoberta e de aplicação de patches, permitindo automatizar o gerenciamento de conformidade daqui para frente.

Objetivos

Tarefa 1: Criar um Produto

  1. Faça log-in na Console do OCI, navegue até Observabilidade e Gerenciamento e selecione Gerenciamento de Aplicativos de Frota.

  2. Clique em Administração.

  3. Em Gerenciamento de metadados, clique em Produtos e em Criar produto.

    Criação de Produto 1

  4. Insira as informações a seguir para o novo produto.

    • Nome do Produto: Informe o nome do produto, evitando informações confidenciais, como chaves, etc.
    • Versão(ões): Informe a versão.
    • Tipos de Patch (Opcional): Selecione o tipo de patch.
    • Produtos compatíveis (Opcional): Adicione produtos compatíveis.
    • Componentes (Opcional): Selecione os componentes.
    • Nomes da credencial (Opcional): Selecione o nome da credencial.

    Criação de Produto 2

Tarefa 2: Definir uma Regra de Política de Conformidade de Patches

Uma política de conformidade de patch de software é criada automaticamente para cada novo produto. A política padrão não contém regras de política. Você pode editar a política para adicionar regras para especificar a condição a ser avaliada se um destino específico é compatível (se verdadeiro) ou não compatível (else). Você pode usar vários atributos de produto para definir as regras, como versão do produto, tipo de patch, severidade do patch, critérios de seleção de patch e período de tolerância. O status de conformidade do patch será reportado como indeterminado se você não criar regras de política.

  1. Vá para a Console do OCI, navegue até Administração e clique em Política de Conformidade.

  2. Selecione a política de conformidade do produto que você precisa modificar. (Sintaxe: Política de Conformidade do Nome do Produto).

  3. Clique em Criar regra de política.

  4. Informe a versão do produto e outros atributos a serem usados na condição.

    Regra da Política de Conformidade 1

    Por exemplo, as regras de política podem ter a seguinte definição:

    • Nome da regra: Digite Apache Tomcat.
    • Versão do Produto: Selecione 10.1 e superior.
    • Tipo de patch: Selecione Patch Crítico.
    • Severidade: Selecione CriticalPatch.
    • Seleção de patch: Selecione Nível de Patch.

    Regra da Política de Conformidade 2

Tarefa 3: Criar Metadados de Patch e Fazer Upload do Patch

Crie os metadados de patch para tornar a aplicação de patch futura mais fácil para o produto adicionado. Em seguida, faça upload dos patches disponíveis para o OCI Object Storage. Dependendo da tecnologia e dos tipos de patches disponíveis para seu novo produto, você pode fazer upload de um patch genérico ou de pacotes específicos para diferentes configurações do sistema operacional.

  1. Vá para a Console do OCI, navegue até Fleet Application Management, clique em Lifecycle Management e, em seguida, Patches.

  2. Clique em Fazer Upload do Patch.

  3. Digite as seguintes informações.

    • Nome do patch: Informe um nome.
    • Produto: Selecione um produto.
    • Severidade: Selecione uma severidade.
    • Selecione Patches dependentes para especificar os patches dependentes que serão corrigidos com o patch atual. Por exemplo, no caso do Apache Tomcat, o patch a seguir pode ser baixado como apache-tomcat-10.1.25.tar.gz a partir daqui: Repositório Central: org/apache/tomcat/tomcat/10.1.25.

    Upload do Patch

Tarefa 4: Criar um Manual de Descoberta para um Produto

O serviço usa um manual de descoberta para identificar o software e a versão do produto adicionado. Por exemplo, no caso do Apache Tomcat, o script de runbook em Python para descobrir e coletar detalhes sobre instâncias do Apache Tomcat em um sistema pode ser o seguinte:

Tarefas no Script do Manual de Descoberta

O script realiza as seguintes tarefas:

Detalhamento de Principais Tarefas

  1. Localize Instâncias do Apache Tomcat.

  2. Extrair detalhes da versão do Apache Tomcat.

    • Método (_get_details(path)):
      • Executa o script version.sh no diretório bin de cada caminho do Apache Tomcat.
      • Analisa a saída para extrair detalhes da chave (por exemplo, número da versão) em um dicionário.
      • Lida com erros: Quaisquer exceções durante a execução ou análise são ignoradas silenciosamente.
    • Saída: Retorna um dicionário de metadados do Apache Tomcat (por exemplo, número do servidor).

  3. Recuperar timestamp de modificação de arquivo.

    • Método _get_timestamp(file_path):
      • Verifica se um determinado arquivo existe e recupera seu último horário de modificação.
      • Formata o timestamp no formato dd-MMM-yyyy HH:mm:ss.
    • Saída: Retorna o timestamp formatado.

  4. Obtenha detalhes do ambiente Java.

    • Método _get_java_details():
      • Usa comandos do sistema para extrair a versão do Java e o caminho do home do Java.
        • Versão Java: Obtida com java -version.
        • Caminho do home do Java: Extraído das propriedades do runtime java.
    • Saída: Retorna um dicionário com java_version e java_home.

  5. Crie um dicionário de instâncias detalhado.

    • Método _instance(path):
      • Cria um dicionário que representa uma única instância do Apache Tomcat.
        • Detalhes do produto: Nome, versão, caminho de destino etc.
        • Patches instalados: Inclui a versão e a data da última modificação do diretório.
        • Propriedades Java: Inclui java_version e java_home.
    • Saída: Retorna um dicionário estruturado para a instância do Apache Tomcat.

  6. Descubra e agregue todas as instâncias.

    • Método _discovery_tomcat():
      • Chama _get_all_tomcats() para localizar caminhos do Apache Tomcat.
      • Itera em cada caminho e chama _instance(path) para coletar detalhes.
      • Agrega todas as instâncias em uma lista de destinos.
    • Saída: Retorna um dicionário com todos os destinos descobertos.

  7. Gerar saída.

    • Grava os detalhes do Apache Tomcat descobertos em um arquivo JSON.
      • Local: /opt/fams/.scripts/tomcat_discovery.json.
      • Formato: JSON pré-impresso.
    • Também imprime o objeto JSON no console para visibilidade imediata.

Fluxo de script

  1. Localizar instâncias do Apache Tomcat: O método _get_all_tomcats() verifica o sistema de arquivos.

  2. Recuperar detalhes de cada instância: Os métodos _get_details() e _instance() extraem metadados relevantes.

  3. Coletar detalhes do Java: O método _get_java_details() extrai as propriedades do ambiente Java.

  4. Agregar dados: O método _discovery_tomcat() combina as informações de todas as instâncias.

  5. Gerar saída: Os resultados são salvos no formato JSON e impressos.

    Exemplo de Saída:

    {

    "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. Tratamento de erro:

    • Falha silenciosa para a maioria das exceções (por exemplo, arquivos ausentes, erros de comando).
    • Essa abordagem impede que o script seja encerrado prematuramente, mas pode ocultar erros durante a execução.

Exemplo: Script de Descoberta do Apache Tomcat no 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())

Depois de lidar com todos os erros, os produtos são associados a uma frota ou várias frotas para automatizar a descoberta e as operações. Quando um produto estiver na lista de usuários permitidos de uma frota, seu manual de descoberta padrão localizará e atualizará automaticamente o inventário de software com alvos do produto implantado em todos os recursos gerenciados.

Para criar um runbook, siga as etapas:

  1. Vá para a Console do OCI, navegue até Fleet Application Management e clique em Ações e Controles.

  2. Clique em Runbooks e Criar runbook.

  3. Digite Nome, Descrição, Operação do ciclo de vida, Tipo de runbook e selecione Tipo de sistema operacional e Tempo de conclusão estimado.

    Criação de Manual 1

  4. Crie seu runbook usando o designer visual, faça upload de um arquivo YAML ou JSON ou faça referência ao seu script de automação existente por meio de tarefas de script Bash ou Python dentro do runbook. Por exemplo, a amostra fornecida é um manual para descobrir o Apache Tomcat.

    Criação de manual 2

  5. Para runbooks do tipo descoberta, selecione Marcar isso como tarefa de saída de descoberta para permitir que o serviço leia e faça parsing da saída da tarefa para preencher o inventário de software.

    Observação: O serviço só poderá fazer parsing da saída se o formato da saída for baseado no modelo de saída de descoberta.

    Tarefa de Saída da Descoberta

    Veja a seguir a saída JSON (runbook\_Apache Tomcat\_discovery.json) do produto.

    {
  "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. Adicione mais tarefas para personalizar seu runbook conforme necessário.

    Editar Tarefa

Tarefa 5: Criar um Manual para Aplicar um Patch

Consulte a Tarefa 4 para criar um manual personalizado com sua sequência de aplicação de patches.

Depois de criar um produto com seus patches disponíveis e lógica de descoberta padrão, agora você pode criar um manual para aplicação de patches que inclua a sequência de automação específica dessa tecnologia e o processo de TI de sua organização. Em seguida, você definirá uma programação de manutenção para definir quando o runbook será acionado para corrigir alvos não compatíveis identificados em sua frota.

O script Bash (apache_tomcat_patching.sh) que automatiza o processo de atualização de uma instalação do Apache Tomcat é o seguinte. Além disso, você pode encontrar as tarefas associadas ao script.

  1. Inicialize as Variáveis

    • target_path: Esta extração de um arquivo target.json no diretório DATA_DIR usando jq.
    • patches_file: Esta variável pode ser usada para identificar dinamicamente o arquivo patches.json mais recente no sistema.
    • patch_url: Especifica o diretório para patches (/opt/fams/wls_patch).

  2. Exibir e Analisar Detalhes do Patch: Leia o conteúdo do arquivo patches.json para saber o seguinte:

    • Para extrair a versão de patch necessária (required_version).
    • Para determinar o nome do arquivo do patch (file_name).

  3. Verificar Arquivos Necessários

    • apache_tomcat_functions.sh:
      • Verifique a presença de um script auxiliar (apache_tomcat_functions.sh).
      • Se o arquivo estiver ausente, o script sairá com um erro.
    • Validação do Caminho do Destino:
      • Verifique se o diretório target_path existe.
      • Se ele não existir, o script sairá com um erro.

  4. Verificar a Versão Atual: Execute o script version.sh do Apache Tomcat para extrair a versão instalada atualmente (curr_version).

  5. Preparar Upgrade

    • Fazer Backup da Instalação Existente: Chame create_backup para fazer backup da instalação existente do Apache Tomcat.
    • Interromper Tomcat: Interrompa o Apache Tomcat usando uma função (stop_tomcat).

  6. Fazer Upgrade da Instalação do Apache Tomcat

    • Extrair uma Nova Versão: Extraia o novo pacote do Apache Tomcat (file_name) no diretório de destino.
    • Copiar Arquivos de Configuração:
      • Copie arquivos críticos (por exemplo, configuração, logs) da instalação antiga para uma nova usando copy_main_files.
      • Trate os erros durante esta etapa restaurando o backup.
    • Renomear e finalizar: renomeie o novo diretório para substituir o diretório de instalação antigo.

  7. Validar e Reiniciar

    • Verificar o Upgrade: Verifique a versão atualizada executando version.sh novamente.
    • Reiniciar o Apache Tomcat: Inicie o Apache Tomcat usando start_tomcat.

  8. Erro no tratamento

    • Forneça mensagens de erro significativas em vários estágios (por exemplo, arquivos ausentes, diretório não encontrado, falhas de upgrade).
    • Reverta as alterações se as operações críticas falharem (por exemplo, copiar arquivos ou renomear diretórios).

As Principais Funções Usadas São:

O que Ele Realiza?

O script fornece uma abordagem estruturada e automatizada para atualizar uma instância do Apache Tomcat, minimizando o tempo de inatividade e garantindo um mecanismo de rollback em caso de falha. Ele conta com as funções predefinidas (apache_tomcat_functions.sh) para gerenciar tarefas como interromper ou iniciar o Apache Tomcat e o tratamento de arquivos.

Veja a seguir o script Bash (apache\_tomcat\_patching.sh) de amostra com os métodos para aplicar 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"
}

Tarefa 6: Criar uma Frota

Crie uma frota e coloque seu produto na lista de permissões relacionada para descobrir seu inventário de software, saber sobre o status de conformidade de patch de software e corrigir a conformidade de patch de software.

  1. Vá para a Console do OCI, navegue até Fleet Application Management, Fleets e clique em Criar Frota.

  2. Informe o Nome e a Descrição da frota e adicione recursos.

  3. Ative a confirmação automática dos recursos do destino.

Tarefa 7: Corrigir a Conformidade de Patches de Software

Clique em Corrigir agora para corrigir a conformidade de patch de software de uma frota em sua página de detalhes ou criar uma programação na página Programações do Gerenciamento do ciclo de vida.

Se você clicar em Corrigir agora, o job de conformidade será executado nos próximos 15 minutos, enquanto que, se você selecionar a opção de programação na página Programações, poderá criar um job para o futuro ou definir uma programação recursiva. Definindo uma programação de manutenção, especifique quando o runbook será acionado para corrigir alvos não compatíveis identificados em sua frota.

Confirmações

Mais Recursos de Aprendizagem

Explore outros laboratórios em docs.oracle.com/learn ou acesse mais conteúdo de aprendizado gratuito no canal Oracle Learning YouTube. Além disso, visite education.oracle.com/learning-explorer para se tornar um Oracle Learning Explorer.

Para obter a documentação do produto, visite o Oracle Help Center.