ノート:

OCIフリート・アプリケーション管理によるApache Tomcatまたはサードパーティ・テクノロジのパッチ適用の自動化

イントロダクション

Oracle Cloud Infrastructure (OCI) Fleet Application Managementサービスにより、ITチームは、OCIにデプロイされたソフトウェアのソフトウェア検出およびパッチ操作を自動化できます。このサービスは、Oracle WebLogic Server、Oracle LinuxなどのOracleテクノロジを検出してパッチ適用するための事前構築済みのランブックを提供します。また、カスタム・ランブックおよびBring Your Own Product機能を使用すると、サービスによって自動的に検出およびパッチ適用される製品またはテクノロジを定義できます。

このチュートリアルでは、Apache Tomcatをよくパッチを適用する必要がある一般的なサードパーティ・テクノロジの例として使用しています。次の項では、OCI Fleet Application Managementを使用してApache Tomcatを自動的に検出してパッチを適用する手順および再利用可能なコード・サンプルを順を追って説明します。サービスでパッチを適用するサードパーティ製品には、同じプロセスを使用できます。

ノート: OCIコンソールを使用してプロセスを説明していますが、Oracle Cloud Infrastructureコマンドライン・インタフェース(OCI CLI)またはAPIを使用することもできます。OCIフリート・アプリケーション管理の詳細は、「フリート・アプリケーション管理」を参照してください。

Apache Tomcatへのパッチ適用の開始

Bring Your Own Product機能は、サードパーティのソフトウェア、テクノロジ、アプリケーション・コンポーネントなど、OCI Fleet Application Management内の新製品の統合を容易にします。この機能により、サービスを使用して、パッチ・コンプライアンスおよびその他のライフサイクル操作をこれらの様々なコンポーネントにわたって一元化できます。

Bring Your Own Product機能を使用して、まず、コンプライアンス・ポリシーおよび使用可能なパッチとともにサービスにカスタム製品を作成します。次に、カスタム・ランブックを使用して、検出とパッチ適用の両方のランブックを作成し、コンプライアンス管理を今後も自動化できるようにします。

目的

タスク1: 製品の作成

  1. OCIコンソールにログインし、「監視および管理」に移動して「フリート・アプリケーション管理」を選択します。

  2. 「管理」をクリックします。

  3. 「メタデータ管理」で、「製品」および「製品の作成」をクリックします。

    製品作成1

  4. 新製品に関する次の情報を入力します。

    • 製品名:キーなどの機密情報を回避して、製品名を入力します。
    • バージョン:バージョンを入力します。
    • パッチ・タイプ(オプション):パッチ・タイプを選択します。
    • 互換性のある製品(オプション):互換性のある製品を追加します。
    • コンポーネント(オプション):コンポーネントを選択します。
    • 資格証明名(オプション):資格証明名を選択します。

    製品作成2

タスク2: パッチ・コンプライアンス・ポリシー・ルールの定義

ソフトウェア・パッチ・コンプライアンス・ポリシーは、新製品ごとに自動的に作成されます。デフォルト・ポリシーにはポリシー・ルールは含まれません。ポリシーを編集してルールを追加し、特定のターゲットが準拠(trueの場合)か非準拠(elseの場合)かを評価する条件を指定できます。様々な製品属性を使用して、製品バージョン、パッチ・タイプ、パッチの重大度、パッチ選択基準、猶予期間などのルールを定義できます。ポリシー・ルールを作成しない場合、パッチ・コンプライアンス・ステータスはindeterminateとしてレポートされます。

  1. OCIコンソールに移動し、「管理」に移動して、「コンプライアンス・ポリシー」をクリックします。

  2. 変更する必要がある製品のコンプライアンス・ポリシーを選択します。(構文: Product name Compliance Policy)。

  3. 「ポリシー・ルールの作成」をクリックします。

  4. 条件で使用する製品バージョンおよびその他の属性を入力します。

    コンプライアンス・ポリシー・ルール1

    たとえば、ポリシー・ルールには次の定義を含めることができます。

    • ルール名: Apache Tomcatと入力します。
    • 製品バージョン: 10.1以上を選択します。
    • パッチ・タイプ: 「クリティカル・パッチ」を選択します。
    • 重要度: CriticalPatchを選択します。
    • パッチの選択: 「パッチ・レベル」を選択します。

    コンプライアンス・ポリシー・ルール2

