주:

이 자습서에서는 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에 배포된 모든 소프트웨어에 대한 소프트웨어 검색 및 패치 작업을 자동화할 수 있습니다. 이 서비스는 Oracle WebLogic Server, Oracle Linux 등 Oracle 테크놀로지를 검색 및 패치하기 위한 사전 구축된 런북을 제공합니다. 또한 사용자 정의 런북 및 자체 제품 가져오기 기능을 통해 서비스에서 자동으로 검색 및 패치할 제품 또는 기술을 정의할 수 있습니다.

이 자습서에서는 패치를 적용해야 하는 인기 있는 타사 기술의 예로 Apache Tomcat을 사용하고 있습니다. 다음 섹션에서는 단계별 지침과 재사용 가능한 코드 샘플을 제공하여 OCI Fleet Application Management를 사용하여 자동으로 검색하고 패치를 적용할 Apache Tomcat을 추가하는 방법을 안내합니다. 서비스에 패치를 적용하려는 타사 제품에 대해서도 동일한 프로세스를 사용할 수 있습니다.

참고: OCI 콘솔을 사용하는 프로세스에 대해 설명하지만, Oracle Cloud Infrastructure 명령행 인터페이스(OCI CLI) 또는 API를 사용할 수도 있습니다. OCI 플리트 애플리케이션 관리에 대한 자세한 내용은 플리트 애플리케이션 관리를 참조하십시오.

Apache Tomcat 패치 시작하기

BYOD(Bring Your Own Product) 기능은 타사 소프트웨어, 기술, 애플리케이션 구성요소 등 OCI 플리트 애플리케이션 관리 내에서 신제품의 통합을 용이하게 합니다. 이 기능을 사용하면 서비스를 사용하여 다양한 구성 요소에서 패치 준수 및 기타 수명 주기 작업을 중앙 집중화할 수 있습니다.

자체 제품 가져오기 기능을 사용하면 먼저 준수 정책 및 사용 가능한 패치와 함께 서비스에서 사용자 정의 제품을 만들 수 있습니다. 다음으로, 커스텀 런북을 사용해 검색 및 패칭 런북을 모두 생성함으로써 규정 준수 관리를 자동화할 수 있습니다.

목표

OCI Fleet Application Management를 통해 Apache Tomcat 또는 타사 기술에 대한 패치 적용을 자동화합니다.

작업 1: 제품 생성

OCI 콘솔에 로그인하고 관찰 가능성 및 관리로 이동한 후 플리트 애플리케이션 관리를 선택합니다.
관리를 누릅니다.
메타데이터 관리에서 제품 및 제품 생성을 누릅니다.
새 제품에 대해 다음 정보를 입력합니다.
- 제품 이름: 제품 이름을 입력하고 키 등의 기밀 정보를 사용하지 않습니다.
- 버전: 버전을 입력합니다.
- 패치 유형(선택사항): 패치 유형을 선택합니다.
- 호환 제품(선택 사항): 호환 제품을 추가합니다.
- 구성 요소(선택 사항): 구성 요소를 선택합니다.
- 인증서 이름(선택사항): 인증서 이름을 선택합니다.

작업 2: 패치 준수 정책 규칙 정의

새 제품마다 자동으로 소프트웨어 패치 준수 정책이 생성됩니다. 기본 정책에는 정책 규칙이 포함되어 있지 않습니다. 정책을 편집하여 특정 대상이 호환되는지(true인 경우) 또는 비준수(else)인지 평가할 조건을 지정할 수 있습니다. 다양한 제품 속성을 사용하여 제품 버전, 패치 유형, 패치 심각도, 패치 선택 기준, 유예 기간 등의 규칙을 정의할 수 있습니다. 정책 규칙을 만들지 않으면 패치 준수 상태가 indeterminate로 보고됩니다.

OCI 콘솔로 이동하여 관리로 이동하고 준수 정책을 누릅니다.
수정해야 하는 제품의 준수 정책을 선택합니다. (구문: Product name Compliance Policy).
정책 규칙 생성을 누릅니다.
조건에 사용할 제품 버전 및 기타 속성을 입력합니다.

예를 들어, 정책 규칙에는 다음 정의가 포함될 수 있습니다.
- 규칙 이름: Apache Tomcat를 입력합니다.
- 제품 버전: 10.1 이상을 선택합니다.
- 패치 유형: 중요한 패치를 선택합니다.
- 심각도: CriticalPatch을 선택합니다.
- 패치 선택: 패치 레벨을 선택합니다.

작업 3: 패치 메타데이터 생성 및 패치 업로드

