Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Connecter ServiceNow

Ce didacticiel explique comment connecter une ServiceNow instance à l' AWS DevOps Agent pour lui permettre de lancer automatiquement des enquêtes de réponse aux incidents lorsqu'un ticket est créé et de publier ses principales conclusions dans le ticket d'origine. Il contient également des exemples expliquant comment configurer votre ServiceNow instance pour envoyer uniquement des tickets spécifiques à un espace d' DevOps agent et comment orchestrer le routage des tickets sur plusieurs espaces d' DevOps agent.

Configuration initiale

La première étape consiste à créer ServiceNow un client d'application OAuth que AWS DevOps vous pouvez utiliser pour accéder à votre ServiceNow instance.

Création d'un client d' ServiceNow application OAuth

Connectez votre client ServiceNow OAuth à AWS DevOps Agent

Chaque enregistrement se connecte à une ServiceNow instance. Pour connecter des instances supplémentaires, répétez cette procédure pour chacune d'entre elles.

Configurez votre règle de ServiceNow gestion

Une fois la connectivité établie, vous devrez configurer une règle de gestion ServiceNow pour envoyer des tickets à vos espaces d' DevOps agent.

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

Si vous avez enregistré votre ServiceNow connexion depuis la page Capability Providers, accédez à l'espace DevOps agent dans lequel vous souhaitez examiner les tickets d' ServiceNow incident. Choisissez Capabilities, puis Communications, puis choisissez l' ServiceNow instance que vous avez enregistrée sur la page Capability Providers. Un seul espace d' DevOps agent peut utiliser plusieurs ServiceNow enregistrements. Pour ajouter une autre instance, répétez cette étape. Maintenant, tout doit être configuré, et tous les incidents où l'appelant est configuré sur « Administrateur des problèmes » (pour imiter les autorisations que vous avez accordées au client AWS DevOps OAuth) déclencheront une enquête de réponse aux incidents dans l'espace agent configuré. DevOps Vous pouvez tester cela en créant un nouvel incident ServiceNow et en définissant le champ Caller de l'incident comme « Administrateur du problème ».

ServiceNow mises à jour des billets

Au cours de toutes les enquêtes de réponse aux incidents déclenchés, votre DevOps agent fournira des mises à jour de ses principales conclusions, des analyses des causes profondes et des plans d'atténuation dans le ticket d'origine. Les résultats des agents sont publiés dans les commentaires d'un incident, et nous ne publierons actuellement que les dossiers des agents de typefinding,, cause investigation_summarymitigation_summary, et les mises à jour sur l'état de l'enquête (par exempleAWS DevOps Agent started/finished its investigation).

Exemples de routage et d'orchestration de tickets

Scénario : Filtrer les incidents envoyés à un espace d' DevOps agent

Il s'agit d'un scénario simple mais nécessite une certaine configuration ServiceNow pour créer un champ permettant de ServiceNow suivre la source de l'incident. Pour les besoins de cet exemple, créez un nouveau champ Source (u_source) à l'aide du générateur de formulaires SNOW. Cela permettra de suivre la source de l'incident et de l'utiliser pour acheminer les demandes d'une source particulière vers un espace d' DevOps agent. Le routage est effectué en créant une règle métier Service Now et en définissant les déclencheurs « Quand » et les « Conditions de filtrage » dans l'onglet Quand exécuter. Dans cet exemple, les conditions du filtre sont définies comme suit :

Scénario : routage des incidents sur plusieurs espaces DevOps d'agents

Cet exemple montre comment déclencher une enquête dans l'espace DevOps agent B lorsque l'urgence est1, la catégorie est Software ou le service estAWS, et déclencher une enquête dans l'espace DevOps agent A lorsque le service est AWS et la source estDynatrace.

Ce scénario peut être réalisé de deux manières. Le script Webhook lui-même peut être mis à jour pour inclure cette logique métier. Dans ce scénario, nous allons montrer comment y parvenir à l'aide d'une règle ServiceNow métier, pour plus de transparence et pour simplifier le débogage. Le routage est effectué en créant deux règles métier de Service Now.

Désormais, lorsque vous créez un nouvel incident qui correspond à la condition spécifiée, cela déclenche une enquête sur l'espace DevOps agent A ou sur l'espace DevOps agent B, ce qui vous permet de contrôler avec précision le routage des incidents.