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 DevOps agent et comment orchestrer le routage des tickets sur plusieurs espaces DevOps agent.

Configuration initiale

La première étape consiste à créer ServiceNow un client d' OAuth application qui AWS DevOps peut être utilisé pour accéder à votre ServiceNow instance.

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

Connectez votre ServiceNow OAuth client à l' AWS DevOps agent

Configurez votre règle ServiceNow métier

Une fois que vous avez établi la connectivité, vous devez configurer une règle métier ServiceNow pour envoyer des tickets à vos espaces d' DevOps agents.

(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 choisi d'enregistrer votre ServiceNow connexion depuis la page des fournisseurs de capacités, vous devez maintenant accéder à l'espace des DevOps agents dans lequel vous souhaitez examiner les tickets d' ServiceNow incident, sélectionner Capabilities → Communications, puis enregistrer l' ServiceNow instance que vous avez enregistrée sur la page Capability Providers. À présent, tout doit être configuré, et tous les incidents pour lesquels l'appelant est défini sur « Administrateur des problèmes » (pour imiter les autorisations que vous avez accordées au AWS DevOps OAuth client) déclencheront une enquête sur la réponse à l'incident dans l'espace DevOps agent configuré. Vous pouvez le tester en créant un nouvel incident ServiceNow et en définissant le champ Caller de l'incident comme « Administrateur des problèmes ».

ServiceNow mises à jour des tickets

Au cours de toutes les enquêtes de réponse aux incidents déclenchées, 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 conclusions de l'agent sont publiées dans les commentaires d'un incident, et nous ne publions actuellement que les dossiers des agents contenant le typefinding,, cause investigation_summarymitigation_summary, et les mises à jour de l'état de l'enquête (par exempleAWS DevOps Agent started/finished its investigation).

Exemples de routage et d'orchestration des tickets

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

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. Dans le cadre 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 de Service Now et en définissant dans l'onglet Quand exécuter les déclencheurs 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 d' DevOps 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 existe et que la source l'estDynatrace. AWS

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 commerciales de Service Now.

Désormais, lorsque vous créez un nouvel incident répondant à la condition spécifiée, il 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.