Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Verbindung herstellen ServiceNow

In diesem Tutorial erfahren Sie, wie Sie eine ServiceNow Instanz mit dem AWS DevOps Agenten verbinden, damit dieser bei der Erstellung eines Tickets automatisch Untersuchungen zur Reaktion auf Vorfälle einleiten und die wichtigsten Ergebnisse im ursprünglichen Ticket veröffentlichen kann. Es enthält auch Beispiele dafür, wie Sie Ihre ServiceNow Instanz so konfigurieren, dass nur bestimmte Tickets an einen DevOps Agent Space gesendet werden, und wie Sie das Ticket-Routing über mehrere DevOps Agent Spaces hinweg orchestrieren.

Erste Einrichtung

Der erste Schritt besteht darin, ServiceNow einen OAuth-Anwendungsclient zu erstellen, mit dem Sie auf Ihre ServiceNow Instanz zugreifen AWS DevOps können.

Erstellen Sie einen ServiceNow OAuth-Anwendungsclient

Verbinden Sie Ihren ServiceNow OAuth-Client mit AWS DevOps Agent

Jede Registrierung stellt eine Verbindung zu einer Instanz her. ServiceNow Um weitere Instanzen zu verbinden, wiederholen Sie diesen Vorgang für jede Instanz.

Konfigurieren Sie Ihre Geschäftsregel ServiceNow

Sobald Sie die Verbindung hergestellt haben, müssen Sie eine Geschäftsregel konfigurieren ServiceNow , um Tickets an Ihre DevOps Agentenbereiche zu senden.

(function executeRule(current, previous /*null when async*/ ) {

    var WEBHOOK_CONFIG = {
        webhookSecret: GlideStringUtil.base64Encode('<<< INSERT WEBHOOK SECRET HERE >>>'),
        webhookUrl: '<<< INSERT WEBHOOK URL HERE >>>'
    };

    function generateHMACSignature(payloadString, secret) {
        try {
            var mac = new GlideCertificateEncryption();
            var signature = mac.generateMac(secret, "HmacSHA256", payloadString);
            return signature;
        } catch (e) {
            gs.error('HMAC generation failed: ' + e);
            return null;
        }
    }

    function callWebhook(payload, config) {
        try {
            var timestamp = new Date().toISOString();
            var payloadString = JSON.stringify(payload);
            var payloadWithTimestamp =`${timestamp}:${payloadString}`;

            var signature = generateHMACSignature(payloadWithTimestamp, config.webhookSecret);

            if (!signature) {
                gs.error('Failed to generate signature');
                return false;
            }

            gs.info('Generated signature: ' + signature);

            var request = new sn_ws.RESTMessageV2();
            request.setEndpoint(config.webhookUrl);
            request.setHttpMethod('POST');

            request.setRequestHeader('Content-Type', 'application/json');
            request.setRequestHeader('x-amzn-event-signature', signature);
            request.setRequestHeader('x-amzn-event-timestamp', timestamp);

            request.setRequestBody(payloadString);

            var response = request.execute();
            var httpStatus = response.getStatusCode();
            var responseBody = response.getBody();

            if (httpStatus >= 200 && httpStatus < 300) {
                gs.info('Webhook sent successfully. Status: ' + httpStatus);
                return true;
            } else {
                gs.error('Webhook failed. Status: ' + httpStatus + ', Response: ' + responseBody);
                return false;
            }

        } catch (ex) {
            gs.error('Error sending webhook: ' + ex.getMessage());
            return false;
        }
    }

    function createReference(field) {
        if (!field || field.nil()) {
            return null;
        }

        return {
            link: field.getLink(true),
            value: field.toString()
        };
    }

    function getStringValue(field) {
        if (!field || field.nil()) {
            return null;
        }
        return field.toString();
    }

    function getIntValue(field) {
        if (!field || field.nil()) {
            return null;
        }
        var val = parseInt(field.toString());
        return isNaN(val) ? null : val;
    }

    var eventType = (current.operation() == 'insert') ? "create" : "update";

    var incidentEvent = {
        eventType: eventType.toString(),
        sysId: current.sys_id.toString(),
        priority: getStringValue(current.priority),
        impact: getStringValue(current.impact),
        active: getStringValue(current.active),
        urgency: getStringValue(current.urgency),
        description: getStringValue(current.description),
        shortDescription: getStringValue(current.short_description),
        parent: getStringValue(current.parent),
        incidentState: getStringValue(current.incident_state),
        severity: getStringValue(current.severity),
        problem: createReference(current.problem),
        additionalContext: {}
    };

    incidentEvent.additionalContext = {
        number: current.number.toString(),
        opened_at: getStringValue(current.opened_at),
        opened_by: current.opened_by.nil() ? null : current.opened_by.getDisplayValue(),
        assigned_to: current.assigned_to.nil() ? null : current.assigned_to.getDisplayValue(),
        category: getStringValue(current.category),
        subcategory: getStringValue(current.subcategory),
        knowledge: getStringValue(current.knowledge),
        made_sla: getStringValue(current.made_sla),
        major_incident: getStringValue(current.major_incident)
    };

    for (var key in incidentEvent.additionalContext) {
        if (incidentEvent.additionalContext[key] === null) {
            delete incidentEvent.additionalContext[key];
        }
    }

    gs.info(JSON.stringify(incidentEvent, null, 2)); // Pretty print for logging only

    if (WEBHOOK_CONFIG.webhookUrl && WEBHOOK_CONFIG.webhookSecret) {
        callWebhook(incidentEvent, WEBHOOK_CONFIG);
    } else {
        gs.info('Webhook not configured.');
    }

})(current, previous);

