Alarme mit ServiceNow verwalten

In diesem Thema wird erläutert, wie Sie automatische ServiceNow-Tickets einreichen, wenn Alarme ausgelöst werden.

Wenn in diesem Szenario die CPU-Auslastung den von Ihrem Alarm angegebenen Schwellenwert überschreitet, wird ein ServiceNow-Ticket für Ihren Bereitstellungsanbieter erstellt.

Geben Sie keine privaten Informationen ein, wenn Sie Ihren Cloud-Ressourcen Beschreibungen, Tags oder benutzerdefinierte Namen über die Konsole, die API oder die CLI von Oracle Cloud Infrastructure zuweisen.

Dieses Szenario umfasst das Schreiben einer Funktion in die Datei ServiceNow-Tickets (und das Erstellen eines Secrets zum Speichern Ihrer ServiceNow-Zugangsdaten), das Hinzufügen dieser Funktion und einer optionalen E-Mail als Abonnements zu einem Thema und das Erstellen eines Alarms, der Nachrichten an dieses Thema sendet, wenn der Alarmschwellenwert überschritten wird. Die Nachricht nimmt die Abonnements des Themas auf, die neben der Funktion eine Gruppen-E-Mail-Adresse enthält. Die Funktion wird beim Empfang der Nachricht aufgerufen.

Alles außer der Funktion kann in der Konsole eingerichtet werden. Alternativ können Sie die Oracle Cloud Infrastructure-CLI oder -API verwenden, um die einzelnen Vorgänge selbst auszuführen.

Das folgende Diagramm zeigt den allgemeinen Prozessablauf:



Servicenow-Benachrichtigungen-oracle.zip

Speichern Sie Ihre ServiceNow-Zugangsdaten in einem Secret

Erstellen Sie ein Secret, das Sie später referenzieren, wenn Sie die Funktion erstellen.

Erstellen Sie ein Secret mit der Konsole (Sie können ein Secret auch mit der Befehlszeilenschnittstelle (CLI) oder der Anwendungsprogrammierschnittstelle (API) erstellen).

  1. Klicken Sie im Navigationsmenü auf Identität und Sicherheit und dann auf Vault.
  2. Klicken Sie unter Listengeltungsbereich in der Liste Compartment auf den Namen des Compartments, in dem Sie ein Secret erstellen möchten.
  3. Gehen Sie in der Liste der Vaults im Compartment wie folgt vor:
    • Klicken Sie auf den Vault-Namen, in dem Sie ein Secret erstellen möchten.
    • Erstellen Sie einen neuen Vault für das Secret, und klicken Sie dann auf den Namen des Vaults.
  4. Erstellen Sie das username-Secret:
    1. Klicken Sie auf Secrets und dann auf Secret erstellen.
    2. Wählen Sie im Dialogfeld Secret erstellen ein Compartment in der Liste Erstellen in Compartment aus. Secrets können sich außerhalb des Compartments befinden, in dem der Vault enthalten ist.)
    3. Klicken Sie auf Name, und geben Sie einen Namen zur Identifizierung des Secrets ein. Geben Sie keine vertraulichen Informationen in dieses Feld ein.
      Beispielname: servicenow_username_plain_text
    4. Klicken Sie auf Beschreibung, und geben Sie eine kurze Beschreibung des Secrets ein, um es leichter identifizieren zu können. Geben Sie keine vertraulichen Informationen in dieses Feld ein.
      Beispielbeschreibung: servicenow_username_plain_text
    5. Wählen Sie den Master-Verschlüsselungsschlüssel aus, mit dem Sie die geheimen Inhalte verschlüsseln möchten, während sie in den Vault importiert werden (der Schlüssel muss zu demselben Vault gehören).
    6. Wählen Sie für die Secret-Typvorlage Nur Text aus.
    7. Klicken Sie auf Secret-Inhalt, und geben Sie Ihren ServiceNow-Benutzernamen ein:
      <your-servicenow-username>
    8. Klicken Sie auf Secret erstellen.
    9. Notieren Sie sich die Secret-OCID.

Funktion erstellen

Beginnen Sie mit dem folgenden Beispielcode, um eine Funktion zur Datei von ServiceNow-Tickets zu erstellen, und autorisieren Sie die Funktion dann, auf Ihre ServiceNow-Zugangsdaten in dem Secret zuzugreifen, das mit dem Oracle Cloud Infrastructure Vault-Service erstellt wurde.

Das Codebeispiel enthält die Variablen SNOW_URL, SNOW_USER_ID_SEC und SNOW_USER_PWD_SEC, die in der hypothetischen Funktion verwendet werden. Sie können diese Werte direkt aus der Funktion lesen oder die Werte stattdessen als benutzerdefinierte Konfigurationsparameter übergeben.

