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á.

# AWS DevOps Guia de integração do Agent CLI
<a name="getting-started-with-aws-devops-agent-cli-onboarding-guide"></a>

## Visão geral do
<a name="overview"></a>

Com o AWS DevOps Agent, você pode monitorar e gerenciar sua AWS infraestrutura. Este guia explica como configurar o AWS DevOps Agente usando a Interface de Linha de AWS Comando (AWS CLI). Você cria funções do IAM, configura um espaço de agente e associa sua AWS conta. Você também ativa o aplicativo do operador e, opcionalmente, conecta integrações de terceiros. Este guia leva aproximadamente 20 minutos para ser concluído.

AWS DevOps O agente está disponível em seis AWS regiões: Leste dos EUA (Norte da Virgínia), Oeste dos EUA (Oregon), Ásia-Pacífico (Sydney), Ásia-Pacífico (Tóquio), Europa (Frankfurt) e Europa (Irlanda). Para obter mais informações sobre as regiões suportadas, consulte[Regiões aceitas](about-aws-devops-agent-supported-regions.md).

## Pré-requisitos
<a name="prerequisites"></a>

Antes de começar, verifique se você tem o seguinte:
+ AWS CLI versão 2 instalada e configurada
+ Autenticação em sua conta AWS de monitoramento
+ Permissões para criar funções de AWS Identity and Access Management (IAM) e anexar políticas
+ Uma AWS conta para usar como conta de monitoramento
+ Familiaridade com a AWS CLI e a sintaxe JSON

Ao longo deste guia, substitua os seguintes valores de espaço reservado pelos seus próprios:
+ `<MONITORING_ACCOUNT_ID>`— Seu ID de AWS conta de 12 dígitos para a conta de monitoramento (primária)
+ `<EXTERNAL_ACCOUNT_ID>`— O ID da AWS conta de 12 dígitos da conta secundária a ser monitorada (usado na etapa 4)
+ `<REGION>`— O código AWS da região do seu espaço de agente (por exemplo, `us-east-1` ou`eu-central-1`)
+ `<AGENT_SPACE_ID>`— O identificador do espaço do agente que é retornado pelo `create-agent-space` comando

## Configuração de funções do IAM
<a name="iam-roles-setup"></a>

### 1. Crie a função de espaço do DevOps agente
<a name="1-create-the-devops-agent-space-role"></a>

Crie a política de confiança do IAM executando o seguinte comando:

```
cat > devops-agentspace-trust-policy.json << 'EOF'
{
  "Version": "2012-10-17",		 	 	 		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": "aidevops.amazonaws.com"
      },
      "Action": "sts:AssumeRole",
      "Condition": {
        "StringEquals": {
          "aws:SourceAccount": "<MONITORING_ACCOUNT_ID>"
        },
        "ArnLike": {
          "aws:SourceArn": "arn:aws:aidevops:<REGION>:<MONITORING_ACCOUNT_ID>:agentspace/*"
        }
      }
    }
  ]
}
EOF
```

Crie o perfil do IAM:

```
aws iam create-role \
  --region <REGION> \
  --role-name DevOpsAgentRole-AgentSpace \
  --assume-role-policy-document file://devops-agentspace-trust-policy.json
```

Salve o ARN da função executando o seguinte comando:

```
aws iam get-role --role-name DevOpsAgentRole-AgentSpace --query 'Role.Arn' --output text
```

Anexe a política AWS gerenciada:

```
aws iam attach-role-policy \
  --role-name DevOpsAgentRole-AgentSpace \
  --policy-arn arn:aws:iam::aws:policy/AIDevOpsAgentAccessPolicy
```

Crie e anexe uma política em linha para permitir a criação da função vinculada ao serviço Resource Explorer:

```
cat > devops-agentspace-additional-policy.json << 'EOF'
{
  "Version": "2012-10-17",		 	 	 		 	 	 
  "Statement": [
    {
      "Sid": "AllowCreateServiceLinkedRoles",
      "Effect": "Allow",
      "Action": [
        "iam:CreateServiceLinkedRole"
      ],
      "Resource": [
        "arn:aws:iam::<MONITORING_ACCOUNT_ID>:role/aws-service-role/resource-explorer-2.amazonaws.com/AWSServiceRoleForResourceExplorer"
      ]
    }
  ]
}
EOF

aws iam put-role-policy \
  --role-name DevOpsAgentRole-AgentSpace \
  --policy-name AllowCreateServiceLinkedRoles \
  --policy-document file://devops-agentspace-additional-policy.json
```

### 2. Crie a função IAM do aplicativo do operador
<a name="2-create-the-operator-app-iam-role"></a>