추가한 제품에 대한 이후 패치 작업을 보다 쉽게 수행할 수 있도록 패치 메타 데이터를 생성합니다. 그런 다음 사용 가능한 패치를 OCI Object Storage에 업로드해야 합니다. 신제품에 사용 가능한 패치의 기술 및 유형에 따라 다양한 운영 체제 구성에 맞게 일반 패치나 특정 패키지를 업로드할 수 있습니다.

OCI 콘솔로 이동하여 플리트 애플리케이션 관리로 이동하고 수명 주기 관리, 패치를 차례로 누릅니다.
Upload Patch를 누릅니다.
다음 정보를 입력하십시오.
- 패치 이름: 이름을 입력합니다.
- 제품: 제품을 선택합니다.
- 심각도: 심각도를 선택합니다.
- 현재 패치와 함께 패치될 종속 패치를 지정하려면 종속 패치를 선택합니다. 예를 들어, Apache Tomcat의 경우 Central Repository: org/apache/tomcat/tomcat/10.1.25에서 다음 패치를 apache-tomcat-10.1.25.tar.gz로 다운로드할 수 있습니다.

작업 4: 제품에 대한 검색 실행 문서 생성

이 서비스는 검색 런북을 사용하여 추가된 제품의 소프트웨어 및 버전을 식별합니다. 예를 들어, Apache Tomcat의 경우 시스템에서 Apache Tomcat 인스턴스에 대한 세부정보를 검색하고 수집하기 위한 Python의 런북 스크립트는 다음과 같을 수 있습니다.

검색 실행 설명서 스크립트의 작업

이 스크립트는 다음 작업을 수행합니다.

파일 시스템을 스캔하여 Apache Tomcat 인스턴스를 찾습니다.
메소드(_get_all_tomcats()): Apache Tomcat 인스턴스를 찾습니다.
- find 명령을 사용하여 Apache Tomcat 설치의 특징인 webapps라는 디렉토리의 파일 시스템을 검색합니다.
- Apache Tomcat 경로의 루트를 가져오기 위해 /webapps 접미어를 제거합니다.
- 중복되거나 관련이 없는 결과가 발생하지 않도록 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():
  - Apache Tomcat 경로를 찾으려면 _get_all_tomcats()를 호출합니다.
  - 각 경로를 반복하고 _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 검색 스크립트

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

모든 오류를 처리한 후 제품은 차량 또는 여러 차량과 연관되어 검색 및 운영을 자동화합니다. 제품이 플리트에 대해 허용된 사용자 목록에 있으면 기본 검색 런북은 모든 관리 리소스에 걸쳐 배치된 제품의 대상으로 소프트웨어 인벤토리를 자동으로 찾아 업데이트합니다.

런북을 생성하려면 다음과 같이 하십시오.

OCI 콘솔로 이동하여 플리트 애플리케이션 관리로 이동한 후 작업 및 제어를 누릅니다.
런북 및 런북 생성을 누릅니다.
이름, 설명, 수명 주기 작업, 런북 유형을 입력하고 OS(운영체제) 유형 및 예상 완료 시간을 선택합니다.
비주얼 디자이너를 사용하여 런북을 만들거나, YAML 또는 JSON 파일을 업로드하거나, 런북 내의 Bash 또는 Python 스크립트 작업을 통해 기존 자동화 스크립트를 참조할 수 있습니다. 예를 들어, 제공된 샘플은 Apache Tomcat을 검색하기 위한 런북입니다.

검색 유형의 런북에 대해 서비스가 작업 출력을 읽고 구문 분석하여 소프트웨어 인벤토리를 채울 수 있도록 하려면 검색 출력 작업으로 표시를 선택합니다.

주: 출력 형식이 검색 출력 템플리트를 기반으로 하는 경우에만 서비스에서 출력을 구문 분석할 수 있습니다.

검색 출력 태스크

다음은 제품의 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)을 인출합니다.
업그레이드 준비
- 기존 설치 백업: 기존 Apache Tomcat 설치를 백업하려면 create_backup를 호출합니다.
- 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(Consulting Member Technical Staff), Fabio Bonisoli(Fleet Application Management Product Manager)

추가 학습 자원

docs.oracle.com/learn에서 다른 실습을 탐색하거나 Oracle Learning YouTube 채널에서 더 많은 무료 학습 콘텐츠에 액세스하세요. 또한 Oracle Learning Explorer가 되려면 education.oracle.com/learning-explorer을 방문하십시오.

제품 설명서는 Oracle Help Center를 참조하십시오.

제목 및 저작권 정보

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

G23646-01

December 2024

Oracle and/or its affiliates.