タスク3: パッチ・メタデータの作成およびパッチのアップロード

パッチ・メタデータを作成して、追加した製品に対する今後のパッチ適用を容易にします。その後、使用可能なパッチをOCI Object Storageにアップロードする必要があります。テクノロジおよび新製品で使用可能なパッチのタイプに応じて、様々なオペレーティング・システム構成に対して汎用パッチまたは特定のパッケージをアップロードできます。

  1. OCIコンソールに移動し、「フリート・アプリケーション管理」に移動し、「ライフサイクル管理」、「パッチ」の順にクリックします。

  2. 「パッチのアップロード」をクリックします。

  3. 次の情報を入力します

    • パッチ名:名前を入力します。
    • プロダクト:プロダクトを選択します。
    • 重大度:重大度を選択します。
    • 「依存パッチ」を選択して、パッチを適用する依存パッチを現在のパッチとともに指定します。たとえば、Apache Tomcatの場合、中央リポジトリ: org/apache/tomcat/tomcat/10.1.25からapache-tomcat-10.1.25.tar.gzとして次のパッチをダウンロードできます。

    パッチのアップロード

タスク4: 製品の検出ランブックの作成

このサービスでは、検出ランブックを使用して、追加された製品のソフトウェアおよびバージョンを識別します。たとえば、Apache Tomcatの場合、システム上のApache Tomcatインスタンスに関する詳細を検出および収集するためのPythonのrunbookスクリプトは次のようになります。

検出ランブック・スクリプトのタスク

このスクリプトは次のタスクを実行します。

重要なタスクの内訳

  1. Apache Tomcatインスタンスを探します。

  2. Apache Tomcatバージョン詳細を抽出します。

    • メソッド(_get_details(path)):
      • 各Apache Tomcatパスのbinディレクトリでversion.shスクリプトを実行します。
      • 出力を解析して、キーの詳細(バージョン番号など)をディクショナリに抽出します。
      • エラーの処理: 実行中または解析中の例外はすべて暗黙的に無視されます。
    • 出力: Apache Tomcatメタデータのディクショナリ(サーバー番号など)を返します。

  3. ファイル変更タイムスタンプを取得します。

    • メソッド_get_timestamp(file_path):
      • 指定されたファイルが存在するかどうかを確認し、その最終変更時間を取得します。
      • タイムスタンプをdd-MMM-yyyy HH:mm:ss形式で書式設定します。
    • 出力:書式設定されたタイムスタンプを返します。

  4. Java環境の詳細を収集します。

    • メソッド_get_java_details():
      • システム・コマンドを使用して、JavaバージョンおよびJavaホーム・パスをフェッチします。
        • Javaバージョン: java -versionで取得されます。
        • Javaホーム・パス: javaランタイム・プロパティから抽出されます。
    • 出力: java_versionおよびjava_homeを含むディクショナリを返します。

  5. 詳細なインスタンス・ディクショナリを作成します。

    • メソッド_instance(path):
      • 単一のApache Tomcatインスタンスを表すディクショナリを構築します。
        • 製品詳細:名前、バージョン、ターゲット・パスなど。
        • インストール済パッチ:ディレクトリのバージョンと最終変更日が含まれます。
        • Javaプロパティ: java_versionおよびjava_homeが含まれます。
    • 出力: Apache Tomcatインスタンスの構造化ディクショナリを返します。

  6. すべてのインスタンスを検出して集計します。

    • メソッド_discovery_tomcat():
      • _get_all_tomcats()をコールして、Apache Tomcatパスを検索します。
      • 各パスを反復し、_instance(path)をコールして詳細を収集します。
      • すべてのインスタンスをターゲット・リストに集計します。
    • 出力:検出されたすべてのターゲットを含むディクショナリを返します。

  7. 出力を生成します。

    • 検出されたApache Tomcatの詳細をJSONファイルに書き込みます。
      • 場所: /opt/fams/.scripts/tomcat_discovery.json。
      • 形式:プリティプリントされたJSON。
    • また、すぐに表示できるようにJSONオブジェクトをコンソールに出力します。

