注意：

本教程需要访问 Oracle Cloud。要注册免费账户，请参阅开始使用 Oracle Cloud Infrastructure 免费套餐。
它对 Oracle Cloud Infrastructure 身份证明、租户和区间使用示例值。完成实验室后，请使用特定于云环境的那些值替换这些值。

使用 OCI 车队应用管理自动为 Apache Tomcat 或第三方技术打补丁

简介

Oracle Cloud Infrastructure (OCI) 车队应用管理服务可帮助 IT 团队自动为 OCI 中部署的任何软件执行软件搜索和修补操作。该服务提供了用于发现和修补 Oracle 技术（包括 Oracle WebLogic Server、Oracle Linux 等）的预构建运行手册。此外，自定义的运行手册和自带产品功能允许您定义要由服务自动搜索和打补丁的产品或技术。

在本教程中，我们使用 Apache Tomcat 作为您可能经常需要修补的常用第三方技术的示例。以下各节提供了分步说明和可重用的代码示例，以指导您添加要自动搜索的 Apache Tomcat 以及使用 OCI 组应用程序管理应用补丁程序。对于要为服务打补丁的任何第三方产品，可以使用相同的流程。

注：我们使用 OCI 控制台描述该过程，但您也可以使用 Oracle Cloud Infrastructure 命令行界面 (OCI CLI) 或 API。有关 OCI 组应用程序管理的信息，请参阅组应用程序管理。

Apache Tomcat 打补丁入门

自带产品功能有助于在 OCI 车队应用管理中集成新产品，例如第三方软件、技术或应用组件。通过此功能，您可以使用服务集中管理这些组件中的补丁程序合规性和其他生命周期操作。

使用自带产品功能，您将首先在服务中创建定制产品及其合规性策略和可用补丁程序。接下来，使用定制运行簿，您将创建搜索和打补丁运行簿，从而自动执行合规性管理。

目标

使用 OCI Fleet Application Management 自动为 Apache Tomcat 或第三方技术打补丁。

任务 1：创建产品

登录到 OCI 控制台，导航到 Observability & Management ，然后选择 Fleet Application Management 。
单击管理。
在元数据管理下，单击产品和创建产品。
为新产品输入以下信息。
- Product Name（产品名称）：输入产品名称，避免任何机密信息，如密钥等。
- 版本：输入版本。
- 补丁程序类型（可选）：选择补丁程序类型。
- 兼容产品（可选）：添加兼容产品。
- 组件（可选）：选择组件。
- 身份证明名称（可选）：选择身份证明名称。

任务 2：定义补丁程序合规性策略规则

系统会为每个新产品自动创建软件补丁程序合规性策略。默认策略不包含任何策略规则。您可以编辑策略以添加规则，以指定条件来评估特定目标是否合规（如果为 true）或不合规（否则）。您可以使用各种产品属性来定义规则，例如产品版本、补丁程序类型、补丁程序严重性、补丁程序选择标准和宽限期。如果未创建策略规则，则补丁程序合规性状态将报告为不确定。

转到 OCI 控制台，导航到管理，然后单击合规性策略。
选择要修改的产品的合规性策略。（语法： Product name Compliance Policy ）。
单击创建策略规则。
输入要在条件中使用的产品版本和其他属性。

例如，策略规则可以具有以下定义：
- 规则名称：输入 Apache Tomcat。
- 产品版本：选择 10.1 及更高版本。
- 补丁程序类型：选择关键补丁程序。
- 严重性：选择 CriticalPatch 。
- 补丁程序选择：选择补丁程序级别。

任务 3：创建补丁程序元数据并上载补丁程序

创建补丁程序元数据，以便将来对添加的产品进行打补丁。然后，您应将可用的补丁程序上载到 OCI 对象存储。根据新产品的技术和可用补丁程序的类型，可以针对不同的操作系统配置上载通用补丁程序或特定程序包。

转到 OCI 控制台，导航到组应用程序管理，依次单击生命周期管理和补丁程序。
单击上载补丁程序。
输入以下信息。
- 补丁程序名称：输入名称。
- 产品：选择一个产品。
- 严重性：选择一个严重性。
- 选择相关补丁程序可指定将随当前补丁程序一起打补丁的相关补丁程序。例如，对于 Apache Tomcat，可以从此处以 apache-tomcat-10.1.25.tar.gz 格式下载以下修补程序： Central Repository：org/apache/tomcat/tomcat/10.1.25 。

任务 4：为产品创建 Discovery Runbook

