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.

Ersteinrichtung

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

Erstellen Sie einen ServiceNow OAuth Anwendungsclient

Connect Ihren ServiceNow OAuth Kunden mit dem AWS DevOps Agenten

Konfigurieren Sie Ihre ServiceNow Geschäftsregel

Sobald Sie die Konnektivität 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 sich dafür entschieden haben, Ihre ServiceNow Verbindung auf der Seite Capability Providers zu registrieren, müssen Sie jetzt zu dem DevOps Agentenbereich navigieren, in dem Sie ServiceNow Incident-Tickets untersuchen möchten, Capabilities → Communications auswählen und dann die ServiceNow Instance registrieren, die Sie auf der Capability Provider-Seite registriert haben. 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 im konfigurierten DevOps Agent Space eine Incident-Response-Untersuchung aus. Sie können dies testen, indem Sie einen neuen Incident erstellen ServiceNow und das Anrufer-Feld des Incidents auf „Problem Administrator“ setzen.

ServiceNow Ticketaktualisierungen

Während aller Untersuchungen zur Reaktion auf Vorfälle aktualisiert DevOps Ihr Mitarbeiter die wichtigsten Ergebnisse, Ursachenanalysen und Pläne zur Schadensbegrenzung in das ursprüngliche Ticket. Die Ergebnisse des Sachbearbeiters werden in den Kommentaren zu einem Vorfall veröffentlicht. Derzeit veröffentlichen wir nur Agentendatensätze vom Typfinding,, cause investigation_summarymitigation_summary, und Aktualisierungen zum Ermittlungsstatus (z. B.AWS DevOps Agent started/finished its investigation).

Beispiele für die Weiterleitung und Orchestrierung von Tickets

Szenario: Filtern, welche Incidents an einen DevOps Agent Space gesendet werden

Dies ist ein einfaches Szenario, für das jedoch einige Konfigurationen erforderlich sind ServiceNow , um ein Feld zur Nachverfolgung der Vorfallquelle ServiceNow zu erstellen. Für dieses Beispiel erstellen Sie mit dem SNOW Form Builder ein neues Quellfeld (u_source). Auf diese Weise können Sie die Quelle des Vorfalls nachverfolgen und anhand dieser Informationen Anfragen von einer bestimmten Quelle an einen DevOps Agent Space weiterleiten. Die Weiterleitung erfolgt, indem eine Service Now-Geschäftsregel erstellt wird und auf der Registerkarte „Wann ausgeführt“ die Einstellungen „Wann“ und „Filterbedingungen“ ausgelöst werden. In diesem Beispiel sind die Filterbedingungen wie folgt festgelegt:

Szenario: Weiterleitung von Vorfällen an mehrere DevOps Agent Spaces

Dieses Beispiel zeigt, wie eine Untersuchung in DevOps Agentenbereich B ausgelöst wird, wenn die Dringlichkeit1, Kategorie oder Service ist SoftwareAWS, und eine Untersuchung in DevOps Agentenbereich A ausgelöst wirdAWS, wenn der Service aktiviert ist und die Quelle istDynatrace.

Dieses Szenario kann auf zwei Arten erreicht werden. Das Webhook-Skript selbst kann aktualisiert werden, um diese Geschäftslogik einzubeziehen. In diesem Szenario werden wir zeigen, 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 Incident erstellen, der der angegebenen Bedingung entspricht, löst er entweder eine Untersuchung in DevOps Agent Space A oder DevOps Agent Space B aus, sodass Sie eine genaue Kontrolle über die Weiterleitung von Vorfällen haben.