Crie a política de confiança do IAM executando o seguinte comando:

```
cat > devops-operator-trust-policy.json << 'EOF'
{
  "Version": "2012-10-17",		 	 	 		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": "aidevops.amazonaws.com"
      },
      "Action": [
        "sts:AssumeRole",
        "sts:TagSession"
      ],
      "Condition": {
        "StringEquals": {
          "aws:SourceAccount": "<MONITORING_ACCOUNT_ID>"
        },
        "ArnLike": {
          "aws:SourceArn": "arn:aws:aidevops:<REGION>:<MONITORING_ACCOUNT_ID>:agentspace/*"
        }
      }
    }
  ]
}
EOF
```

Crie o perfil do IAM:

```
aws iam create-role \
  --role-name DevOpsAgentRole-WebappAdmin \
  --assume-role-policy-document file://devops-operator-trust-policy.json \
  --region <REGION>
```

Salve o ARN da função executando o seguinte comando:

```
aws iam get-role --role-name DevOpsAgentRole-WebappAdmin --query 'Role.Arn' --output text
```

Anexe a política do aplicativo AWS gerenciado do operador:

```
aws iam attach-role-policy \
  --role-name DevOpsAgentRole-WebappAdmin \
  --policy-arn arn:aws:iam::aws:policy/AIDevOpsOperatorAppAccessPolicy
```

Essa política gerenciada concede ao aplicativo do operador permissões para acessar os recursos do espaço do agente. Esses recursos incluem investigações, recomendações, gerenciamento de conhecimento, bate-papo e integração com o AWS Support. A política define o escopo do acesso ao espaço específico do agente usando a `aws:PrincipalTag/AgentSpaceId` condição. Para obter mais informações sobre a lista completa de ações, consulte[DevOps Permissões do Agent IAM](aws-devops-agent-security-devops-agent-iam-permissions.md).

## Etapas de integração
<a name="onboarding-steps"></a>

### 1. Crie um espaço para agentes
<a name="1-create-an-agent-space"></a>

Execute o comando a seguir para criar um espaço de agente:

```
aws devops-agent create-agent-space \
  --name "MyAgentSpace" \
  --description "AgentSpace for monitoring my application" \
  --region <REGION>
```

Opcionalmente, especifique `--kms-key-arn` o uso de uma chave AWS KMS gerenciada pelo cliente para criptografia. Você também pode usar `--tags` para adicionar tags de recursos e `--locale` definir o idioma das respostas do agente.

Salve o `agentSpaceId` da resposta (localizada em`agentSpace.agentSpaceId`).

Para listar seus espaços de agente posteriormente, execute o seguinte comando:

```
aws devops-agent list-agent-spaces \
  --region <REGION>
```

### 2. Associe sua AWS conta
<a name="2-associate-your-aws-account"></a>

Associe sua AWS conta para ativar a descoberta de topologia. Defina o `accountType` para um dos seguintes valores:
+ `monitor`— A conta principal em que o espaço do agente existe. Essa conta hospeda o agente e é usada para descoberta de topologia.
+ `source`— Uma conta adicional que o agente monitora. Use esse tipo ao associar contas externas na etapa 4.

```
aws devops-agent associate-service \
  --agent-space-id <AGENT_SPACE_ID> \
  --service-id aws \
  --configuration '{
    "aws": {
      "assumableRoleArn": "arn:aws:iam::<MONITORING_ACCOUNT_ID>:role/DevOpsAgentRole-AgentSpace",
      "accountId": "<MONITORING_ACCOUNT_ID>",
      "accountType": "monitor"
    }
  }' \
  --region <REGION>
```

### 3. Ativar o aplicativo do operador
<a name="3-enable-the-operator-app"></a>

Os fluxos de autenticação podem usar o IAM, o IAM Identity Center (IDC) ou um provedor de identidade externo (IdP). Execute o comando a seguir para habilitar o aplicativo do operador para seu espaço de agente:

```
aws devops-agent enable-operator-app \
  --agent-space-id <AGENT_SPACE_ID> \
  --auth-flow iam \
  --operator-app-role-arn "arn:aws:iam::<MONITORING_ACCOUNT_ID>:role/DevOpsAgentRole-WebappAdmin" \
  --region <REGION>
```

Para autenticação do IAM Identity Center, use `--auth-flow idc` e forneça`--idc-instance-arn`. Para um provedor de identidade externo, use `--auth-flow idp` e forneça `--issuer-url``--idp-client-id`, `--idp-client-secret` e. Para obter mais informações, consulte [Configurando a autenticação do IAM Identity Center](aws-devops-agent-security-setting-up-iam-identity-center-authentication.md) e [Configurando a autenticação do provedor de identidade externo (IdP)](aws-devops-agent-security-setting-up-external-identity-provider-idp-authentication.md).