该服务使用搜索运行手册来标识所添加产品的软件和版本。例如，对于 Apache Tomcat，Python 中用于搜索和收集有关系统上 Apache Tomcat 实例的详细信息的 runbook 脚本可以如下所示：

Discovery Runbook 脚本中的任务

该脚本执行以下任务：

扫描文件系统以查找 Apache Tomcat 实例。
方法 (_get_all_tomcats())：查找 Apache Tomcat 实例。
- 使用 find 命令在文件系统中搜索名为 webapps 的目录，这是 Apache Tomcat 安装的特性。
- 删除 /webapps 后缀以获取 Apache Tomcat 路径的根目录。
- 过滤出包含 backup 的路径，以避免产生冗余或无关的结果。
- 输出：返回 Apache Tomcat 安装路径的列表。
提取每个实例的版本详细信息和元数据。
为 Apache Tomcat 实例构建详细的实例字典。
发现并聚合所有 Apache Tomcat 实例。
收集有关关联 Java 环境的信息。
以 JSON 格式返回可用于报告或进一步处理的所有数据。
处理错误。

关键任务细分

找到 Apache Tomcat 实例。
提取 Apache Tomcat 版本详细信息。
- 方法 (_get_details(path))：
  - 在每个 Apache Tomcat 路径的 bin 目录中运行 version.sh 脚本。
  - 解析输出以将关键详细信息（例如，版本号）提取到字典中。
  - 处理错误：在执行或语法分析期间，将无提示地忽略任何异常。
- 输出：返回 Apache Tomcat 元数据的字典（例如，服务器编号）。
检索文件修改时间戳。
- 方法 _get_timestamp(file_path)：
  - 检查给定文件是否存在并检索其上次修改时间。
  - 将时间戳格式设置为 dd-MMM-yyyy HH:mm:ss 格式。
- 输出：返回带格式的时间戳。
收集 Java 环境详细信息。
- 方法 _get_java_details()：
  - 使用系统命令提取 Java 版本和 Java 主目录路径。
    - Java 版本：通过 java -version 获取。
    - Java 主目录路径：从 java 运行时属性中提取。
- 输出：返回包含 java_version 和 java_home 的字典。
构建详细的实例字典。
- 方法 _instance(path)：
  - 构造表示单个 Apache Tomcat 实例的字典。
    - 产品详细信息：名称、版本、目标路径等。
    - 已安装的修补程序：包括目录的版本和上次修改日期。
    - Java 属性：包括 java_version 和 java_home。
- 输出：返回 Apache Tomcat 实例的结构化字典。
搜索并聚合所有实例。
- 方法 _discovery_tomcat()：
  - 调用 _get_all_tomcats() 以查找 Apache Tomcat 路径。
  - 对每个路径进行迭代并调用 _instance(path) 以收集详细信息。
  - 将所有实例聚集到目标列表中。
- 输出：返回包含所有搜索到的目标的字典。
生成输出。
- 将搜索到的 Apache Tomcat 详细信息写入 JSON 文件。
  - 位置：/opt/fams/.scripts/tomcat_discovery.json。
  - 格式：美化输出 JSON。
- 还会将 JSON 对象输出到控制台以立即可见。

脚本流

查找 Apache Tomcat 实例：_get_all_tomcats() 方法扫描文件系统。
检索每个实例的详细信息：_get_details() 和 _instance() 方法提取相关元数据。
收集 Java 详细信息：_get_java_details() 方法提取 Java 环境属性。
聚集数据：_discovery_tomcat() 方法组合了所有实例的信息。

生成输出：结果以 JSON 格式保存并打印。

输出示例：

{

    "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"
                }
            ]
        }
    ]
}

处理时出错：
- 大多数异常的静默失败（例如，缺少文件、命令错误）。
- 此方法可防止脚本过早终止，但在执行期间可能会掩盖错误。

示例：Python 中的 Apache Tomcat Discovery 脚本

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())

在处理所有错误后，产品会与一个或几个车队关联，以自动执行发现和操作。一旦产品在组允许的用户列表中，其默认搜索运行簿将自动查找并更新软件清单，其中包含所有托管资源中部署的产品的目标。

要创建 Runbook，请执行以下步骤：

转到 OCI 控制台，导航到组应用程序管理，然后单击操作和控制。
单击运行工作簿和创建运行工作簿。
输入名称、说明、生命周期操作、工作簿类型，然后选择操作系统 (OS) 类型和估计完成时间。
使用可视化设计器创建 Runbook，上载 YAML 或 JSON 文件，或者通过 Runbook 中的 Bash 或 Python 脚本任务引用现有自动化脚本。例如，提供的示例是一个用于发现 Apache Tomcat 的运行手册。

