Creazione di un Runbook per la ricerca automatica

Creare un runbook per eseguire la scansione e identificare le home Apache Tomcat installate sulle risorse in Fleet Application Management.

  1. Creare un runbook per scoprire le home Apache Tomcat.
    Fornire informazioni di base quali il nome del runbook (Apache Tomcat Discovery), selezionare il prodotto personalizzato Apache Tomcat, l'operazione del ciclo di vita (Discovery) e il sistema operativo richiesto (Linux).

    Aggiungere gruppi di risorse paralleli o in sequenza a seconda di come si desidera che l'esecuzione dei task venga eseguita tra le risorse e configurarle.

  2. Aggiungere un task al runbook.
    Nota

    Assicurarsi di selezionare Contrassegna come task di output di ricerca automatica.
    Questa azione identifica il task risultato target, indicando a Fleet Application Management che la risposta del task deve essere letta e interpretata per la raccolta dell'inventario software.
  3. Caricare lo script del task del runbook dal file system o dallo storage degli oggetti. Vedere Script di esempio per la ricerca automatica di un prodotto.
    Lo script deve acquisire informazioni quali la home del prodotto o il percorso di destinazione, la versione del prodotto, le patch installate (se presenti) e la home Java e la relativa versione. Fleet Application Management può eseguire lo script o il programma sull'istanza di computazione se supporta un ambiente di esecuzione appropriato o se sono installati i pacchetti software o le librerie. Lo script deve generare i risultati in formato JSON come specificato dal modello di download della ricerca automatica. Vedere Sample YAML for Discovery.
    Ad esempio:
    • I dettagli dello script possono essere i seguenti: Object Storage > compartment: mycompartment > my_bucket > apache_tomcat_discovery.zip (diversi file di questo tipo)
    • La casella Comando può contenere i comandi seguenti: unzip -o -q apache_tomcat_discovery.zip; chmod +x apache_tomcat_discovery.py; python apache_tomcat_discovery.py

    Per un esempio dello script di ricerca automatica di apache_tomcat_discovery.py, vedere script di esempio per la ricerca automatica.

Ora hai il runbook con attività che scoprono le home di Apache Tomcat.

Script di esempio per la ricerca automatica di un prodotto

Ecco un esempio di script Python per la scoperta di 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("%Y-%d-%m %H:%M:%S")
            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, new_version_exists):
        properties = []
        installed_patches = []
        tomcat_details = self._get_details(path)

        instance = {"product": "Apache 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": []})

        if new_version_exists:
            installed_patches = [
                {
                    "patch_name": tomcat_details['Server number'],
                    "patch_applied_dt": self._get_timestamp(path),
                    "patch_description": tomcat_details['Server number'],
                    "patch_type":"Critical Patch Update",
                    "released_date":self._get_timestamp(path),
                    "severity":"CRITICAL"
                }
            ]

        else:
            installed_patches = [
                {
                    "patch_name": tomcat_details['Server number'],
                    "patch_applied_dt": self._get_timestamp(path),
                    "patch_description": tomcat_details['Server number'],
                    "patch_type": "Critical Patch Update"

                }
            ]

        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()
        new_version_exists = any(['backup' in path for path in tomcat_paths])

        for path in tomcat_paths:
            if not 'backup' in path:
                targets.append(self._instance(path, new_version_exists))

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

JSON di esempio per la ricerca automatica

Di seguito è riportata una rappresentazione JSON di esempio di Apache Tomcat analizzata da Fleet Application Management per la ricerca automatica.

{
  "compartmentId": "<your_root_compartment_ocid>",
  "displayName": "Apache Tomcat Discovery",
  "description": "Runbook to discovery Apache Tomcat Product Homes on an instance",
  "operation": "DISCOVERY",
  "runbookRelevance": "PRODUCT",
  "platform": "Apache Tomcat",
  "isDefault": false,
  "osType": "LINUX",
  "estimatedTime": "1",
  "associations": {
    "groups": [
      {
        "name": "Parallel_resource_group",
        "type": "PARALLEL_RESOURCE_GROUP",
        "properties": {
          "actionOnFailure": "ABORT",
          "condition": null
        }
      }
    ],
    "tasks": [
      {
        "stepName": "Apache_Tomcat_discovery_task",
        "associationType": "TASK",
        "taskRecordDetails": {
          "scope": "LOCAL",
          "executionDetails": {
            "executionType": "SCRIPT",
            "variables": null,
            "content": {
              "sourceType": "OBJECT_STORAGE_BUCKET",
              "namespaceName": "mytenancynamespace",
              "bucketName": "demo_bucket",
              "objectName": "my_apache_tomcat_discovery.zip",
              "checksum": "APLIeko3yTq4CXNWzxcVKvHg=="
            },
            "command": "unzip -o -q my_apache_tomcat_discovery.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": {
          "actionOnFailure": "ABORT",
          "condition": null
        },
        "outputVariableMappings": []
      }
    ],
    "executionWorkflowDetails": {
      "workflow": [
        {
          "groupName": "Parallel_resource_group",
          "type": "PARALLEL_RESOURCE_GROUP",
          "steps": [
            {
              "type": "TASK",
              "stepName": "Apache_Tomcat_discovery_task"
            }
          ]
        }
      ]
    }
  }
}

Esempio di YAML per la ricerca automatica

Ecco un esempio di rappresentazione YAML di Apache Tomcat che Fleet Application Management analizza per la ricerca automatica.

compartmentId: <your_root_compartment_ocid>
displayName: Apache Tomcat Discovery
description: Runbook to discovery Apache Tomcat Product Homes on an instance
operation: DISCOVERY
runbookRelevance: PRODUCT
platform: Apache Tomcat
isDefault: false
osType: LINUX
estimatedTime: "1"
associations:
  groups:
    - name: Parallel_resource_group
      type: PARALLEL_RESOURCE_GROUP
      properties:
        actionOnFailure: ABORT
        condition: null
  tasks:
    - stepName: Apache_Tomcat_discovery_task
      associationType: TASK
      taskRecordDetails:
        scope: LOCAL
        executionDetails:
          executionType: SCRIPT
          variables: null
          content:
            sourceType: OBJECT_STORAGE_BUCKET
            namespaceName: mytenancynamespace
            bucketName: demo_bucket
            objectName: my_apache_tomcat_discovery.zip
            checksum: APLIeko3yTq4CXNWzxcVKvHg==
          command: unzip -o -q my_apache_tomcat_discovery.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:
        actionOnFailure: ABORT
        condition: null
      outputVariableMappings: []
  executionWorkflowDetails:
    workflow:
      - groupName: Parallel_resource_group
        type: PARALLEL_RESOURCE_GROUP
        steps:
          - type: TASK
            stepName: Apache_Tomcat_discovery_task