スクリプト・フロー

  1. Apache Tomcatインスタンスの検索: _get_all_tomcats()メソッドは、ファイルシステムをスキャンします。

  2. 各インスタンスの詳細の取得: _get_details()および_instance()メソッドは、関連するメタデータを抽出します。

  3. Javaの詳細の収集: _get_java_details()メソッドは、Java環境プロパティをフェッチします。

  4. データの集計: _discovery_tomcat()メソッドは、すべてのインスタンスの情報を結合します。

  5. 出力の生成:結果は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"
                }
            ]
        }
    ]
}

  6. エラー処理:

    • ほとんどの例外(ファイルの欠落、コマンド・エラーなど)のサイレント障害。
    • この方法では、スクリプトが途中で終了するのを防ぎますが、実行中にエラーが不明瞭になることがあります。

例: PythonでのApache Tomcat検出スクリプト

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

すべてのエラーを処理した後、製品はフリートまたは複数のフリートに関連付けられ、検出と操作を自動化します。製品がフリートに対して許可されたユーザーのリストに表示されると、そのデフォルトの検出ランブックによって、すべての管理対象リソースにわたってデプロイされた製品のターゲットでソフトウェア・インベントリが自動的に検索および更新されます。

ランブックを作成するには、次のステップを実行します。

  1. OCIコンソールに移動し、「フリート・アプリケーション管理」に移動して、「アクションおよびコントロール」をクリックします。

  2. 「Runbooks」および「Create runbook」をクリックします。

  3. 「名前」、「説明」、「ライフサイクル操作」、「ランブック・タイプ」を入力し、「オペレーティング・システム(OS)タイプ」および「推定完了時間」を選択します。

    ランブック作成1

  4. ビジュアル・デザイナを使用したランブックの作成、YAMLまたはJSONファイルのアップロード、またはランブック内のBashまたはPythonスクリプト・タスクを介した既存の自動化スクリプトの参照を行います。たとえば、提供されているサンプルは、Apache Tomcatを検出するためのランブックです。

    ランブック作成2

  5. 検出タイプのランブックの場合、「検出出力タスクとしてマーク」を選択して、サービスがタスクの出力を読み取って解析し、ソフトウェア・インベントリに移入できるようにします。

    ノート:サービスは、出力の形式が検出出力テンプレートに基づいている場合にのみ、出力を解析できます。

    検出出力タスク

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

  6. 必要に応じて、タスクを追加してランブックをカスタマイズします。

    タスクの編集

タスク5: パッチを適用するためのランブックの作成

パッチ適用順序を使用してカスタム・ランブックを作成するには、タスク4を参照してください。

使用可能なパッチとデフォルトの検出ロジックを使用して製品を作成した後、このテクノロジおよび組織のITプロセスに固有の自動化シーケンスを含むパッチ適用のランブックを作成できるようになりました。次に、メンテナンス・スケジュールを定義して、フリートで識別される非準拠ターゲットにパッチを適用するために、ランブックをトリガーするタイミングを定義します。

