附註：

此教學課程需要存取 Oracle Cloud。若要註冊免費帳戶，請參閱 Oracle Cloud Infrastructure Free Tier 入門。
它使用 Oracle Cloud Infrastructure 證明資料、租用戶及區間的範例值。完成實驗室時，請將這些值取代為您雲端環境特定的值。

使用 OCI Fleet Application Management 自動修補 Apache Tomcat 或第三方技術

簡介

Oracle Cloud Infrastructure (OCI) Fleet Application Management 服務可讓 IT 團隊針對部署在 OCI 中的任何軟體，將軟體探索和修補作業自動化。此服務提供預建的 Runbook，用於探索和修補 Oracle 技術，包括 Oracle WebLogic Server、Oracle Linux 等。此外，自訂 Runbook 和自備產品功能可讓您定義要由服務自動尋找和修正的產品或技術。

在本教學課程中，我們將使用 Apache Tomcat 做為經常需要修補的常用協力廠商技術的範例。下列各節提供逐步指示和可重複使用的程式碼範例，引導您使用 OCI Fleet Application Management 新增要自動探索的 Apache Tomcat 及套用修補程式。對於您想要使用服務修補的任何協力廠商產品，都可以使用相同的程序。

注意：我們使用 OCI 主控台描述此處理作業，但也可以使用 Oracle Cloud Infrastructure 命令行介面 (OCI CLI) 或 API。如需 OCI 機組應用程式管理的相關資訊，請參閱機組應用程式管理。

開始使用修正 Apache Tomcat

自備產品功能有助於在 OCI Fleet Application Management 中整合新產品，例如第三方軟體、技術或應用程式元件。這項功能可以透過使用服務，集中管理各種元件的修正程式規範和其他週期作業。

使用自備產品功能，您將先在服務中建立您的自訂產品，以及其規範原則和可用的修補程式。接下來，使用自訂 Runbook，您將同時建立尋找和修補 Runbooks，讓您能夠將法規遵循管理自動化。

目標

使用 OCI Fleet Application Management 自動為 Apache Tomcat 或第三方技術進行修補。

作業 1：建立產品

登入 OCI 主控台，瀏覽至可觀測性與管理，然後選取機組應用程式管理。
按一下管理。
在中繼資料管理下，按一下產品與建立產品。
為新產品輸入以下資訊。
- 產品名稱：輸入產品名稱，避免任何機密資訊 (例如金鑰等等)。
- 版本：輸入版本。
- 修正程式類型 ( 選擇性 )：選取修正程式類型。
- 相容產品 ( 選擇性 )：新增相容產品。
- 元件 ( 選擇性 )：選取元件。
- 證明資料名稱 ( 選擇性 )：選取證明資料名稱。

作業 2：定義修正程式相容性原則規則

系統會自動為每項新產品建立軟體修正程式規範原則。預設策略不包含任何策略規則。您可以編輯原則來新增規則，以指定評估特定目標是否符合 (如果為 true) 或不符合 (否則) 的條件。您可以使用各種產品屬性來定義規則，例如產品版本、修正程式類型、修正程式嚴重度、修正程式選取條件以及寬限期。如果未建立原則規則，則會將修正程式相容性狀態報告為判斷。

移至 OCI 主控台，瀏覽至管理，然後按一下規範原則。
選取您需要修改之產品的相容性原則。(語法： Product name Compliance Policy)。
按一下建立原則規則。
輸入要在條件中使用的產品版本和其他屬性。

例如，原則規則可以具有下列定義：
- 規則名稱：輸入 Apache Tomcat。
- 產品版本：選取 10.1 與更新版本。
- 修正程式類型：選取重要修正程式。
- 嚴重程度：選取 CriticalPatch 。
- 修正程式選擇：選取修正程式層次。

作業 3：建立修正程式描述資料並上傳修正程式

建立修正程式描述資料，以便日後更容易為您新增的產品進行修正。然後，您應該將可用的修正程式上傳到 OCI Object Storage。視新產品的技術和可用的修正程式類型而定，您可以上傳不同作業系統組態的一般修正程式或特定套裝程式。

移至 OCI 主控台，瀏覽至機組應用程式管理，按一下生命週期管理，然後按一下修正程式。
按一下上傳修正程式。
請輸入下列資訊。
- 修正程式名稱：輸入名稱。
- 產品：選取一個產品。
- 嚴重度： 選取嚴重度。
- 選取相依修正程式，即可指定要與目前修正程式一起修正的相依修正程式。例如，若為 Apache Tomcat，可從此處以 apache-tomcat-10.1.25.tar.gz 下載下列修正程式： Central Repository：org/apache/tomcat/tomcat/10.1.25 。

作業 4：建立產品的尋找 Runbook

此服務使用尋找 Runbook 來識別新增產品的軟體和版本。例如，在 Apache Tomcat 的情況下，Python 中的 runbook 命令檔會尋找並收集系統上 Apache Tomcat 執行處理的相關詳細資訊如下：

尋找 Runbook 命令檔中的作業

程序檔會執行以下作業：

掃描檔案系統以找出 Apache Tomcat 實例。
方法 (_get_all_tomcats())：尋找 Apache Tomcat 執行處理。
- 使用 find 命令搜尋檔案系統，尋找名為 webapps 的目錄，這是 Apache Tomcat 安裝的特性。
- 移除 /webapps 字尾，以取得 Apache Tomcat 路徑的根目錄。
- 篩選出包含備份的路徑，以避免多餘或無關的結果。
- 輸出：傳回 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 會自動尋找軟體產品目錄，並以所有受管理資源之已部署產品的目標更新軟體產品目錄。

若要建立 Runbook，請依照下列步驟執行：

移至 OCI 主控台，瀏覽至機組應用程式管理，然後按一下動作與控制項。
按一下執行簿和建立執行簿。
輸入名稱、描述、生命週期作業、執行簿類型，然後選取作業系統 (OS) 類型和預估完成時間。
使用視覺設計工具建立 Runbook、上傳 YAML 或 JSON 檔案，或透過 Runbook 中的 Bash 或 Python 指令碼任務參考您現有的自動化指令碼。例如，提供的範例是用來尋找 Apache Tomcat 的 Runbook。

如果是類型尋找的 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": {}
}

視需要新增更多工作來自訂您的 Runbook。

作業 5：建立套用修正程式的 Runbook

請參閱「工作 4」，以使用您的修正順序建立自訂 Runbook。

使用產品可用的修正程式和預設尋找邏輯建立產品之後，您現在可以建立用於修正的 Runbook，其中包含此技術特有的自動化序列和組織的 IT 處理作業。接著，您將定義維護排程，以定義何時觸發 Runbook 來修正機組中識別的不相容目標。

自動升級 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 分鐘內執行，而如果您從排程頁面選取排程選項，則可以建立未來的工作或設定遞迴排程。定義維護排程，指定何時觸發 Runbook 來修正機組中識別的不相容目標。

認可

作者 - Shabbir Hussain (諮詢成員技術人員)、Fabio Bonisoli (車隊應用軟體管理產品經理)

其他學習資源

探索 docs.oracle.com/learn 上的其他實驗室，或存取 Oracle Learning YouTube 頻道上的更多免費學習內容。此外，請造訪 education.oracle.com/learning-explorer 以成為 Oracle Learning Explorer。

如需產品文件，請造訪 Oracle Help Center 。

標題與著作權資訊

Automate Patching for Apache Tomcat or a Third-Party Technology with OCI Fleet Application Management

G23649-01

December 2024

Oracle 和 (或) 其關係企業。