对于类型为“搜索”的 Runbook，选择将此任务标记为搜索输出任务以允许服务读取并解析任务的输出以填充软件清单。

注：仅当输出的格式基于搜索输出模板时，服务才能对输出进行语法分析。

搜索输出任务

下面是产品的 JSON 输出 (runbook\_Apache Tomcat\_discovery.json)。

{
  "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": {}
}

根据需要添加更多任务来定制运行手册。

任务 5：创建用于应用补丁程序的 Runbook

请参阅任务 4 以创建具有打补丁顺序的定制运行簿。

在创建具有可用补丁程序和默认搜索逻辑的产品后，您现在可以创建用于打补丁的运行手册，其中包含特定于此技术的自动化序列和组织的 IT 流程。然后，您将定义维护计划，以定义何时触发运行簿来为组中标识的不合规目标打补丁。

自动执行 Apache Tomcat 安装升级过程的 Bash 脚本 (apache_tomcat_patching.sh)，如下所示。此外，还可以查找与脚本关联的任务。

初始化变量
- target_path：使用 jq 从 DATA_DIR 目录中的 target.json 文件中提取。
- patches_file：此变量可用于动态标识系统中的最新 patches.json 文件。
- patch_url：此项指定修补程序的目录 (/opt/fams/wls_patch)。
显示和解析修补程序详细信息：读取以下内容的 patches.json 文件：
- 提取所需的修补程序版本 (required_version)。
- 确定修补程序的文件名 (file_name)。
检查所需文件
- apache_tomcat_functions.sh:
  - 确保存在帮助程序脚本 (apache_tomcat_functions.sh)。
  - 如果缺少文件，脚本将退出并显示错误。
- 目标路径验证：
  - 检验 target_path 目录是否存在。
  - 如果该脚本不存在，则会退出并显示错误。
检查当前版本：运行 Apache Tomcat 的 version.sh 脚本以提取当前安装的版本 (curr_version)。
准备升级
- 备份现有安装：调用 create_backup 以备份现有的 Apache Tomcat 安装。
- 停止 Tomcat：使用函数 (stop_tomcat) 停止 Apache Tomcat。
升级 Apache Tomcat 安装
- 提取新版本：将新的 Apache Tomcat 软件包 (file_name) 提取到目标目录中。
- 复制配置文件：
  - 使用 copy_main_files 将关键文件（例如，配置、日志）从旧安装复制到新安装。
  - 通过还原备份来处理此步骤中的错误。
- 重命名和完成：重命名新目录以替换旧的安装目录。
验证并重新启动
- 验证升级：通过再次运行 version.sh 检查升级的版本。
- 重新启动 Apache Tomcat：使用 start_tomcat 启动 Apache Tomcat。
处理错误
- 在不同阶段提供有意义的错误消息（例如，缺少文件、未找到目录、升级失败）。
- 如果关键操作失败，则回退更改（例如，复制文件或重命名目录）。

使用的关键功能包括：

stop_tomcat：停止 Tomcat 服务。
create_backup：创建现有 Tomcat 目录的备份。
copy_main_files：将必要文件从旧安装传输到新安装。
start_tomcat：启动升级的 Tomcat 服务。

它完成什么？

该脚本提供了一种结构化和自动化的方法来升级 Apache Tomcat 实例，最大限度地减少停机时间，并确保在发生故障时回滚机制。它依赖于预定义的函数 (apache_tomcat_functions.sh) 来管理任务，例如停止或启动 Apache Tomcat 和文件处理。

下面是 Bash (apache\_tomcat\_patching.sh) 脚本样例，其中包含应用修补程序的方法。

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

任务 6：创建组

创建组并获取相关允许列表中的产品，以发现其软件清单，了解软件补丁程序合规性状态并修复软件补丁程序合规性。

转到 OCI 控制台，导航到组应用程序管理、组，然后单击创建组。
输入组的名称和说明并添加资源。
启用目标资源的自动确认。

任务 7：修复软件修补程序合规性

单击立即修复以修复组在详细信息页上的软件补丁程序合规性，或者从生命周期管理的调度页创建调度。

如果单击立即修复，相容性作业将在接下来的 15 分钟内运行，而如果从调度页中选择调度选项，则可以为将来创建作业或设置递归调度。通过定义维护计划，指定何时触发运行簿来为组中标识的不合规目标打补丁。

确认

Authors - Shabbir Hussain（咨询成员技术人员）、Fabio Bonisoli（车队应用管理产品经理）