Apache Tomcatインストールのアップグレード・プロセスを自動化するBashスクリプト(apache_tomcat_patching.sh)は次のとおりです。また、スクリプトに関連付けられているタスクも確認できます。

  1. 変数の初期化

    • target_path: jqを使用して、DATA_DIRディレクトリのtarget.jsonファイルから抽出します。
    • patches_file:この変数を使用して、システム内の最新のpatches.jsonファイルを動的に識別できます。
    • patch_url:パッチのディレクトリ(/opt/fams/wls_patch)を指定します。

  2. パッチ詳細の表示および解析: patches.jsonファイルの内容を読み取ります。

    • 必要なパッチ・バージョン(required_version)を抽出します。
    • パッチのファイル名(file_name)を決定します。

  3. 必須ファイルのチェック

    • apache_tomcat_functions.sh:
      • ヘルパー・スクリプト(apache_tomcat_functions.sh)が存在することを確認します。
      • ファイルが欠落している場合、スクリプトはエラーで終了します。
    • ターゲット・パスの検証:
      • target_pathディレクトリが存在することを確認してください。
      • 存在しない場合、このスクリプトはエラーで終了します。

  4. 現在のバージョンの確認: Apache Tomcatのversion.shスクリプトを実行して、現在インストールされているバージョン(curr_version)をフェッチします。

  5. アップグレードの準備

    • 既存のインストールのバックアップ: create_backupをコールして、既存のApache Tomcatインストールをバックアップします。
    • Tomcatの停止:関数(stop_tomcat)を使用してApache Tomcatを停止します。

  6. Apache Tomcatインストールのアップグレード

    • 新規バージョンの抽出:新しいApache Tomcatパッケージ(file_name)をターゲット・ディレクトリに抽出します。
    • 構成ファイルのコピー:
      • copy_main_filesを使用して、古いインストールから新しいインストールに重要なファイル(構成、ログなど)をコピーします。
      • バックアップをリストアして、このステップ中のエラーを処理します。
    • 名前変更および確定:新しいディレクトリの名前を変更して、古いインストール・ディレクトリを置き換えます。

  7. 検証および再起動

    • アップグレードの確認: version.shを再度実行して、アップグレードされたバージョンを確認します。
    • Apache Tomcatの再起動: start_tomcatを使用してApache Tomcatを起動します。

  8. ハンドル・エラー

    • 様々なステージで意味のあるエラー・メッセージ(ファイルの欠落、ディレクトリが見つかりません、アップグレードの失敗など)を提供します。
    • クリティカルな操作が失敗した場合(ファイルのコピーやディレクトリ名の変更など)、変更をロールバックします。

使用される主な機能は次のとおりです。

何が実現しますか。

このスクリプトは、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: フリートの作成

フリートを作成し、関連する許可リストに製品を取得して、ソフトウェア・インベントリを検出し、ソフトウェア・パッチ・コンプライアンス・ステータスを把握し、ソフトウェア・パッチ・コンプライアンスを修正します。

  1. OCIコンソールに移動し、「フリート・アプリケーション管理」、「フリート」に移動して、「フリートの作成」をクリックします。

  2. フリートの「名前」および「説明」を入力し、リソースを追加します。

  3. ターゲットのリソースの自動確認を有効にします。

タスク7: ソフトウェア・パッチ・コンプライアンスの修正

「今すぐ修正」をクリックして、フリートのソフトウェア・パッチ・コンプライアンスを詳細ページで修正するか、ライフサイクル管理の「スケジュール」ページからスケジュールを作成します。

「今すぐ修正」をクリックすると、コンプライアンス・ジョブは次の15分以内に実行されますが、「スケジュール」ページからスケジュール・オプションを選択した場合、将来のジョブを作成することも、再帰的なスケジュールを設定することもできます。メンテナンス・スケジュールを定義して、フリートで識別された非準拠ターゲットにパッチを適用するために、ランブックをトリガーするタイミングを指定します。

承認

その他の学習リソース

docs.oracle.com/learnの他のラボを確認するか、Oracle Learning YouTubeチャネルで無料のラーニング・コンテンツにアクセスしてください。また、education.oracle.com/learning-explorerにアクセスしてOracle Learning Explorerになります。

製品ドキュメントは、Oracle Help Centerを参照してください。