**Observação:** se você criou anteriormente uma função de aplicativo de operador para outro espaço de agente em sua conta, você pode reutilizar o ARN dessa função.

### 4. (Opcional) Associar contas de origem adicionais
<a name="4-optional-associate-additional-source-accounts"></a>

Para monitorar contas adicionais com o AWS DevOps Agent, crie uma função entre contas do IAM.

#### Crie a função entre contas na conta externa
<a name="create-the-cross-account-role-in-the-external-account"></a>

Mude para a conta externa e crie a política de confiança. `MONITORING_ACCOUNT_ID`É a conta principal que hospeda o espaço do agente que você configurou na etapa 2. Essa configuração permite que o serviço do AWS DevOps Agente assuma uma função nas contas de origem secundária em nome da conta de monitoramento.

Execute o comando a seguir para criar a política de confiança:

```
cat > devops-cross-account-trust-policy.json << 'EOF'
{
  "Version": "2012-10-17",		 	 	 		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": "aidevops.amazonaws.com"
      },
      "Action": "sts:AssumeRole",
      "Condition": {
        "StringEquals": {
          "aws:SourceAccount": "<MONITORING_ACCOUNT_ID>",
          "sts:ExternalId": "arn:aws:aidevops:<REGION>:<MONITORING_ACCOUNT_ID>:agentspace/<AGENT_SPACE_ID>"
        }
      }
    }
  ]
}
EOF
```

Crie a função do IAM entre contas:

```
aws iam create-role \
  --role-name DevOpsAgentCrossAccountRole \
  --assume-role-policy-document file://devops-cross-account-trust-policy.json
```

Salve o ARN da função executando o seguinte comando:

```
aws iam get-role --role-name DevOpsAgentCrossAccountRole --query 'Role.Arn' --output text
```

Anexe a política AWS gerenciada:

```
aws iam attach-role-policy \
  --role-name DevOpsAgentCrossAccountRole \
  --policy-arn arn:aws:iam::aws:policy/AIDevOpsAgentAccessPolicy
```

Anexe a política em linha para permitir a criação da função vinculada ao serviço Resource Explorer na conta externa:

```
cat > devops-cross-account-additional-policy.json << 'EOF'
{
  "Version": "2012-10-17",		 	 	 		 	 	 
  "Statement": [
    {
      "Sid": "AllowCreateServiceLinkedRoles",
      "Effect": "Allow",
      "Action": [
        "iam:CreateServiceLinkedRole"
      ],
      "Resource": [
        "arn:aws:iam::<EXTERNAL_ACCOUNT_ID>:role/aws-service-role/resource-explorer-2.amazonaws.com/AWSServiceRoleForResourceExplorer"
      ]
    }
  ]
}
EOF

aws iam put-role-policy \
  --role-name DevOpsAgentCrossAccountRole \
  --policy-name AllowCreateServiceLinkedRoles \
  --policy-document file://devops-cross-account-additional-policy.json
```

#### Associar a conta externa
<a name="associate-the-external-account"></a>

Volte para sua conta de monitoramento e execute o seguinte comando para associar a conta externa:

```
aws devops-agent associate-service \
  --agent-space-id <AGENT_SPACE_ID> \
  --service-id aws \
  --configuration '{
    "sourceAws": {
      "accountId": "<EXTERNAL_ACCOUNT_ID>",
      "accountType": "source",
      "assumableRoleArn": "arn:aws:iam::<EXTERNAL_ACCOUNT_ID>:role/DevOpsAgentCrossAccountRole"
    }
  }' \
  --region <REGION>
```

### 5. (Opcional) Associado GitHub
<a name="5-optional-associate-github"></a>

**Observação:** primeiro, você deve se registrar GitHub por meio do console do AWS DevOps agente usando o OAuth fluxo antes de poder associá-lo por meio da CLI.

Para obter instruções sobre como se registrar GitHub por meio do console, consulte[Conexão a CI/CD tubulações](configuring-capabilities-for-aws-devops-agent-connecting-to-cicd-pipelines-index.md).

Liste os serviços registrados:

```
aws devops-agent list-services \
  --region <REGION>
```

Salve o `<SERVICE_ID>` para ServiceType:. `github`

Depois de se registrar GitHub no console, associe GitHub repositórios executando o seguinte comando:

