Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Connessione ServiceNow

Questo tutorial illustra come collegare un' ServiceNow istanza ad AWS DevOps Agent per consentirgli di avviare automaticamente le indagini sulla risposta agli incidenti quando viene creato un ticket e di pubblicarne i risultati principali nel ticket di origine. Contiene anche esempi su come configurare l' ServiceNow istanza per inviare solo ticket specifici a un DevOps Agent Space e su come orchestrare il routing dei ticket su più Agent Spaces. DevOps

Configurazione iniziale

Il primo passaggio consiste nella creazione di ServiceNow un'applicazione client OAuth da utilizzare per accedere ServiceNow all'istanza. AWS DevOps

Crea un client applicativo ServiceNow OAuth

Connect il tuo ServiceNow client OAuth a AWS DevOps Agente

Configura la tua regola aziendale ServiceNow

Una volta stabilita la connettività, dovrai configurare una regola aziendale per ServiceNow inviare i ticket al/i tuo/i DevOps Agent Space.

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

Se hai scelto di registrare la ServiceNow connessione dalla pagina Provider di funzionalità, ora devi accedere all' DevOps Agent Space in cui desideri esaminare i ticket relativi agli ServiceNow incidenti, selezionare Capacità → Comunicazioni e quindi registrare l' ServiceNow istanza registrata nella pagina Provider di capacità. Ora, tutto dovrebbe essere configurato e tutti gli incidenti in cui il chiamante è impostato su «Problem Administrator» (per simulare le autorizzazioni concesse al client AWS DevOps OAuth) attiveranno un'indagine sulla risposta agli incidenti nello spazio DevOps agente configurato. Puoi verificarlo creando un nuovo incidente ServiceNow e impostando il campo Caller dell'incidente come «Problem Administrator».

ServiceNow aggiornamenti dei ticket

Durante tutte le indagini relative alla risposta agli incidenti innescati, il tuo DevOps agente fornirà aggiornamenti sui risultati principali, sulle analisi delle cause principali e sui piani di mitigazione nel ticket di origine. I risultati dell'agente vengono pubblicati nei commenti relativi a un incidente e al momento pubblicheremo solo i dati relativi al tipofinding, cause investigation_summarymitigation_summary, e agli aggiornamenti sullo stato delle indagini (ad esempio). AWS DevOps Agent started/finished its investigation

Esempi di routing e orchestrazione dei ticket

Scenario: filtraggio degli incidenti inviati a un Agent Space DevOps

Questo è uno scenario semplice ma richiede una configurazione ServiceNow per creare un campo in cui ServiceNow tracciare l'origine dell'incidente. Ai fini di questo esempio, crea un nuovo campo Source (u_source) utilizzando il generatore di moduli SNOW. Ciò consentirà di tracciare l'origine dell'incidente e di utilizzarla per indirizzare le richieste da una particolare fonte a un DevOps Agent Space. Il routing viene eseguito creando una regola aziendale di Service Now e nella scheda Quando eseguire impostando i trigger «When» e «Filter Conditions». In questo esempio le condizioni di filtro sono impostate come segue:

Scenario: instradamento degli incidenti su più Agent Spaces DevOps

Questo esempio mostra come attivare un'indagine in DevOps Agent Space B quando l'urgenza è1, la categoria è Software o il servizio è AWS e avviare un'indagine in DevOps Agent Space A quando il servizio è e l'origine AWS sì. Dynatrace

Questo scenario può essere realizzato in due modi. Lo script webhook stesso può essere aggiornato per includere questa logica aziendale. In questo scenario mostreremo come realizzarlo con una ServiceNow Business Rule, per la trasparenza e la semplificazione del debug. Il routing viene eseguito creando due regole aziendali di Service Now.

Ora, quando crei un nuovo Incidente che corrisponde alla condizione specificata, verrà avviata un'indagine su DevOps Agent Space A o DevOps Agent Space B, fornendoti un controllo granulare sul routing degli incidenti.