As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Conectando ServiceNow
<a name="connecting-to-ticketing-and-chat-connecting-servicenow"></a>

Este tutorial explica como conectar uma ServiceNow instância ao AWS DevOps Agent para permitir que ela inicie automaticamente investigações de resposta a incidentes quando um ticket é criado e publique suas principais descobertas no ticket de origem. Ele também contém exemplos de como configurar sua ServiceNow instância para enviar somente tickets específicos para um DevOps Agent Space e como orquestrar o roteamento de tickets em vários DevOps Agent Spaces.

## Configuração inicial
<a name="initial-setup"></a>

A primeira etapa é criar ServiceNow um cliente de OAuth aplicativo que AWS DevOps possa ser usado para acessar sua ServiceNow instância.

### Crie um cliente ServiceNow OAuth de aplicativo
<a name="create-a-servicenow-oauth-application-client"></a>

1. Ative a propriedade do sistema de credenciais do cliente da sua instância

   1. Pesquise `sys_properties.list` na caixa de pesquisa do filtro e pressione enter (não mostrará a opção, mas pressionar enter funciona)

   1. Escolha Novo

   1. Adicione o nome como `glide.oauth.inbound.client.credential.grant_type.enabled` e o valor como verdadeiro com o tipo verdadeiro \$1 falso

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


1. Navegue até Sistema OAuth > Registro de aplicativos na caixa de pesquisa do filtro

1. Escolha “Novo” > “Nova experiência de integração de entrada” > “Nova integração” > “OAuth - Concessão de credenciais do cliente”

1. Escolha um nome e defina o usuário do OAuth aplicativo como “Administrador do problema”, clique em “Salvar”

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


### Conecte seu ServiceNow OAuth cliente ao AWS DevOps agente
<a name="connect-your-servicenow-oauth-client-to-aws-devops-agent"></a>

1. Você pode iniciar esse processo em dois lugares. Primeiro, navegando até a página **Provedores de Capacidades**, encontrando **ServiceNow**em **Comunicação** e, em seguida, clicando em **Registrar**. Como alternativa, você pode selecionar qualquer Espaço do DevOps Agente que você possa ter criado e navegar até Capacidades → Comunicações → Adicionar → ServiceNow e clicar em Registrar.

1. Em seguida, autorize o DevOps Agente a acessar sua ServiceNow instância usando o cliente do OAuth aplicativo que você acabou de criar.

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

+ Siga as próximas etapas e salve as informações resultantes sobre o webhook 

**Importante**  
Você não verá essas informações novamente

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


### Configure sua regra ServiceNow de negócios
<a name="configure-your-servicenow-business-rule"></a>

Depois de estabelecer a conectividade, você precisará configurar uma regra de negócios para enviar tickets ServiceNow para o (s) seu (s) espaço (s) de DevOps agente.

1. Navegue até Assinaturas de atividades → Administração → Regras de negócios e clique em Novo.

1. Defina o campo “Tabela” como “Incidente [incidente]”, marque a caixa “Avançado” e defina a regra a ser executada após Inserir, Atualizar e Excluir.

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


1. Navegue até a guia “Avançado” e adicione o seguinte script de webhook, inserindo o segredo e o URL do webhook onde indicado, e clique em Enviar.

```
(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 você optou por registrar sua ServiceNow conexão na página **Capability Providers**, agora você precisa navegar até o DevOps Agent Space no qual deseja investigar os tickets de ServiceNow incidentes, selecionar Capabilities → Communications e, em seguida, registrar a ServiceNow instância registrada na página Capability Providers. Agora, tudo deve estar configurado e todos os incidentes em que o chamador está configurado como “Administrador do problema” (para imitar as permissões que você concedeu ao AWS DevOps OAuth cliente) acionarão uma investigação de resposta a incidentes no Espaço do Agente configurado DevOps . Você pode testar isso criando um novo incidente ServiceNow e definindo o campo Chamador do incidente como “Administrador do problema”. 

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


### ServiceNow atualizações de ingressos
<a name="servicenow-ticket-updates"></a>

Durante todas as investigações de resposta a incidentes acionados, seu DevOps agente fornecerá atualizações de suas principais descobertas, análises da causa raiz e planos de mitigação no ticket de origem. As descobertas do agente são publicadas nos comentários de um incidente e, atualmente, publicaremos apenas registros do agente do tipo`finding`,, `cause` `investigation_summary``mitigation_summary`, e atualizações do status da investigação (por exemplo`AWS DevOps Agent started/finished its investigation`).

## Exemplos de roteamento e orquestração de tickets
<a name="ticket-routing-and-orchestration-examples"></a>

### Cenário: filtrando quais incidentes são enviados para um DevOps Espaço do Agente
<a name="scenario-filtering-which-incidents-are-sent-to-a-devops-agent-space"></a>

Esse é um cenário simples, mas precisa de alguma configuração ServiceNow para criar um campo ServiceNow para rastrear a origem do incidente. Para fins deste exemplo, crie um novo campo Fonte (u\$1source) usando o construtor de formulários SNOW. Isso permitirá rastrear a origem do incidente e usá-la para rotear solicitações de uma fonte específica para um Espaço do DevOps Agente. O roteamento é realizado criando uma regra de negócios do Service Now e, na guia Quando executar, definindo os gatilhos “Quando” e “Condições do filtro”. Neste exemplo, as condições do filtro são definidas da seguinte forma: 

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


### Cenário: roteamento de incidentes em vários DevOps espaços de agentes
<a name="scenario-routing-incidents-across-multiple-devops-agent-spaces"></a>

Este exemplo mostra como acionar uma Investigação no Espaço do DevOps Agente B quando a urgência é`1`, a categoria é `Software` ou o Serviço é`AWS`, e acionar uma Investigação no Espaço do DevOps Agente A quando o serviço é `AWS` e a origem é`Dynatrace`.

Esse cenário pode ser realizado de duas maneiras. O script do webhook em si pode ser atualizado para incluir essa lógica de negócios. Nesse cenário, mostraremos como fazer isso com uma regra de ServiceNow negócios, para transparência e simplificação da depuração. O roteamento é realizado com a criação de duas regras de negócios do Service Now.
+ Crie uma regra de negócios ServiceNow para o DevOps Agent Space A e crie uma condição usando o construtor de condições para enviar somente os eventos com base em nossa condição especificada.

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

+ Em seguida, crie outra regra de negócios ServiceNow para AgentSpace B, para a qual a regra de negócios só será acionada quando o serviço for AWS e a origem for o Dynatrace.

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


Agora, quando você cria um novo incidente que corresponda à condição especificada, ele aciona uma investigação no Espaço do DevOps Agente A ou no Espaço do DevOps Agente B, fornecendo a você um controle refinado sobre o roteamento de incidentes.