#####################################################
# THIS SAMPLE CODE IS FOR DEMO PURPOSES ONLY
#*************************************************
# ******** DO NOT USE IN PRODUCTION *************
# ************************************************
#####################################################
import io
import sys
import oci
import json
import base64
import requests
from fdk import response
SNOW_URL = '<Provide Service Now URL here>'
SNOW_USER_ID_SEC = '<Provide the OCID of OCI Secret for Service Now User ID>'
SNOW_USER_PWD_SEC = '<Provide the OCID of OCI Secret for Service Now User Password>'
OCI_TO_SNOW_SEV_MAP =
{    'CRITICAL'  : '1',    'WARNING'   : '2',    'ERROR'     : '3',    'INFO'      : '4' }
def handler(ctx, data: io.BytesIO = None):
    try:
        funDataStr = data.read().decode('utf-8')
        funDataJSON =  json.loads(funDataStr)
        alarmData = {}
        alarmData['type'] = funDataJSON['type']
        alarmData['metaDataList'] = funDataJSON['alarmMetaData']
        alarmData['title'] = funDataJSON['title']
        alarmData['body'] = funDataJSON['body']
        alarmData['sev'] = OCI_TO_SNOW_SEV_MAP[funDataJSON['severity'].upper()]
        if alarmData['type'].upper() == 'OK_TO_FIRING':
            snowURL = SNOW_URL
            snowUsrIDSec = SNOW_USER_ID_SEC
            snowUsrPwdSec = SNOW_USER_PWD_SEC
            ociResPrncplSigner = oci.auth.signers.get_resource_principals_signer()
            ociSecSvc = oci.secrets.SecretsClient(config={}, signer=ociResPrncplSigner)
            snowUserID = readSecValueFromSecSvc(ociSecSvc, snowUsrIDSec)
            snowPswd = readSecValueFromSecSvc(ociSecSvc, snowUsrPwdSec)
            snowData = getSNOWData(alarmData)
            sendDataToSnow(snowURL, snowUserID, snowPswd, snowData)
    except Exception as e:
        sys.stderr.write("Exception : " + str(e))
        sys.stderr.write("Exception Class : " + str(e._class_))
    return response.Response(ctx, response_data="", headers={"Content-Type": "application/json"})
def sendDataToSnow(snowURL, uid, pwd, snowData):
    try:
{ 
snowHdrs =
      "Content-Type" : "application/json",
counter = 0
for sd in snowData:
"Accept" : "application/json"         }
        snowResp = requests.post(snowURL, auth=(uid, pwd), headers=snowHdrs, data=json.dumps(sd))
except Exception as e:
    sys.stderr.write("Exception : " + str(e))
    sys.stderr.write("Exception Class : " + str(e._class_))
   def getSNOWData(alarmData):
       snowData = []
       if alarmData['type'].upper() == 'OK_TO_FIRING':
           alrmMD = alarmData['metaDataList'][0]
           for d in alrmMD['dimensions']:
               snowDataElem = {}
               snowDataElem['node'] = d['resourceDisplayName']
               snowDataElem['source'] = 'OCI'
               snowDataElem['severity'] = alarmData['sev']
               snowDataElem['description'] = alarmData['body']
               snowDataElem['type'] = alarmData['title']
               snowData.append(snowDataElem)
       return snowData
   def readSecValueFromSecSvc(ociSecSvc, secID):
       secResp = ociSecSvc.get_secret_bundle(secID)
       secContent = secResp.data.secret_bundle_content.content
       secret_content = base64.b64decode(secContent).decode('utf-8')
       return secret_content

Verwenden Sie eine dynamische Gruppe, um Ihrer Funktion das Lesen von Secrets zu ermöglichen. Ihre Funktion muss über diese Berechtigung verfügen, um auf Ihre ServiceNow-Zugangsdaten zuzugreifen, die in den zuvor erstellten Secrets gespeichert sind.

  1. Suchen und notieren Sie die Funktions-OCID im folgenden Format:
    ocid1.fnfunc.oc1.iad.<exampleuniqueID>

    Fügen Sie Ihre Funktion in die relevante dynamische Gruppe ein, indem Sie die folgende Regel angeben:

    resource.id = '<function-ocid>'

    Alternativ können Sie eine dynamische Gruppe erstellen, die alle Funktionen enthält:

    ALL{resource.type=’fnfunc’, resource.compartment.id=’<compartment_OCID>’}
  2. Erteilen Sie der dynamischen Gruppe Zugriff auf Secrets, indem Sie die folgende Policy hinzufügen.
    allow dynamic-group <dynamic-group-name> to read secret-family in tenancy

    Um Ihrer Funktion für den Zugriff auf andere Oracle Cloud Infrastructure-Ressourcen zu autorisieren, wie Compute-Instanzen, nehmen Sie die Funktion in eine dynamische Gruppe auf, und erstellen Sie eine Policy, um der dynamischen Gruppe Zugriff auf diese Ressourcen zu erteilen.