```
aws devops-agent associate-service \
  --agent-space-id <AGENT_SPACE_ID> \
  --service-id <SERVICE_ID> \
  --configuration '{
    "github": {
      "repoName": "<GITHUB_REPO_NAME>",
      "repoId": "<GITHUB_REPO_ID>",
      "owner": "<GITHUB_OWNER>",
      "ownerType": "organization"
    }
  }' \
  --region <REGION>
```

### 6. (Opcional) Registre-se e associe-se ServiceNow
<a name="6-optional-register-and-associate-servicenow"></a>

Primeiro, registre o ServiceNow serviço com OAuth as credenciais:

```
aws devops-agent register-service \
  --service servicenow \
  --service-details  '{
    "servicenow": {
      "instanceUrl": "<SERVICENOW_INSTANCE_URL>",
      "authorizationConfig": {
        "oAuthClientCredentials": {
            "clientName": "<SERVICENOW_CLIENT_NAME>",
            "clientId": "<SERVICENOW_CLIENT_ID>",
            "clientSecret": "<SERVICENOW_CLIENT_SECRET>"
        }
      }
    }
  }' \
  --region <REGION>
```

Salve o retornado `<SERVICE_ID>` e associe ServiceNow:

```
aws devops-agent associate-service \
  --agent-space-id <AGENT_SPACE_ID> \
  --service-id <SERVICE_ID> \
  --configuration '{
    "servicenow": {
      "instanceUrl": "<SERVICENOW_INSTANCE_URL>"
    }
  }' \
  --region <REGION>
```

### 7. (Opcional) Registre e associe o Dynatrace
<a name="7-optional-register-and-associate-dynatrace"></a>

Primeiro, registre o serviço Dynatrace com OAuth as credenciais:

```
aws devops-agent register-service \
  --service dynatrace \
  --service-details '{
  "dynatrace": {
    "accountUrn": "<DYNATRACE_ACCOUNT_URN>",
    "authorizationConfig": {
        "oAuthClientCredentials": {
            "clientName": "<DYNATRACE_CLIENT_NAME>",
            "clientId": "<DYNATRACE_CLIENT_ID>",
            "clientSecret": "<DYNATRACE_CLIENT_SECRET>"
        }
      }
    }
  }' \
  --region <REGION>
```

Salve o retornado `<SERVICE_ID>` e associe o Dynatrace. Os recursos são opcionais. O ambiente especifica a qual ambiente Dynatrace se associar.

```
aws devops-agent associate-service \
  --agent-space-id <AGENT_SPACE_ID> \
  --service-id <SERVICE_ID> \
  --configuration '{
    "dynatrace": {
      "envId": "<DYNATRACE_ENVIRONMENT_ID>",
      "resources": [
        "<DYNATRACE_RESOURCE_1>",
        "<DYNATRACE_RESOURCE_2>"
      ]
    }
  }' \
  --region <REGION>
```

A resposta inclui informações de webhook para integração. Você pode usar esse webhook para acionar uma investigação da Dynatrace. Para obter mais informações, consulte [Conectando o Dynatrace](connecting-telemetry-sources-connecting-dynatrace.md).

### 8. (Opcional) Registre e associe o Splunk
<a name="8-optional-register-and-associate-splunk"></a>

Primeiro, registre o serviço Splunk com BearerToken as credenciais.

O endpoint usa o seguinte formato: `https://<XXX>.api.scs.splunk.com/<XXX>/mcp/v1/`

```
aws devops-agent register-service \
  --service mcpserversplunk \
  --service-details '{
  "mcpserversplunk": {
    "name": "<SPLUNK_NAME>",
    "endpoint": "<SPLUNK_ENDPOINT>",
    "authorizationConfig": {
        "bearerToken": {
            "tokenName": "<SPLUNK_TOKEN_NAME>",
            "tokenValue": "<SPLUNK_TOKEN_VALUE>"
        }
      }
    }
  }' \
  --region <REGION>
```

Salve o retornado `<SERVICE_ID>` e associe o Splunk:

```
aws devops-agent associate-service \
  --agent-space-id <AGENT_SPACE_ID> \
  --service-id <SERVICE_ID> \
  --configuration '{
    "mcpserversplunk":  {
      "name": "<SPLUNK_NAME>",
      "endpoint": "<SPLUNK_ENDPOINT>"
    }
  }' \
  --region <REGION>
```

A resposta inclui informações de webhook para integração. Você pode usar esse webhook para acionar uma investigação da Splunk. Para obter mais informações, consulte [Conectando o Splunk](connecting-telemetry-sources-connecting-splunk.md).

### 9. (Opcional) Registre e associe a New Relic
<a name="9-optional-register-and-associate-new-relic"></a>