Wenn Sie Ihre ServiceNow Verbindung auf der Seite „Capability Providers“ registriert haben, navigieren Sie zum DevOps Agentenbereich, in dem Sie Incident-Tickets untersuchen ServiceNow möchten. Wählen Sie Capabilities, dann Communications und dann die ServiceNow Instance aus, die Sie auf der Seite Capability Providers registriert haben. Ein einzelner DevOps Agent Space kann mehr als eine ServiceNow Registrierung verwenden. Um eine weitere Instanz hinzuzufügen, wiederholen Sie diesen Schritt. Jetzt sollte alles eingerichtet sein, und alle Vorfälle, bei denen der Anrufer auf „Problem Administrator“ gesetzt ist (um die Berechtigungen nachzuahmen, die Sie dem AWS DevOps OAuth-Client erteilt haben), lösen eine Untersuchung zur Reaktion auf den Vorfall im konfigurierten Agentenbereich aus. DevOps Sie können dies testen, indem Sie einen neuen Vorfall erstellen ServiceNow und das Anruferfeld des Vorfalls auf „Problemadministrator“ setzen.

ServiceNow Aktualisierungen des Tickets

Bei allen Untersuchungen zur Reaktion auf einen Vorfall informiert Ihr DevOps Agent über die wichtigsten Ergebnisse, Ursachenanalysen und Pläne zur Schadensbegrenzung in das ursprüngliche Ticket. Die Ergebnisse des Agenten werden in den Kommentaren zu einem Vorfall veröffentlicht, und wir veröffentlichen derzeit nur Agentenaufzeichnungen mit Informationen zum Typfinding, cause investigation_summarymitigation_summary, und zum Ermittlungsstatus (z. B.AWS DevOps Agent started/finished its investigation).

Beispiele für das Routing und die Orchestrierung von Tickets

Szenario: Filtern, welche Vorfälle an einen DevOps Agentenbereich gesendet werden

Dies ist ein einfaches Szenario, erfordert jedoch eine gewisse Konfiguration ServiceNow , um ein Feld zur Verfolgung der Incident-Quelle ServiceNow zu erstellen. Erstellen Sie für dieses Beispiel mit dem SNOW Form Builder ein neues Quellfeld (u_source). Auf diese Weise können Sie die Incident-Quelle verfolgen und sie verwenden, um Anfragen von einer bestimmten Quelle an einen DevOps Agent Space weiterzuleiten. Das Routing erfolgt, indem eine Service Now-Geschäftsregel erstellt wird und auf der Registerkarte „Wann soll ausgeführt werden“ die Einstellungen „Wann“ ausgelöst und „Bedingungen filtern“ ausgewählt werden. In diesem Beispiel werden die Filterbedingungen wie folgt festgelegt:

Szenario: Vorfälle werden über mehrere DevOps Agentenbereiche weitergeleitet

Dieses Beispiel zeigt, wie eine Untersuchung in DevOps Agent Space B ausgelöst wird, wenn die Dringlichkeit1, Kategorie oder Service istAWS, und eine Untersuchung in DevOps Agent Space A ausgelöst wirdAWS, wenn der Service und die Quelle istDynatrace. Software

Dieses Szenario kann auf zwei Arten erreicht werden. Das Webhook-Skript selbst kann aktualisiert werden, um diese Geschäftslogik einzubeziehen. In diesem Szenario zeigen wir, wie dies mit einer ServiceNow Geschäftsregel erreicht werden kann, um Transparenz zu gewährleisten und das Debuggen zu vereinfachen. Das Routing erfolgt durch die Erstellung von zwei Service Now-Geschäftsregeln.

Wenn Sie nun einen neuen Vorfall erstellen, der die angegebene Bedingung erfüllt, wird entweder eine Untersuchung in DevOps Agentenbereich A oder DevOps Agentenbereich B ausgelöst, sodass Sie die Weiterleitung des Vorfalls genau steuern können.