Thema erstellen

Erstellen Sie das Thema, das Sie für die Abonnements und den Alarm verwenden.

Ein Thema ist ein Kommunikationskanal zum Senden von Nachrichten an Abonnements. Jeder Themenname ist innerhalb des Mandanten eindeutig. Sie können das Thema mit der Konsole, der Befehlszeilenschnittstelle (CLI) oder der Anwendungsprogrammierschnittstelle (API) erstellen.

Sie müssen die Funktion bereitstellen, bevor Sie sie mit einem Thema verwenden können.

  1. So erstellen Sie das Thema mit der Konsole:
    1. Öffnen Sie das Navigationsmenü, und klicken Sie auf Entwicklerservices. Klicken Sie unter "Anwendungsintegration" auf Benachrichtigungen.
    2. Klicken Sie oben in der Themenliste auf Thema erstellen.
    3. Konfigurieren Sie das Thema im Dialogfeld Thema erstellen:
      • Name: Geben Sie einen Anzeigenamen für das Thema an. Dieser muss im gesamten Mandanten eindeutig sein. Bei der Validierung wird die Groß- und Kleinschreibung berücksichtigt. Geben Sie dabei keine vertraulichen Informationen ein.
      • Beschreibung: Geben Sie optional eine Beschreibung für das Thema ein. Geben Sie dabei keine vertraulichen Informationen ein.
    4. Klicken Sie auf Erstellen.
  2. Um das Thema mit der CLI zu erstellen, öffnen Sie eine Eingabeaufforderung, und geben Sie einen Befehl ähnlich dem folgenden ein:
    oci ons topic create
    --name "My Topic"
    --compartment-id "<compartment-ocid>"
  3. Um das Thema mit der API zu erstellen, verwenden Sie Vorgänge wie die folgenden:
    POST /20181201/topics
    Host: notification.us-phoenix-1.oraclecloud.com
    <authorization and other headers>
    {
      "name": "My Topic",
      "compartmentId": "<compartment_OCID>"
    }
    

Abonnements erstellen

Erstellen Sie das Abonnement für das Thema.

Ein Abonnement ist ein Endpunkt für ein Thema. Veröffentlichte Nachrichten werden an jedes Abonnement für ein Thema gesendet.

Sie müssen die Funktion bereitstellen, bevor Sie sie mit einem Abonnement verwenden können. Sie benötigen die Berechtigung FN_INVOCATION, damit die Funktion als Abonnement zu einem Thema hinzugefügt werden kann.

  1. So erstellen Sie das Funktionsabonnement mit der Konsole:
    1. Öffnen Sie das Navigationsmenü, und klicken Sie auf Entwicklerservices. Klicken Sie unter "Anwendungsintegration" auf Benachrichtigungen. Klicken Sie auf den Namen des Themas, dem Sie das Abonnement hinzufügen möchten.
    2. Klicken Sie auf der Themendetailseite auf Abonnement erstellen.
    3. Konfigurieren Sie im Dialogfeld "Abonnement erstellen" Ihr Funktionsabonnement. Für Funktionsabonnements ist keine Bestätigung erforderlich.
      • Klicken Sie für das Abonnementprotokoll auf Funktion.
      • Klicken Sie für das Funktions-Compartment auf das Compartment, das Ihre Funktion enthält.
      • Klicken Sie für die Funktionsanwendung auf die Anwendung mit Ihrer Funktion.
      • Klicken Sie unter "Funktion" auf Ihre Funktion.
    4. Klicken Sie auf Erstellen.
  2. So erstellen Sie ein optionales E-Mail-Abonnement mit der Konsole:
    1. Öffnen Sie das Navigationsmenü, und klicken Sie auf Entwicklerservices. Klicken Sie unter "Anwendungsintegration" auf Benachrichtigungen. Klicken Sie auf den Namen des Themas, dem Sie das Abonnement hinzufügen möchten.
    2. Klicken Sie auf der Themendetailseite auf Abonnement erstellen.
    3. Konfigurieren Sie im Dialogfeld "Abonnement erstellen" Ihr E-Mail-Abonnement.
      • Klicken Sie für das Abonnementprotokoll auf E-Mail.
      • Geben Sie eine E-Mail-Adresse ein.
    4. Klicken Sie auf Erstellen.
      Das E-Mail-Abonnement wird erstellt, und eine Abonnementbestätigungs-URL wird an die angegebene E-Mail-Adresse gesendet. Das Abonnement bleibt bis zu seiner Bestätigung im Status Ausstehend. Um Ihr neues E-Mail-Abonnement zu bestätigen, öffnen Sie die E-Mail, und klicken Sie auf die Bestätigungs-URL.
  3. So erstellen Sie ein Abonnement mit der CLI:
    1. Um ein Funktionsabonnement zu erstellen, öffnen Sie eine Eingabeaufforderung, und geben Sie einen Befehl wie den folgenden ein:
      oci ons subscription create
      --compartment-id "<compartment-ocid>"
      --topic-id "<topic-ocid>" 
      --protocol "ORACLE_FUNCTIONS"
      --subscription-endpoint "<function-ocid>"
    2. Um ein E-Mail-Abonnement zu erstellen, öffnen Sie eine Eingabeaufforderung, und geben Sie einen Befehl ähnlich dem folgenden ein:
      oci ons subscription create
      --compartment-id "<compartment-ocid>"
      --topic-id "<topic-ocid>" 
      --protocol "EMAIL"
      --subscription-endpoint "team@example.com"
  4. So erstellen Sie ein Abonnement mit der API:
    1. Um ein Funktionsabonnement mit der API zu erstellen, verwenden Sie Vorgänge wie die Folgenden:
      POST /20181201/subscriptions
      Host: notification.us-phoenix-1.oraclecloud.com
      <authorization and other headers>
      {
        "topicId": "<topic_OCID>",
        "compartmentId": "<compartment_OCID>",
        "protocol": "ORACLE_FUNCTIONS",
        "endpoint": "<function_OCID>"
      } 
    2. Um ein E-Mail-Abonnement mit der API zu erstellen, verwenden Sie Vorgänge wie die Folgenden:
      POST /20181201/subscriptions
      Host: notification.us-phoenix-1.oraclecloud.com
      <authorization and other headers>
      {
        "topicId": "<topic_OCID>",
        "compartmentId": "<compartment_OCID>",  
        "protocol": "EMAIL",
        "endpoint": "team@example.com"
      
      } 