Primeiro, registre o serviço New Relic com as credenciais da chave de API.

Região: `US` Ou`EU`.

Campos opcionais:`applicationIds`,`entityGuids`, `alertPolicyIds`

```
aws devops-agent register-service \
  --service mcpservernewrelic \
  --service-details '{
    "mcpservernewrelic": {
      "authorizationConfig": {
        "apiKey": {
          "apiKey": "<YOUR_NEW_RELIC_API_KEY>",
          "accountId": "<YOUR_ACCOUNT_ID>",
          "region": "US",
          "applicationIds": ["<APP_ID_1>", "<APP_ID_2>"],
          "entityGuids": ["<ENTITY_GUID_1>"],
          "alertPolicyIds": ["<POLICY_ID_1>"]
        }
      }
    }
  }' \
  --region <REGION>
```

Salve o retornado `<SERVICE_ID>` e, em seguida, associe o New Relic:

```
aws devops-agent associate-service \
  --agent-space-id <AGENT_SPACE_ID> \
  --service-id <SERVICE_ID> \
  --configuration '{
    "mcpservernewrelic":  {
      "accountId": "<YOUR_ACCOUNT_ID>",
      "endpoint": "https://mcp.newrelic.com/mcp/"
    }
  }' \
  --region <REGION>
```

A resposta inclui informações de webhook para integração. Você pode usar esse webhook para iniciar uma investigação da New Relic. Para obter mais informações, consulte [Conectando a New Relic](connecting-telemetry-sources-connecting-new-relic.md).

### 10. (Opcional) Registre e associe o Datadog
<a name="10-optional-register-and-associate-datadog"></a>

Primeiro, você deve registrar o Datadog por meio do console do AWS DevOps agente usando o OAuth fluxo antes de poder associá-lo por meio da CLI. Para obter mais informações, consulte [Conectando DataDog](connecting-telemetry-sources-connecting-datadog.md).

Liste os serviços registrados:

```
aws devops-agent list-services \
  --region <REGION>
```

Salve o `<SERVICE_ID>` para ServiceType:. `mcpserverdatadog`

Em seguida, associe o Datadog:

```
aws devops-agent associate-service \
  --agent-space-id <AGENT_SPACE_ID> \
  --service-id <SERVICE_ID> \
  --configuration '{
    "mcpserverdatadog": {
      "name": "Datadog-MCP-Server",
      "endpoint": "<DATADOG_MCP_ENDPOINT>"
    }
  }' \
  --region <REGION>
```

A resposta inclui informações de webhook para integração. Você pode usar esse webhook para acionar uma investigação do Datadog. Para obter mais informações, consulte [Conectando DataDog](connecting-telemetry-sources-connecting-datadog.md).

### 11. (Opcional) Excluir um espaço de agente
<a name="11-optional-delete-an-agent-space"></a>

A exclusão de um espaço de agente remove todas as associações, configurações e dados de investigação desse espaço de agente. Esta ação não pode ser desfeita.

Para excluir um espaço de agente, execute o seguinte comando:

```
aws devops-agent delete-agent-space \
  --agent-space-id <AGENT_SPACE_ID> \
  --region <REGION>
```

## Verificação
<a name="verification"></a>

Para verificar sua configuração, execute os seguintes comandos:

```
# List your agent spaces
aws devops-agent list-agent-spaces \
  --region <REGION>

# Get details of a specific agent space
aws devops-agent get-agent-space \
  --agent-space-id <AGENT_SPACE_ID> \
  --region <REGION>

# List associations for an agent space
aws devops-agent list-associations \
  --agent-space-id <AGENT_SPACE_ID> \
  --region <REGION>
```

## Próximas etapas
<a name="next-steps"></a>
+ Para conectar integrações adicionais, consulte[Configurando recursos para AWS DevOps o Agent](configuring-capabilities-for-aws-devops-agent.md).
+ Para saber mais sobre as habilidades e capacidades dos agentes, consulte[DevOps Habilidades do agente](about-aws-devops-agent-devops-agent-skills.md).
+ Para entender o aplicativo web do operador, consulte[O que é um DevOps Agent Web App?](about-aws-devops-agent-what-is-a-devops-agent-web-app.md).

## Observações
<a name="notes"></a>
+ Substitua `<AGENT_SPACE_ID>``<MONITORING_ACCOUNT_ID>`,`<EXTERNAL_ACCOUNT_ID>`,`<REGION>`, e assim por diante por seus valores reais.
+ Para obter uma lista de regiões compatíveis, consulte [Regiões aceitas](about-aws-devops-agent-supported-regions.md).