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
<a name="connecting-to-ticketing-and-chat-connecting-servicenow"></a>

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
<a name="initial-setup"></a>

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

### Crea un client ServiceNow OAuth applicativo
<a name="create-a-servicenow-oauth-application-client"></a>

1. Abilita la proprietà del sistema di credenziali del client dell'istanza

   1. Cerca `sys_properties.list` nella casella di ricerca del filtro e poi premi invio (non mostrerà l'opzione ma premere invio funziona)

   1. Scegli Nuovo

   1. Aggiungi il nome as `glide.oauth.inbound.client.credential.grant_type.enabled` e il valore a true con type as true \$1 false

![\[alt text not found\]](http://docs.aws.amazon.com/it_it/devopsagent/latest/userguide/images/09ed6d5ff911.png)


1. Vai a Sistema OAuth > Registro delle applicazioni dalla casella di ricerca del filtro

1. Scegli «Nuova» > «Nuova esperienza di integrazione in entrata» > «Nuova integrazione» > «OAuth - Concessione delle credenziali del cliente»

1. Scegli un nome e imposta l'utente dell' OAuth applicazione su «Problem Administrator», fai clic su «Salva»

![\[alt text not found\]](http://docs.aws.amazon.com/it_it/devopsagent/latest/userguide/images/aeff4c127f7c.png)


### Connect il ServiceNow OAuth client all' AWS DevOps agente
<a name="connect-your-servicenow-oauth-client-to-aws-devops-agent"></a>

1. Puoi iniziare questo processo in due punti. Innanzitutto, accedendo alla pagina **Capability Provider** e trovandola nella **ServiceNow**sezione **Comunicazione**, quindi facendo clic su **Registra**. In alternativa, puoi selezionare qualsiasi DevOps Agent Space che potresti aver creato e accedere a Capacità → Comunicazioni → Aggiungi → ServiceNow e fare clic su Registra.

1. Successivamente, autorizza l' DevOps agente ad accedere alla tua ServiceNow istanza utilizzando il client OAuth applicativo che hai appena creato.

![\[alt text not found\]](http://docs.aws.amazon.com/it_it/devopsagent/latest/userguide/images/3db5a9aafc5f.png)

+ Segui i passaggi successivi e salva le informazioni risultanti sul webhook 

**Importante**  
Queste informazioni non verranno più visualizzate

![\[alt text not found\]](http://docs.aws.amazon.com/it_it/devopsagent/latest/userguide/images/80d0a319f87e.png)


### Configura la tua regola ServiceNow aziendale
<a name="configure-your-servicenow-business-rule"></a>

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

1. Vai su Activity Subscriptions → Administration → Business Rules e fai clic su Nuovo.

1. Imposta il campo «Tabella» su «Incidente [incidente]», seleziona la casella «Avanzate» e imposta la regola in modo che venga eseguita dopo l'inserimento, l'aggiornamento e l'eliminazione.

![\[alt text not found\]](http://docs.aws.amazon.com/it_it/devopsagent/latest/userguide/images/6f2a7370e2c0.png)


1. Vai alla scheda «Avanzate» e aggiungi il seguente script webhook, inserendo il segreto e l'URL del webhook dove indicato, e fai clic su Invia.

```
(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 che hai dato al AWS DevOps OAuth client) avvieranno un'indagine sulla risposta agli incidenti nell'Agent Space configurato. DevOps Puoi verificarlo creando un nuovo incidente in ServiceNow e impostando il campo Caller dell'incidente come «Problem Administrator». 

![\[alt text not found\]](http://docs.aws.amazon.com/it_it/devopsagent/latest/userguide/images/4c7d24a85f88.png)


### ServiceNow aggiornamenti dei ticket
<a name="servicenow-ticket-updates"></a>

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 tipo`finding`, `cause` `investigation_summary``mitigation_summary`, e agli aggiornamenti sullo stato delle indagini (ad esempio). `AWS DevOps Agent started/finished its investigation`

## Esempi di routing e orchestrazione dei ticket
<a name="ticket-routing-and-orchestration-examples"></a>

### Scenario: filtraggio degli incidenti inviati a un Agent Space DevOps
<a name="scenario-filtering-which-incidents-are-sent-to-a-devops-agent-space"></a>

Questo è uno scenario semplice ma richiede una configurazione ServiceNow per creare un campo per ServiceNow tracciare l'origine dell'incidente. Ai fini di questo esempio, crea un nuovo campo Source (u\$1source) 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: 

![\[alt text not found\]](http://docs.aws.amazon.com/it_it/devopsagent/latest/userguide/images/fac7a186beee.png)


### Scenario: instradamento degli incidenti su più DevOps spazi di agenti
<a name="scenario-routing-incidents-across-multiple-devops-agent-spaces"></a>

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.
+ Crea una regola aziendale in ServiceNow DevOps Agent Space A e crea una condizione utilizzando il generatore di condizioni per inviare solo gli eventi in base alla nostra condizione specificata.

![\[alt text not found\]](http://docs.aws.amazon.com/it_it/devopsagent/latest/userguide/images/bca2f3928bf0.png)

+ Quindi, crea un'altra regola aziendale in AgentSpace B ServiceNow per la quale la regola aziendale verrà attivata solo quando Service è AWS e l'origine è Dynatrace.

![\[alt text not found\]](http://docs.aws.amazon.com/it_it/devopsagent/latest/userguide/images/bc29e4db1a76.png)


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.