Alarm erstellen

Erstellen Sie den Alarm, der eine Nachricht an das Thema sendet, wenn der Alarmschwellenwert überschritten wird. Benachrichtigungen übermitteln die Nachricht dann an aktive Abonnements in diesem Thema.

  1. So erstellen Sie den Alarm über die Konsole:
    1. Öffnen Sie das Navigationsmenü, und klicken Sie auf Observability and Management. Klicken Sie unter Monitoring auf Alarmdefinitionen.
    2. Klicken Sie auf Alarm erstellen.
    3. Legen Sie auf der Seite Alarm erstellen unter Alarm definieren den gewünschten Schwellenwert fest:
      Unter Metrik-Beschreibung:
      • Compartment: Wählen Sie das Compartment aus, das eine relevante Compute-Instanz enthält.
      • Metrik-Namespace: oci_computeagent
      • Metrikname: CpuUtilization
      • Intervall: 1m
      • Statistik: Anzahl
      Unter Triggerregel:
      • Operator: größer als
      • Wert: 90
      • Triggerverzögerung in Minuten: 1
    4. Um Alarmbenachrichtigungen zu definieren, fügen Sie das zuvor erstellte Thema als Ziel hinzu.
      Unter Ziel:
      • Zielservice: Benachrichtigungen
      • Compartment: (Wählen Sie das Compartment aus, das Ihr Thema enthält)
      • Thema: (Ihr Thema auswählen)
    5. Klicken Sie auf Alarm speichern.
  2. Um den Alarm mit der CLI zu erstellen, öffnen Sie eine Eingabeaufforderung, und geben Sie einen Befehl ähnlich dem folgenden ein:
    oci monitoring alarm create
    --display-name "My Alarm"
    --compartment-id "<compartment-ocid>" 
    --metric-compartment-id "<compartment-ocid>" 
    --namespace "oci_computeagent" 
    --query-text "CPUUtilization[1m].count() > 90"
    --severity "CRITICAL"
    --destinations "<topic-ocid>"
    --is-enabled true
  3. Um den Alarm mit der API zu erstellen, verwenden Sie Vorgänge wie die folgenden:
    POST /20180401/alarms
    Host: telemetry.us-phoenix-1.oraclecloud.com
    <authorization and other headers>
    {
      "displayName": "My Alarm",
      "compartmentId": "<compartment_OCID>",
      "metricCompartmentId": "<compartment_OCID>",
      "namespace": "oci_computeagent",
      "query": "MemoryUtilization[1m].max() > 90",
      "severity": "CRITICAL",
      "destinations":
        [
          "<topic_OCID>"
        ],
      "isEnabled": true
    }