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

# Começando com o AWS DevOps Agent
<a name="getting-started-with-aws-devops-agent"></a>

Neste guia de introdução, você criará um Agent Space básico, configurará permissões mínimas e conduzirá sua primeira investigação baseada em IA.

## Tópicos:
<a name="topics"></a>
+ [Criação de um espaço de agente](getting-started-with-aws-devops-agent-creating-an-agent-space.md)
+ [AWS DevOps Guia de integração do Agent CLI](getting-started-with-aws-devops-agent-cli-onboarding-guide.md)
+ [Criação de um ambiente de teste](getting-started-with-aws-devops-agent-creating-a-test-environment.md)
+ [Introdução ao AWS DevOps Agent usando o AWS CDK](getting-started-with-aws-devops-agent-getting-started-with-aws-devops-agent-using-aws-cdk.md)
+ [Começando a usar o AWS DevOps Agent usando AWS CloudFormation](getting-started-with-aws-devops-agent-getting-started-with-aws-devops-agent-using-aws-cloudformation.md)
+ [Introdução ao AWS DevOps Agent usando o Terraform](getting-started-with-aws-devops-agent-getting-started-with-aws-devops-agent-using-terraform.md)

# Criação de um espaço de agente
<a name="getting-started-with-aws-devops-agent-creating-an-agent-space"></a>

Um Espaço do Agente define as ferramentas e a infraestrutura às AWS DevOps quais o Agente tem acesso. Este guia orienta você na criação de um Espaço do Agente, na configuração do acesso à conta principal e na ativação do DevOps Agent Web App. Consulte “O que é um espaço do agente” para saber mais sobre o conceito do espaço do agente.

## Criação de um espaço de agente
<a name="creating-an-agent-space"></a>

### Acesse o console do AWS DevOps agente
<a name="access-the-aws-devops-agent-console"></a>

1. Faça login no console AWS de gerenciamento

1. Navegue até o console do AWS DevOps agente

### Nomeie o Agent Space
<a name="name-the-agent-space"></a>

1. Clique em **Criar espaço do agente**

Na seção **Detalhes do Espaço do Agente**, forneça:

1. No campo **Nome**, insira um nome para o seu Espaço do Agente

1. (Opcional) No campo **Descrição**, adicione detalhes sobre a finalidade do Espaço do Agente

1. (Opcional) No menu suspenso **Idioma de resposta do agente**, selecione o idioma que o agente usa ao gerar respostas, descobertas e resultados da investigação. As opções incluem: indonésio, chinês (Simplified/PRC), Chinese (Traditional/Taiwan), inglês (Reino Unido), francês (França), alemão (Alemanha), italiano (Itália), japonês (Japão), coreano (Coreia), português (Brasil), espanhol (América Latina), turco (Turquia), árabe (Arábia Saudita), tailandês (Tailândia) e vietnamita (Vietnã) Vietnã). Se nenhum idioma for selecionado, o agente responderá no idioma da entrada.

### Configurando o acesso à conta principal
<a name="configuring-primary-account-access"></a>

Na seção **Conceder acesso aos AWS recursos do Agent Space**, você configurará uma função do IAM para conceder ao Agent Space acesso à AWS conta principal. A conta principal é a AWS conta na qual você cria seu Espaço do Agente. AWS DevOps O agente exige uma função do IAM para descobrir e acessar AWS recursos nessa conta durante as investigações.

Escolha um método de configuração de função. **** Selecione uma das opções a seguir:

#### Opção 1: criar automaticamente uma nova função de AWS DevOps agente (recomendado)
<a name="option-1-auto-create-a-new-aws-devops-agent-role-recommended"></a>

Essa opção cria automaticamente uma função com as permissões apropriadas para que o AWS DevOps Agente investigue recursos em sua conta.

**nota**  
**Você precisa ter permissões do IAM para criar novas funções para usar essa opção.

1. Selecione **Criar automaticamente uma nova função de AWS DevOps agente**

1. (Opcional) Atualize o nome da função do Agent Space a ser criada

#### Opção 2: atribuir uma função existente
<a name="option-2-assign-an-existing-role"></a>

Use essa opção quando outro administrador tiver criado anteriormente uma função específica para o AWS DevOps Agente.

1. Selecione **Atribuir uma função existente**

1. No menu suspenso, selecione uma função existente que tenha as permissões apropriadas

#### Opção 3: criar uma nova função de AWS DevOps agente usando um modelo de política
<a name="option-3-create-a-new-aws-devops-agent-role-using-a-policy-template"></a>

Use essa opção quando precisar limitar os serviços e recursos que o agente pode acessar na conta principal.

1. Selecione **Criar uma nova função de AWS DevOps agente usando um modelo de política**

1. Siga as instruções para criar a política de confiança e a política embutida da nova função.

### Ativando o Agent Space Web App
<a name="enabling-the-agent-space-web-app"></a>

O aplicativo Web é onde a equipe interage com o AWS DevOps Agente para investigações de incidentes e revisão de recomendações. Consulte Arquitetura do console do AWS DevOps agente [link] para saber mais. Quando ativado, os usuários podem acessar o Agent Space Web App por meio de um link de autenticação do IAM no AWS Management Console.

Selecione uma das opções a seguir:

#### Opção 1: criar automaticamente uma nova função de AWS DevOps agente (recomendado)
<a name="option-1-auto-create-a-new-aws-devops-agent-role-recommended"></a>

Essa opção cria automaticamente uma função com as permissões apropriadas para acessar o DevOps Agent Web App.

**nota**  
**Você precisa ter permissões do IAM para criar novas funções para usar essa opção.

1. Selecione **Criar automaticamente uma nova função de AWS DevOps agente**

1. Revise as permissões que serão concedidas à função

#### Opção 2: atribuir uma função existente
<a name="option-2-assign-an-existing-role"></a>

Use essa opção quando outro administrador tiver criado anteriormente uma função de operador.

1. Selecione **Atribuir uma função existente**

1. No menu suspenso, selecione uma função existente que tenha as permissões apropriadas

#### Opção 3: criar uma nova função de AWS DevOps agente usando um modelo de política
<a name="option-3-create-a-new-aws-devops-agent-role-using-a-policy-template"></a>

Use essa opção quando precisar personalizar as permissões para acesso ao aplicativo web.

1. Selecione **Criar uma nova função de AWS DevOps agente usando um modelo de política**

1. Siga as instruções para criar a política de confiança e a política embutida da nova função.

### Adicionar tags (opcional)
<a name="adding-tags-optional"></a>

Você pode adicionar AWS tags ao seu Espaço do Agente durante a criação. As tags são pares de valores-chave que ajudam você a organizar e identificar seus recursos. Você pode adicionar até 50 tags por espaço do agente. Para adicionar tags, expanda a seção **Tags** na página Criar espaço do agente e clique em **Adicionar nova tag**.

### Criação completa do espaço do agente
<a name="complete-agent-space-creation"></a>

Depois que todas as seções estiverem preenchidas, clique em **Criar**

## Verificando sua configuração do Agent Space
<a name="verifying-your-agent-space-setup"></a>

Depois de configurado, o botão de **acesso do operador** aparecerá na página de detalhes do Espaço do agente. Clicar nele abrirá o aplicativo Web em uma nova guia e será autenticado com êxito.

## Próximas etapas
<a name="next-steps"></a>

Depois de configurar seu Espaço do Agente, considere estas próximas etapas:
+ Adicione contas secundárias se seus aplicativos abrangerem várias AWS contas
+ Configure integrações de terceiros, como ferramentas de observabilidade ou sistemas de emissão de bilhetes
+ Configurar a autenticação do AWS Identity Center para ambientes de produção
+ Explore o mapeamento de recursos do seu aplicativo para ajudar o AWS DevOps Agente a entender sua infraestrutura

# 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).

# Criação de um ambiente de teste
<a name="getting-started-with-aws-devops-agent-creating-a-test-environment"></a>

Este guia fornece testes práticos para validar a funcionalidade de resposta a incidentes do AWS DevOps Agente usando uma arquitetura de amostra. Use este suplemento se quiser testar o DevOps Agent antes de conectar seus sistemas de produção.

## Pré-requisitos
<a name="prerequisites"></a>
+ AWS conta com acesso administrativo
+ AWS DevOps Espaço do agente criado e configurado usando o fluxo de função de criação automática do DevOps agente

## Visão geral de custos e segurança
<a name="cost-and-safety-overview"></a>

### Proteção de custos
<a name="cost-protection"></a>
+ **Teste EC2**: GRATUITO (nível AWS gratuito) ou \$1 \$10,02 por 2 horas
+ **Teste Lambda**: GRATUITO (nível gratuito de 1 milhão requests/month )
+ **CloudWatch**: GRÁTIS (10 alarmes, métricas básicas incluídas)
+ **Custo total estimado esperado**: \$10,00 - \$10,05 para o teste completo

### Características de segurança nesses testes
<a name="safety-features-in-these-tests"></a>
+ **Terminação automática**: desligamento automático embutido
+ **Nível gratuito qualificado**: usa os menores tipos de instância
+ **Escopo limitado**: recursos de teste mínimos e isolados
+ **Limpeza fácil**: etapas simples do console para remover tudo
+ **Sem impacto na produção**: ambiente de teste completamente separado

## Configure sua AWS conta para testes
<a name="set-up-your-aws-account-for-testing"></a>

**Importante**  
**Os recursos de infraestrutura precisam ser implantados na AWS conta em que você criou a conta de nuvem primária do seu DevOps Agent Space. A região específica não importa.

1. Faça login no AWS console: [https://console.aws.amazon.com](https://console.aws.amazon.com/)

1. Verifique se você está trabalhando na mesma AWS conta em que seu Espaço DevOps do Agente está localizado

1. Você pode usar qualquer região para seus recursos de teste

**nota**  
O mapeamento 1:1 entre a conta principal do seu DevOps agente e os recursos do ambiente de teste que você está criando simplifica a configuração do teste. Você pode estender facilmente seu Espaço do DevOps Agente para incluir contas secundárias e permitir investigações entre contas.

## Escolha seu teste
<a name="choose-your-test"></a>

Você pode executar qualquer um dos testes de forma independente ou os dois juntos:

### Opção de teste A: teste de capacidade da CPU EC2
<a name="test-option-a-ec2-cpu-capacity-test"></a>

**Objetivo**: validar a capacidade do AWS DevOps agente de detectar e investigar problemas de desempenho do EC2

**Tempo estimado**: 5 minutos de configuração \$1 10 minutos de execução automática

**Dificuldade**: Totalmente automatizado (sem necessidade de etapas manuais)

### Opção de teste B: teste de taxa de erro Lambda
<a name="test-option-b-lambda-error-rate-test"></a>

**Objetivo**: validar a capacidade do AWS DevOps agente de detectar e investigar erros da função Lambda

**Tempo estimado**: 10 minutos de configuração \$12 minutos para acionar

**Dificuldade**: Muito fácil

## Opção de teste A: teste de capacidade da CPU EC2
<a name="test-option-a-ec2-cpu-capacity-test"></a>

### Etapa 1: implantar a CloudFormation pilha para o teste do EC2
<a name="step-1-deploy-cloudformation-stack-for-ec2-test"></a>

Usaremos CloudFormation para criar nossos recursos de teste, o que permite ao AWS DevOps Agente rastreá-los e investigá-los adequadamente.

1. **Navegue até CloudFormation**:

   1. No AWS Console, pesquise por "CloudFormation" e clique em **CloudFormation**

   1. Clique em **Criar pilha** > **Com novos recursos (padrão)**

1. **Carregar modelo**:

   1. Crie um novo arquivo local chamado `AWS-DevOpsAgent-ec2-test.yaml`

   1. Copie e cole esse CloudFormation modelo no arquivo:

      1. 

         ```
         AWSTemplateFormatVersion: '2010-09-09'
         Description: 'AWS DevOps Agent EC2 CPU Test Stack'
         Parameters:
           MyIP:
             Type: String
             Description: Your current IP address for SSH access (find at https://whatismyipaddress.com)
             Default: '0.0.0.0/0'
         Resources:
           # Security Group for SSH access
           TestSecurityGroup:
             Type: AWS::EC2::SecurityGroup
             Properties:
               GroupName: AWS-DevOpsAgent-test-sg
               GroupDescription: AWS DevOps Agent beta testing security group
               SecurityGroupIngress:
                 - IpProtocol: tcp
                   FromPort: 22
                   ToPort: 22
                   CidrIp: !Ref MyIP
                   Description: SSH access from your IP
               Tags:
                 - Key: Name
                   Value: AWS-DevOpsAgent-Test-SG
                 - Key: Purpose
                   Value: AWS-DevOpsAgent-Testing
           # Key Pair for SSH access
           TestKeyPair:
             Type: AWS::EC2::KeyPair
             Properties:
               KeyName: AWS-DevOpsAgent-test-key
               KeyType: rsa
               Tags:
                 - Key: Name
                   Value: AWS-DevOpsAgent-Test-Key
                 - Key: Purpose
                   Value: AWS-DevOpsAgent-Testing
           # EC2 Instance for CPU testing
           TestInstance:
             Type: AWS::EC2::Instance
             Properties:
               InstanceType: t3.micro
               ImageId: '{{resolve:ssm:/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-6.1-x86_64}}'
               KeyName: !Ref TestKeyPair
               SecurityGroupIds:
                 - !Ref TestSecurityGroup
               UserData:
                 Fn::Base64: !Sub |
                   #!/bin/bash
                   yum update -y
                   yum install -y htop
                   
                   # Create the CPU stress test script
                   cat > /home/ec2-user/cpu-stress-test.sh << 'EOF'
                   #!/bin/bash
                   echo "Starting AWS DevOpsAgent CPU Stress Test"
                   echo "Time: $(date)"
                   echo "Instance: $(curl -s http://169.254.169.254/latest/meta-data/instance-id)"
                   echo ""
                   
                   # Get number of CPU cores
                   CORES=$(nproc)
                   echo "CPU Cores: $CORES"
                   echo ""
                   
                   echo "Starting stress test (5 minutes)..."
                   echo "This will generate >70% CPU usage to trigger CloudWatch alarm"
                   echo ""
                   
                   # Create CPU load using yes command
                   echo "Starting CPU load processes..."
                   for i in $(seq 1 $CORES); do
                       (yes > /dev/null) &
                       CPU_PID=$!
                       echo "Started CPU load process $i (PID: $CPU_PID)"
                       echo $CPU_PID >> /tmp/cpu_test_pids
                   done
                   
                   # Auto-cleanup after 5 minutes
                   (sleep 300 && echo "Stopping CPU load processes..." && kill $(cat /tmp/cpu_test_pids 2>/dev/null) 2>/dev/null && rm -f /tmp/cpu_test_pids) &
                   
                   echo ""
                   echo "CPU load processes started for 5 minutes"
                   echo "Check CloudWatch for alarm trigger in 3-5 minutes"
                   EOF
                   
                   chmod +x /home/ec2-user/cpu-stress-test.sh
                   chown ec2-user:ec2-user /home/ec2-user/cpu-stress-test.sh
                   
                   # Create auto-shutdown script (safety mechanism)
                   cat > /home/ec2-user/auto-shutdown.sh << 'SHUTDOWN_EOF'
                   #!/bin/bash
                   echo "Auto-shutdown scheduled for 2 hours from now: $(date)"
                   sleep 7200
                   echo "Auto-shutdown executing at: $(date)"
                   sudo shutdown -h now
                   SHUTDOWN_EOF
                   
                   chmod +x /home/ec2-user/auto-shutdown.sh
                   nohup /home/ec2-user/auto-shutdown.sh > /home/ec2-user/auto-shutdown.log 2>&1 &
                   
                   echo "AWS DevOpsAgent test setup completed at $(date)" > /home/ec2-user/setup-complete.txt
               Tags:
                 - Key: Name
                   Value: AWS-DevOpsAgent-Test-Instance
                 - Key: Purpose
                   Value: AWS-DevOpsAgent-Testing
           # CloudWatch Alarm for CPU utilization
           CPUAlarm:
             Type: AWS::CloudWatch::Alarm
             Properties:
               AlarmName: AWS-DevOpsAgent-EC2-CPU-Test
               AlarmDescription: AWS-DevOpsAgent beta test - EC2 CPU utilization alarm
               MetricName: CPUUtilization
               Namespace: AWS/EC2
               Statistic: Average
               Period: 60
               EvaluationPeriods: 1
               Threshold: 70
               ComparisonOperator: GreaterThanThreshold
               Dimensions:
                 - Name: InstanceId
                   Value: !Ref TestInstance
               TreatMissingData: notBreaching
         Outputs:
           InstanceId:
             Description: EC2 Instance ID for testing
             Value: !Ref TestInstance
           
           SecurityGroupId:
             Description: Security Group ID
             Value: !Ref TestSecurityGroup
             
           AlarmName:
             Description: CloudWatch Alarm Name
             Value: !Ref CPUAlarm
             
           SSHCommand:
             Description: SSH command to connect to instance
             Value: !Sub 'ssh -i "AWS-DevOpsAgent-test-key.pem" ec2-user@${TestInstance.PublicDnsName}'
         ```

   1. No CloudFormation console, selecione **Carregar um arquivo de modelo**

   1. Clique em **Escolher arquivo**

   1. Selecione o `AWS-DevOpsAgent-ec2-test.yaml` arquivo

   1. Clique em **Avançar**.

1. **Configurar pilha**:

   1. **Nome da pilha:** `AWS-DevOpsAgent-EC2-Test`

   1. **Parâmetros:**

      1. **MyIP**: deixe como padrão `0.0.0.0/0` (você pode protegê-lo mais tarde, se necessário)

   1. Clique em **Avançar**.

1. **Configure as opções de pilha:**

   1. **Deixe os padrões, clique em Avançar**

1. **Revisar e criar**:

   1. Verifique, **reconheço que isso AWS CloudFormation pode criar recursos do IAM**

   1. Clique em **Enviar**

1. **Aguarde a conclusão**:

   1. A criação da pilha leva de 3 a 5 minutos

   1. O status mudará de `CREATE_IN_PROGRESS` para `CREATE_COMPLETE`

   1. **Importante**: Sua instância do EC2 agora faz parte de uma CloudFormation pilha que AWS DevOpsAgent pode ser rastreada\$1

#### Opcional: acesso SSH seguro (somente se você planeja se conectar à instância)
<a name="optional-secure-ssh-access-only-if-you-plan-to-connect-to-the-instance"></a>

Ignore esta etapa se você quiser apenas executar o teste automatizado

1. **Navegue até os grupos de segurança do EC2**:

   1. No AWS Console, acesse **EC2** → **Security** Groups

   1. Encontre `AWS-DevOpsAgent-test-sg`

1. **Atualize a regra SSH**:

   1. Selecione o grupo de segurança → guia **Regras de entrada** → **Editar regras de entrada**

   1. Encontre a regra SSH (porta 22)

   1. Altere a fonte de `0.0.0.0/0` para seu IP: `[YOUR_IP]/32`

   1. Obtenha seu IP de [https://whatismyipaddress.com](https://whatismyipaddress.com/)

   1. Clique em **Salvar regras**

### Etapa 2: Aguarde a execução automática do teste
<a name="step-2-wait-for-automatic-test-execution"></a>

1. **Execução automática de testes**:
   + O teste de estresse da CPU será **iniciado automaticamente 5 minutos** após a inicialização da instância
   + Nenhuma intervenção manual é necessária - basta esperar, o teste é executado completamente em segundo plano

1. **Monitore o teste**:
   + A instância inicializa e prepara o teste automaticamente
   + O script será executado por 5 minutos e gerará > 70% de uso da CPU
   + CloudWatch o alarme deve ser acionado dentro de 8 a 10 minutos no total (5 min de atraso \$1 3-5 min para alarme)

1. **Opcional: nova execução manual** (para testes adicionais):
   + Conecte-se à sua instância: console EC2 → → **Connect `AWS-DevOpsAgent-Test-Instance`** → **Session Manager**
   + Execute o teste de estresse novamente: `./cpu-stress-test.sh`
   + Perfeito para testar AWS DevOpsAgent a resposta várias vezes

## Opção de teste B: teste de taxa de erro Lambda
<a name="test-option-b-lambda-error-rate-test"></a>

### Etapa 1: implantar a CloudFormation pilha para o teste Lambda
<a name="step-1-deploy-cloudformation-stack-for-lambda-test"></a>

1. **Navegue até CloudFormation**:

   1. No AWS Console, acesse **CloudFormation**

   1. Clique em **Criar pilha** → **Com novos recursos (padrão)**

1. **Carregar modelo**:

   1. Crie um novo arquivo local chamado `AWS-DevOpsAgent-lambda-test.yaml`

   1. Copie e cole esse CloudFormation modelo no arquivo:

      1. 

         ```
         AWSTemplateFormatVersion: '2010-09-09'
         Description: 'AWS DevOpsAgent Lambda Error Test Stack'
         Resources:
           # IAM Role for Lambda function
           LambdaExecutionRole:
             Type: AWS::IAM::Role
             Properties:
               RoleName: AWS-DevOpsAgentLambdaTestRole
               AssumeRolePolicyDocument:
                 Version: '2012-10-17'
                 Statement:
                   - Effect: Allow
                     Principal:
                       Service: lambda.amazonaws.com
                     Action: sts:AssumeRole
               ManagedPolicyArns:
                 - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
               Tags:
                 - Key: Name
                   Value: AWS-DevOpsAgent-Lambda-Test-Role
                 - Key: Purpose
                   Value: AWS-DevOpsAgent-Testing
           # Lambda function that generates errors
           TestLambdaFunction:
             Type: AWS::Lambda::Function
             Properties:
               FunctionName: AWS-DevOpsAgent-test-lambda
               Runtime: python3.12
               Handler: index.lambda_handler
               Role: !GetAtt LambdaExecutionRole.Arn
               Code:
                 ZipFile: |
                   import json
                   import random
                   import time
                   from datetime import datetime
                   def lambda_handler(event, context):
                       print(f"AWS DevOpsAgent Test Lambda - {datetime.now()}")
                       print(f"Event: {json.dumps(event)}")
                       
                       # Intentionally generate errors for testing
                       error_scenarios = [
                           "Simulated database connection timeout",
                           "Test API rate limit exceeded", 
                           "Intentional validation error for AWS DevOpsAgent testing"
                       ]
                       
                       # Always throw an error for testing purposes
                       error_message = random.choice(error_scenarios)
                       print(f"Generating test error: {error_message}")
                       
                       # This will create a Lambda error that CloudWatch will detect
                       raise Exception(f"AWS DevOpsAgent Test Error: {error_message}")
               Description: AWS DevOpsAgent beta test function - intentionally generates errors
               Timeout: 30
               Tags:
                 - Key: Name
                   Value: AWS-DevOpsAgent-Test-Lambda
                 - Key: Purpose
                   Value: AWS-DevOpsAgent-Testing
           # CloudWatch Alarm for Lambda errors
           LambdaErrorAlarm:
             Type: AWS::CloudWatch::Alarm
             Properties:
               AlarmName: AWS-DevOpsAgent-Lambda-Error-Test
               AlarmDescription: AWS-DevOpsAgent beta test - Lambda error rate alarm
               MetricName: Errors
               Namespace: AWS/Lambda
               Statistic: Sum
               Period: 60
               EvaluationPeriods: 1
               Threshold: 0
               ComparisonOperator: GreaterThanThreshold
               Dimensions:
                 - Name: FunctionName
                   Value: !Ref TestLambdaFunction
               TreatMissingData: notBreaching
         Outputs:
           LambdaFunctionName:
             Description: Lambda Function Name for testing
             Value: !Ref TestLambdaFunction
             
           LambdaFunctionArn:
             Description: Lambda Function ARN
             Value: !GetAtt TestLambdaFunction.Arn
             
           AlarmName:
             Description: CloudWatch Alarm Name
             Value: !Ref LambdaErrorAlarm
             
           TestCommand:
             Description: AWS CLI command to test the function
             Value: !Sub 'aws lambda invoke --function-name ${TestLambdaFunction} --payload "{\"test\":\"AWS DevOpsAgent validation\"}" response.json'
         ```

   1. No CloudFormation console, selecione **Carregar um arquivo de modelo**

   1. Clique em **Escolher arquivo**

   1. Selecione o `AWS-DevOpsAgent-lambda-test.yaml` arquivo

   1. Clique em **Avançar**.

1. **Configurar pilha**:

   1. **Nome da pilha:** `AWS-DevOpsAgent-Lambda-Test`

   1. Clique em **Avançar**.

1. **Configure as opções de pilha:**

   1. **Deixe os padrões, clique em Avançar**

1. **Revisar e criar**:

   1. Verifique, **reconheço que isso AWS CloudFormation pode criar recursos do IAM**

   1. Clique em **Enviar**

1. **Aguarde a conclusão**:

   1. A criação da pilha leva de 2 a 3 minutos

   1. O status mudará para `CREATE_COMPLETE`

### Etapa 2: acionar erros do Lambda
<a name="step-2-trigger-lambda-errors"></a>

1. **Navegue até o console Lambda**:

   1. Vá para o console **AWS Lambda**

   1. Encontre sua função `AWS-DevOpsAgent-test-lambda`

1. **Teste a função**:

   1. Clique na guia **Teste**

   1. Clique em **Criar novo evento**

   1. **Nome do evento**: `AWS-DevOpsAgent-test-event`

   1. Use essa carga JSON:

      1. 

         ```
         {
         "test": "AWS DevOpsAgent validation",
         "timestamp": "2024-01-01T00:00:00Z"
         }
         ```

   1. Clique em **Salvar**

1. **Gere erros**:

   1. Clique no botão **Testar** 3 vezes (aguarde 10 segundos entre cada uma)

   1. Cada teste gerará um erro intencional

   1. CloudWatch o **alarme** deve ser acionado dentro de 2-3 minutos

   1. **AWS DevOpsAgent**agora deve ser capaz de detectar o alarme com uma **investigação** no **aplicativo Operator**, que você configurará a seguir.

## Validar a detecção AWS DevOps do agente
<a name="validate-aws-devops-agent-detection"></a>

### Etapa 1: CloudWatch alarmes de verificação de sanidade (opcional)
<a name="step-1-sanity-check-cloudwatch-alarms-optional"></a>

Esta etapa é para garantir que os testes acima estejam agora em um estado de alarme.

**Para o teste EC2:**
+ No CloudWatch console, acesse **Alarmes**
+ **Aguarde de 3 a 5 minutos** após iniciar o teste de estresse
+ Seu alarme deve aparecer **Em estado de alarme**
+ **Se ainda estiver “OK”**: aguarde mais 2 a 3 minutos (CloudWatch as métricas podem ser atrasadas)

**Para o Teste Lambda:**
+ Verifique o `AWS-DevOpsAgent-Lambda-Error-Test` alarme
+ Deve mostrar o **alarme** dentro de 2-3 minutos após a execução dos testes

### Etapa 2: iniciar uma investigação AWS DevOps do agente
<a name="step-2-start-a-aws-devops-agent-investigation"></a>

1. Abra seu **AWS DevOps agente AgentSpace**

1. Clique em **Acesso de administrador**. Isso abrirá o aplicativo web DevOps Agent Space em uma nova janela

1. Clique no botão **Iniciar investigação** no lado direito da tela

1. Preencha o seguinte formulário:

   1. **Detalhes da investigação:** descreva a investigação que você gostaria de realizar. Inclua todos os detalhes que puder sobre os objetivos da investigação, áreas a serem exploradas ou informações relevantes.

   1. **Ponto de partida da investigação**: descreva as informações a partir das quais você gostaria de iniciar a investigação. Você pode mencionar um alarme, uma métrica, um trecho de registro ou qualquer outra coisa para dar ao DevOps Agente um ponto de partida para trabalhar. Nesse caso, forneça um resumo dos alarmes que você acabou de criar.

   1. **Data e hora do incidente (de** preferência ISO 8601) ::MMZ YYYY-MM-DDTHH

   1. Dê um **nome à sua investigação:** exemplo: `Oncall_investigation_1:2025-10-27`

   1. **AWS ID da conta** do incidente

   1. **Região** onde o incidente ocorreu

   1. **Prioridade** - AWS DevOpsAgent permite duas investigações simultâneas. A Prioridade permite que você defina a ordem de execução de suas investigações.

1. Clique em Investigar para iniciar a investigação.

1. Clique na sua investigação listada no painel. Você será direcionado para a tela Detalhes da Investigação, onde poderá ver as etapas granulares que o DevOps Agente está realizando.

### Resultados esperados
<a name="expected-results"></a>

#### Resultados do teste EC2:
<a name="ec2-test-results"></a>
+ Detecta o alarme da CPU EC2
+ Identifica a causa raiz: “carga de trabalho do teste de estresse da CPU”
+ Mostra a linha do tempo: Teste de estresse → pico de CPU → Alarme
+ Fornece recomendações para monitoramento e escalabilidade

**Resultados do teste Lambda:**
+ Detecta o pico da taxa de erro do Lambda
+ Identifica a causa raiz: “Exceções de testes intencionais”
+ Mostra a linha do tempo: Invocações de funções → Erros → Alarme
+ Fornece recomendações para tratamento e monitoramento de erros

## Instruções de limpeza
<a name="cleanup-instructions"></a>

### Teste de limpeza A (teste EC2)
<a name="cleanup-test-a-ec2-test"></a>

#### Limpeza automática
<a name="automatic-cleanup"></a>
+ A instância será encerrada automaticamente após 2 horas ( CloudFormation incorporada ao modelo)

#### Limpeza manual (imediata)
<a name="manual-cleanup-immediate"></a>

1. **Excluir CloudFormation pilha**:

   1. Vá para o CloudFormation console

   1. Selecione a `AWS-DevOpsAgent-EC2-Test` pilha

   1. Clique em **Excluir**

   1. Confirme a exclusão

   1. **Isso excluirá automaticamente todos os recursos**: instância do EC2, grupo de segurança, key pair e alarme CloudWatch 

### Teste de limpeza B (teste Lambda)
<a name="cleanup-test-b-lambda-test"></a>

1. **Excluir CloudFormation pilha**:

   1. Vá para o CloudFormation console

   1. Selecione a `AWS-DevOpsAgent-Lambda-Test` pilha

   1. Clique em **Excluir**

   1. Confirme a exclusão

   1. **Isso excluirá automaticamente todos os recursos**: função Lambda, função do IAM e alarme CloudWatch 

## Solução de problemas
<a name="troubleshooting"></a>

### Problemas comuns
<a name="common-issues"></a>

#### “Não é possível se conectar à instância do EC2”
<a name="cant-connect-to-ec2-instance"></a>
+ **Verifique o grupo de segurança**: verifique se o SSH (porta 22) está aberto para o seu IP
+ **Verifique as principais permissões**: Executar `chmod 400 AWS-DevOpsAgent-test-key.pem`
+ **Verifique o IP público**: a instância deve ter um IP público atribuído
+ **Aguarde a instância**: verifique se a instância está no estado “Executando”

#### “O alarme não está sendo acionado”
<a name="alarm-not-triggering"></a>
+ **Aguarde as métricas**: CloudWatch as métricas podem levar de 2 a 5 minutos para aparecer
+ **Verifique a carga da CPU**: SSH para a instância e execute `top` para verificar a CPU > 70%
+ **Verifique o teste de estresse**: execute `ps aux | grep yes` para ver se os processos de carregamento estão em execução
+ **Espera prolongada**: às vezes, leva de 7 a 8 minutos para o primeiro acionamento do alarme

## Validação de testes
<a name="test-validation"></a>

Seu teste de AWS DevOp agente é bem-sucedido quando:

### Validação técnica
<a name="technical-validation"></a>
+ **Precisão da investigação**: Os resultados do teste EC2 devem indicar corretamente que o alarme foi acionado devido à carga da CPU. O resultado do teste Lambda deve indicar que se tratou de uma falha intencional.
+ **Precisão do cronograma**: sequência correta de eventos mostrados
+ **Qualidade da recomendação**: sugestões práticas fornecidas

# Introdução ao AWS DevOps Agent usando o AWS CDK
<a name="getting-started-with-aws-devops-agent-getting-started-with-aws-devops-agent-using-aws-cdk"></a>

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

Este guia mostra como usar o AWS Cloud Development Kit (AWS CDK) para criar e implantar recursos do AWS DevOps Agente. O aplicativo AWS CDK automatiza a criação de um espaço de agente, funções de AWS Identity and Access Management (IAM), um aplicativo de operador e associações de contas por meio de. AWS AWS CloudFormation

A abordagem AWS CDK automatiza as etapas manuais descritas no [guia de integração da CLI](https://docs.aws.amazon.com/devopsagent/latest/userguide/getting-started-with-aws-devops-agent-cli-onboarding-guide.html), definindo todos os recursos necessários como infraestrutura como código.

AWS DevOps O agente está disponível nas seguintes 6 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 Interface de linha de comando (AWS CLI) instalada e configurada com as credenciais apropriadas
+ Node.js, versão 18 ou versões posteriores
+ AWS Interface de linha de comando (CLI) do CDK instalada globalmente. Para instalar a CLI do AWS CDK, execute o seguinte comando:

```
npm install -g aws-cdk
```
+ Uma AWS conta para a conta de monitoramento (primária)
+ (Opcional) Uma segunda AWS conta se você quiser configurar o monitoramento entre contas

## O que este guia aborda
<a name="what-this-guide-covers"></a>

Este guia está dividido em duas partes:
+ **Parte 1** — Implante um espaço de agente com um aplicativo de operador e uma AWS associação em sua conta de monitoramento. Depois de concluir essa parte, o agente pode monitorar problemas nessa conta.
+ **Parte 2 (opcional)** — Adicione uma AWS associação de origem para uma conta de serviço e implante uma função do IAM entre contas nessa conta. Essa configuração permite que o espaço do agente monitore recursos em todas as contas.

## Recursos criados
<a name="resources-created"></a>

### Parte 1: DevOpsAgentStack (conta de monitoramento)
<a name="part-1-devopsagentstack-monitoring-account"></a>
+ **Função do IAM** (`DevOpsAgentRole-AgentSpace`) — assumida pelo serviço do DevOps agente para monitorar a conta. Inclui a política `AIDevOpsAgentAccessPolicy` gerenciada e uma política em linha que permite a criação da função vinculada ao serviço Resource Explorer.
+ **Função do IAM** (`DevOpsAgentRole-WebappAdmin`) — Função do aplicativo operador com a política `AIDevOpsOperatorAppAccessPolicy` gerenciada para operações do agente.
+ **Espaço do agente** (`MyCDKAgentSpace`) — O espaço do agente central, criado usando o `AWS::DevOpsAgent::AgentSpace` CloudFormation recurso. Inclui a configuração do aplicativo do operador.
+ **Associação** (AWS monitor) — vincula a conta de monitoramento ao espaço do agente usando o `AWS::DevOpsAgent::Association` CloudFormation recurso.
+ **Associação** (AWS fonte) — (Opcional) Vincula a conta de serviço ao espaço do agente para monitoramento entre contas.

### Parte 2: ServiceStack (conta de serviço, opcional)
<a name="part-2-servicestack-service-account-optional"></a>
+ **Função do IAM** (`DevOpsAgentRole-SecondaryAccount`) — Função entre contas com um nome fixo. Confiável pelo espaço do agente na conta de monitoramento. Inclui a política `AIDevOpsAgentAccessPolicy` gerenciada e uma política em linha que permite a criação da função vinculada ao serviço Resource Explorer.
+ **Função Lambda** (`echo-service`) — Um exemplo simples de serviço que reflete eventos de entrada.

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

### Etapa 1: clonar o repositório de amostra
<a name="step-1-clone-the-sample-repository"></a>

Execute os comandos a seguir para clonar o repositório e mudar para o diretório do projeto:

```
git clone https://github.com/aws-samples/sample-aws-devops-agent-cdk.git
cd sample-aws-devops-agent-cdk
```

### Etapa 2: instalar dependências
<a name="step-2-install-dependencies"></a>

Execute o comando a seguir para instalar as dependências do projeto:

```
npm install
```

## Parte 1: Implantar o espaço do agente
<a name="part-1-deploy-the-agent-space"></a>

Nesta seção, você cria o espaço do agente, as funções do IAM, o aplicativo do operador e uma AWS associação na sua conta de monitoramento.

### Etapa 1: configurar o ID da conta de monitoramento
<a name="step-1-configure-the-monitoring-account-id"></a>

Abra `lib/constants.ts` e defina o ID da sua conta de monitoramento:

O exemplo a seguir mostra a constante a ser atualizada:

```
export const MONITORING_ACCOUNT_ID = "<YOUR_MONITORING_ACCOUNT_ID>";
```

### Etapa 2: Inicializar o ambiente AWS CDK
<a name="step-2-bootstrap-the-aws-cdk-environment"></a>

Se você não inicializou o AWS CDK em sua conta de monitoramento, execute o seguinte comando:

```
cdk bootstrap aws://<MONITORING_ACCOUNT_ID>/<REGION> --profile monitoring
```

### Etapa 3: criar e implantar
<a name="step-3-build-and-deploy"></a>

Execute os comandos a seguir para criar o TypeScript código e implantar a pilha:

```
npm run build
cdk deploy DevOpsAgentStack --profile monitoring
```

### Etapa 4: Grave as saídas da pilha
<a name="step-4-record-the-stack-outputs"></a>

Após a conclusão da implantação, o AWS CDK imprime as saídas da pilha. Registre esses valores para uso posterior.

O exemplo a seguir mostra a saída esperada:

```
Outputs:
DevOpsAgentStack.AgentSpaceArn = arn:aws:aidevops:<REGION>:123456789012:agentspace/abc123
DevOpsAgentStack.AgentSpaceRoleArn = arn:aws:iam::123456789012:role/DevOpsAgentRole-AgentSpace
DevOpsAgentStack.OperatorRoleArn = arn:aws:iam::123456789012:role/DevOpsAgentRole-WebappAdmin
DevOpsAgentStack.AssociationId = assoc-xyz
```

Se você planeja concluir a Parte 2, salve o `AgentSpaceArn` valor. Você precisa dele para configurar a pilha de contas de serviço.

### Etapa 5: verificar a implantação
<a name="step-5-verify-the-deployment"></a>

Para verificar se o espaço do agente foi criado com êxito, execute o seguinte comando da AWS CLI:

```
aws devopsagent get-agent-space \
  --agent-space-id <AGENT_SPACE_ID> \
  --region <REGION>
```

Nesse ponto, seu espaço de agente é implantado com o aplicativo do operador ativado e sua conta de monitoramento associada. O agente pode monitorar problemas nessa conta.

## Parte 2 (opcional): adicionar monitoramento entre contas
<a name="part-2-optional-add-cross-account-monitoring"></a>

Nesta seção, você estende a configuração para que seu espaço de agente possa monitorar recursos em uma segunda AWS conta (a conta de serviço). Isso envolve duas ações:

1. Adicionar uma AWS associação de origem na DevOpsAgentStack que aponta para a conta de serviço.

1. Implantando o ServiceStack na conta de serviço com uma função do IAM que confia no espaço do agente.

**Importante**  
**Você deve concluir a Parte 1 antes de continuar. O ServiceStack requer o `AgentSpaceArn` da saída DevOpsAgentStack de implantação.

### Etapa 1: configurar o ID da conta de serviço
<a name="step-1-configure-the-service-account-id"></a>

Abra `lib/constants.ts` e defina o ID da sua conta de serviço:

O exemplo a seguir mostra a constante a ser atualizada:

```
export const SERVICE_ACCOUNT_ID = "<YOUR_SERVICE_ACCOUNT_ID>";
```

O DevOpsAgentStack cria uma AWS associação de origem usando esse ID de conta. Se você implantou o DevOpsAgentStack antes de definir esse valor, reimplante para criar a associação:

Execute os seguintes comandos para reimplantar:

```
npm run build
cdk deploy DevOpsAgentStack --profile monitoring
```

### Etapa 2: definir o ARN do espaço do agente
<a name="step-2-set-the-agent-space-arn"></a>

Copie o `AgentSpaceArn` valor da DevOpsAgentStack saída (Parte 1, Etapa 4) e defina-o em`lib/constants.ts`:

O exemplo a seguir mostra a constante a ser atualizada:

```
export const AGENT_SPACE_ARN = "arn:aws:aidevops:<REGION>:<MONITORING_ACCOUNT_ID>:agentspace/<SPACE_ID>";
```

O ServiceStack usa esse valor para definir o escopo da política de confiança na função de conta secundária. O só ServiceStack é sintetizado quando esse valor é definido.

### Etapa 3: inicializar a conta de serviço
<a name="step-3-bootstrap-the-service-account"></a>

Se você não inicializou o AWS CDK na sua conta de serviço, execute o seguinte comando:

```
cdk bootstrap aws://<SERVICE_ACCOUNT_ID>/<REGION> --profile service
```

### Etapa 4: implantar o ServiceStack
<a name="step-4-deploy-the-servicestack"></a>

Execute os comandos a seguir para criar e implantar o ServiceStack usando credenciais para a conta de serviço:

```
npm run build
cdk deploy ServiceStack --profile service
```

Isso cria os seguintes recursos na conta de serviço:
+ Uma função do IAM (`DevOpsAgentRole-SecondaryAccount`) que confia no espaço do agente na conta de monitoramento
+ Uma função echo Lambda `echo-service` () como um serviço de exemplo

### Etapa 5: verificar a implantação
<a name="step-5-verify-the-deployment"></a>

Para confirmar que a função Lambda foi implantada com sucesso, execute os seguintes comandos para testar o serviço echo:

```
aws lambda invoke \
  --function-name echo-service \
  --payload '{"test": "hello world"}' \
  --profile service \
  response.json
cat response.json
```

## Solução de problemas
<a name="troubleshooting"></a>

Esta seção descreve problemas comuns e como resolvê-los.

**CloudFormation tipo de recurso não encontrado**
+ Verifique se você está implantando em um[Regiões aceitas](about-aws-devops-agent-supported-regions.md).
+ Confirme se sua AWS CLI está configurada com as permissões apropriadas.

**Falha na criação da função do IAM**
+ Verifique se sua função de implantação tem permissões para criar funções do IAM.
+ Verifique se as condições da política de confiança correspondem ao ID da sua conta.

**A implantação entre contas falha com “Não foi possível assumir a função na conta de destino”**
+ Cada pilha deve ser implantada com credenciais para a conta de destino. Use o `--profile` sinalizador para especificar o perfil AWS CLI correto.
+ Verifique se o AWS CDK foi inicializado na conta de destino.

**Atrasos na propagação do IAM**
+ As mudanças de função do IAM podem levar alguns minutos para se propagar. Se a criação do espaço do agente falhar imediatamente após a criação da função, aguarde alguns minutos e reimplante.

## Limpeza
<a name="cleanup"></a>

Para remover todos os recursos, destrua as pilhas na ordem inversa.

Execute os seguintes comandos para destruir as pilhas:

```
# If you deployed the ServiceStack, destroy it first
cdk destroy ServiceStack --profile service
# Then destroy the DevOpsAgentStack
cdk destroy DevOpsAgentStack --profile monitoring
```

**Aviso:** essa ação exclui permanentemente o espaço do agente e todos os dados associados. Esta ação não pode ser desfeita. Certifique-se de ter feito backup de todas as informações importantes antes de continuar.

## Considerações sobre segurança
<a name="security-considerations"></a>
+ O aplicativo AWS CDK cria funções do IAM com políticas de confiança que só permitem que o responsável pelo `aidevops.amazonaws.com` serviço as assuma.
+ As políticas de confiança incluem condições que restringem o acesso à sua AWS conta específica e ao ARN do espaço do agente.
+ Todas as políticas seguem o princípio do menor privilégio. Analise e personalize as políticas do IAM com base nos requisitos de segurança da sua organização.
+ A função entre contas (`DevOpsAgentRole-SecondaryAccount`) usa um nome fixo e tem como escopo um ARN de espaço de agente específico.

## Próximas etapas
<a name="next-steps"></a>

Depois de implantar seu AWS DevOps agente usando o AWS CDK:

1. Saiba mais sobre a gama completa de recursos do DevOps Agente no [Guia do Usuário do AWS DevOps Agente](https://docs.aws.amazon.com/devopsagent/latest/userguide/).

1. Considere integrar a implantação do AWS CDK em seus CI/CD pipelines para gerenciamento automatizado da infraestrutura.

## Recursos adicionais do
<a name="additional-resources"></a>
+ [AWS DevOps Guia do usuário do agente](https://docs.aws.amazon.com/devopsagent/latest/userguide/)
+ [Exemplo de repositório CDK](https://github.com/aws-samples/sample-aws-devops-agent-cdk) no site GitHub 
+ [Guia de integração da CLI](https://docs.aws.amazon.com/devopsagent/latest/userguide/getting-started-with-aws-devops-agent-cli-onboarding-guide.html)

# Começando a usar o AWS DevOps Agent usando AWS CloudFormation
<a name="getting-started-with-aws-devops-agent-getting-started-with-aws-devops-agent-using-aws-cloudformation"></a>

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

Este guia mostra como usar AWS CloudFormation modelos para criar e implantar recursos do AWS DevOps Agente. Os modelos automatizam a criação de um espaço para agentes, funções de AWS Identity and Access Management (IAM), um aplicativo de operador e associações de AWS contas como infraestrutura como código.

A CloudFormation abordagem automatiza as etapas manuais descritas no guia de [integração da CLI](https://docs.aws.amazon.com/devopsagent/latest/userguide/getting-started-with-aws-devops-agent-cli-onboarding-guide.html) definindo todos os recursos necessários em modelos YAML declarativos.

AWS DevOps O agente está disponível nas seguintes 6 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 Interface de linha de comando (AWS CLI) instalada e configurada com as credenciais apropriadas
+ Permissões para criar funções e CloudFormation pilhas do IAM
+ Uma AWS conta para a conta de monitoramento (primária)
+ (Opcional) Uma segunda AWS conta se você quiser configurar o monitoramento entre contas

## O que este guia aborda
<a name="what-this-guide-covers"></a>

Este guia está dividido em duas partes:
+ **Parte 1** — Implante um espaço de agente com um aplicativo de operador e uma AWS associação em sua conta de monitoramento. Depois de concluir essa parte, o agente pode monitorar problemas nessa conta.
+ **Parte 2 (opcional)** — Implante uma função do IAM entre contas em uma conta secundária e adicione uma AWS associação de origem. Essa configuração permite que o espaço do agente monitore recursos em todas as contas.

## Parte 1: Implantar o espaço do agente
<a name="part-1-deploy-the-agent-space"></a>

Nesta seção, você cria um CloudFormation modelo que provisiona o espaço do agente, as funções do IAM, o aplicativo do operador e uma AWS associação na sua conta de monitoramento.

### Etapa 1: criar o CloudFormation modelo
<a name="step-1-create-the-cloudformation-template"></a>

Salve o modelo a seguir como`devops-agent-stack.yaml`:

```
AWSTemplateFormatVersion: '2010-09-09'
Description: AWS DevOps Agent - Agent Space with IAM roles, operator app, and AWS association

Parameters:
  AgentSpaceName:
    Type: String
    Default: MyCloudFormationAgentSpace
    Description: Name for the agent space
  AgentSpaceDescription:
    Type: String
    Default: Agent space deployed with CloudFormation
    Description: Description for the agent space

Resources:
  # IAM role assumed by the DevOps Agent service to monitor the account
  DevOpsAgentSpaceRole:
    Type: AWS::IAM::Role
    Properties:
      RoleName: DevOpsAgentRole-AgentSpace
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: aidevops.amazonaws.com
            Action: sts:AssumeRole
            Condition:
              StringEquals:
                aws:SourceAccount: !Ref AWS::AccountId
              ArnLike:
                aws:SourceArn: !Sub arn:aws:aidevops:${AWS::Region}:${AWS::AccountId}:agentspace/*
      ManagedPolicyArns:
        - arn:aws:iam::aws:policy/AIDevOpsAgentAccessPolicy
      Policies:
        - PolicyName: AllowCreateServiceLinkedRoles
          PolicyDocument:
            Version: '2012-10-17'
            Statement:
              - Sid: AllowCreateServiceLinkedRoles
                Effect: Allow
                Action:
                  - iam:CreateServiceLinkedRole
                Resource:
                  - !Sub arn:aws:iam::${AWS::AccountId}:role/aws-service-role/resource-explorer-2.amazonaws.com/AWSServiceRoleForResourceExplorer

  # IAM role for the operator app interface
  DevOpsOperatorRole:
    Type: AWS::IAM::Role
    Properties:
      RoleName: DevOpsAgentRole-WebappAdmin
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: aidevops.amazonaws.com
            Action:
              - sts:AssumeRole
              - sts:TagSession
            Condition:
              StringEquals:
                aws:SourceAccount: !Ref AWS::AccountId
              ArnLike:
                aws:SourceArn: !Sub arn:aws:aidevops:${AWS::Region}:${AWS::AccountId}:agentspace/*
      ManagedPolicyArns:
        - arn:aws:iam::aws:policy/AIDevOpsOperatorAppAccessPolicy

  # The agent space resource
  AgentSpace:
    Type: AWS::DevOpsAgent::AgentSpace
    DependsOn:
      - DevOpsAgentSpaceRole
      - DevOpsOperatorRole
    Properties:
      Name: !Ref AgentSpaceName
      Description: !Ref AgentSpaceDescription
      OperatorApp:
        Iam:
          OperatorAppRoleArn: !GetAtt DevOpsOperatorRole.Arn

  # Association linking the monitoring account to the agent space
  MonitorAssociation:
    Type: AWS::DevOpsAgent::Association
    Properties:
      AgentSpaceId: !GetAtt AgentSpace.AgentSpaceId
      ServiceId: aws
      Configuration:
        Aws:
          AssumableRoleArn: !GetAtt DevOpsAgentSpaceRole.Arn
          AccountId: !Ref AWS::AccountId
          AccountType: monitor

Outputs:
  AgentSpaceId:
    Description: The agent space ID
    Value: !GetAtt AgentSpace.AgentSpaceId
  AgentSpaceArn:
    Description: The agent space ARN
    Value: !GetAtt AgentSpace.Arn
  AgentSpaceRoleArn:
    Description: The agent space IAM role ARN
    Value: !GetAtt DevOpsAgentSpaceRole.Arn
  OperatorRoleArn:
    Description: The operator app IAM role ARN
    Value: !GetAtt DevOpsOperatorRole.Arn
```

### Etapa 2: implantar a pilha
<a name="step-2-deploy-the-stack"></a>

Execute o comando a seguir para implantar a pilha. `<REGION>`Substitua por um [Regiões aceitas](about-aws-devops-agent-supported-regions.md) (por exemplo,`us-east-1`).

```
aws cloudformation deploy \
  --template-file devops-agent-stack.yaml \
  --stack-name DevOpsAgentStack \
  --capabilities CAPABILITY_NAMED_IAM \
  --region <REGION>
```

### Etapa 3: Grave as saídas da pilha
<a name="step-3-record-the-stack-outputs"></a>

Após a conclusão da implantação, execute o comando a seguir para recuperar as saídas da pilha. Registre esses valores para uso posterior.

```
aws cloudformation describe-stacks \
  --stack-name DevOpsAgentStack \
  --query 'Stacks[0].Outputs' \
  --region <REGION>
```

O exemplo a seguir mostra a saída esperada:

```
[
  {
    "OutputKey": "AgentSpaceId",
    "OutputValue": "abc123def456"
  },
  {
    "OutputKey": "AgentSpaceArn",
    "OutputValue": "arn:aws:aidevops:<REGION>:<ACCOUNT_ID>:agentspace/abc123def456"
  },
  {
    "OutputKey": "AgentSpaceRoleArn",
    "OutputValue": "arn:aws:iam::<ACCOUNT_ID>:role/DevOpsAgentRole-AgentSpace"
  },
  {
    "OutputKey": "OperatorRoleArn",
    "OutputValue": "arn:aws:iam::<ACCOUNT_ID>:role/DevOpsAgentRole-WebappAdmin"
  }
]
```

Se você planeja concluir a Parte 2, salve o `AgentSpaceArn` valor. Você precisa dele para configurar a função entre contas.

### Etapa 4: Verificar a implantação
<a name="step-4-verify-the-deployment"></a>

Para verificar se o espaço do agente foi criado com êxito, execute o seguinte comando da AWS CLI:

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

Nesse ponto, seu espaço de agente é implantado com o aplicativo do operador ativado e sua conta de monitoramento associada. O agente pode monitorar problemas nessa conta.

## Parte 2 (opcional): adicionar monitoramento entre contas
<a name="part-2-optional-add-cross-account-monitoring"></a>

Nesta seção, você estende a configuração para que seu espaço de agente possa monitorar recursos em uma segunda AWS conta (a conta de serviço). Isso envolve duas ações:

1. Implantação de uma função do IAM na conta de serviço que confia no espaço do agente.

1. Adicionar uma AWS associação de origem na conta de monitoramento que aponta para a conta de serviço.

**Nota:** Você deve concluir a Parte 1 antes de continuar. O modelo de conta de serviço exige as saídas `AgentSpaceArn` da pilha da Parte 1.

### Etapa 1: criar o modelo de conta de serviço
<a name="step-1-create-the-service-account-template"></a>

Salve o modelo a seguir como`devops-agent-service-account.yaml`. Esse modelo cria uma função do IAM entre contas na conta secundária.

```
AWSTemplateFormatVersion: '2010-09-09'
Description: AWS DevOps Agent - Cross-account IAM role for secondary account monitoring

Parameters:
  MonitoringAccountId:
    Type: String
    Description: The 12-digit AWS account ID of the monitoring account
  AgentSpaceArn:
    Type: String
    Description: The ARN of the agent space from the monitoring account

Resources:
  # Cross-account IAM role trusted by the agent space
  DevOpsSecondaryAccountRole:
    Type: AWS::IAM::Role
    Properties:
      RoleName: DevOpsAgentRole-SecondaryAccount
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: aidevops.amazonaws.com
            Action: sts:AssumeRole
            Condition:
              StringEquals:
                aws:SourceAccount: !Ref MonitoringAccountId
              ArnLike:
                aws:SourceArn: !Ref AgentSpaceArn
      ManagedPolicyArns:
        - arn:aws:iam::aws:policy/AIDevOpsAgentAccessPolicy
      Policies:
        - PolicyName: AllowCreateServiceLinkedRoles
          PolicyDocument:
            Version: '2012-10-17'
            Statement:
              - Sid: AllowCreateServiceLinkedRoles
                Effect: Allow
                Action:
                  - iam:CreateServiceLinkedRole
                Resource:
                  - !Sub arn:aws:iam::${AWS::AccountId}:role/aws-service-role/resource-explorer-2.amazonaws.com/AWSServiceRoleForResourceExplorer

Outputs:
  SecondaryAccountRoleArn:
    Description: The cross-account IAM role ARN
    Value: !GetAtt DevOpsSecondaryAccountRole.Arn
```

### Etapa 2: implantar a pilha de contas de serviço
<a name="step-2-deploy-the-service-account-stack"></a>

Usando as credenciais da conta de serviço, execute o seguinte comando:

```
aws cloudformation deploy \
  --template-file devops-agent-service-account.yaml \
  --stack-name DevOpsAgentServiceAccountStack \
  --capabilities CAPABILITY_NAMED_IAM \
  --parameter-overrides \
    MonitoringAccountId=<MONITORING_ACCOUNT_ID> \
    AgentSpaceArn=<AGENT_SPACE_ARN> \
  --region <REGION>
```

### Etapa 3: Adicionar a AWS associação de origem
<a name="step-3-add-the-source-aws-association"></a>

Volte para a conta de monitoramento e crie uma AWS associação de origem. Você pode fazer isso criando uma pilha separada ou atualizando o modelo original. O exemplo a seguir usa um modelo independente.

Salve o modelo a seguir como`devops-agent-source-association.yaml`:

```
AWSTemplateFormatVersion: '2010-09-09'
Description: AWS DevOps Agent - Source AWS association for cross-account monitoring

Parameters:
  AgentSpaceId:
    Type: String
    Description: The agent space ID from the monitoring account stack
  ServiceAccountId:
    Type: String
    Description: The 12-digit AWS account ID of the service account
  ServiceAccountRoleArn:
    Type: String
    Description: The ARN of the DevOpsAgentRole-SecondaryAccount role in the service account

Resources:
  SourceAssociation:
    Type: AWS::DevOpsAgent::Association
    Properties:
      AgentSpaceId: !Ref AgentSpaceId
      ServiceId: aws
      Configuration:
        SourceAws:
          AccountId: !Ref ServiceAccountId
          AccountType: source
          AssumableRoleArn: !Ref ServiceAccountRoleArn

Outputs:
  SourceAssociationId:
    Description: The source association ID
    Value: !Ref SourceAssociation
```

Implante a pilha de associações usando as credenciais da conta de monitoramento:

```
aws cloudformation deploy \
  --template-file devops-agent-source-association.yaml \
  --stack-name DevOpsAgentSourceAssociationStack \
  --parameter-overrides \
    AgentSpaceId=<AGENT_SPACE_ID> \
    ServiceAccountId=<SERVICE_ACCOUNT_ID> \
    ServiceAccountRoleArn=arn:aws:iam::<SERVICE_ACCOUNT_ID>:role/DevOpsAgentRole-SecondaryAccount \
  --region <REGION>
```

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

Verifique sua configuração executando os seguintes comandos da AWS CLI:

```
# 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>
```

## Solução de problemas
<a name="troubleshooting"></a>

Esta seção descreve problemas comuns e como resolvê-los.

**CloudFormation tipo de recurso não encontrado**
+ Verifique se você está implantando em um[Regiões aceitas](about-aws-devops-agent-supported-regions.md).
+ Confirme se sua AWS CLI está configurada com as permissões apropriadas.

**Falha na criação da função do IAM**
+ Verifique se suas credenciais de implantação têm permissões para criar funções do IAM com nomes personalizados (`CAPABILITY_NAMED_IAM`).
+ Verifique se as condições da política de confiança correspondem ao ID da sua conta.

**Falha na implantação entre contas**
+ Cada pilha deve ser implantada com credenciais para a conta de destino. Use o `--profile` sinalizador para especificar o perfil AWS CLI correto.
+ Verifique se o `AgentSpaceArn` parâmetro corresponde ao ARN exato das saídas da pilha da Parte 1.

**Atrasos na propagação do IAM**
+ As mudanças de função do IAM podem levar alguns minutos para se propagar. Se a criação do espaço do agente falhar imediatamente após a criação da função, aguarde alguns minutos e reimplante.

## Limpeza
<a name="cleanup"></a>

Para remover todos os recursos, exclua as pilhas na ordem inversa.

**Aviso:** essa ação exclui permanentemente o espaço do seu agente e todos os dados associados. Esta ação não pode ser desfeita. Certifique-se de ter feito backup de todas as informações importantes antes de continuar.

Execute os seguintes comandos para excluir as pilhas:

```
# If you deployed the source association stack, delete it first
aws cloudformation delete-stack \
  --stack-name DevOpsAgentSourceAssociationStack \
  --region <REGION>

aws cloudformation wait stack-delete-complete \
  --stack-name DevOpsAgentSourceAssociationStack \
  --region <REGION>

# If you deployed the service account stack, delete it next (using service account credentials)
aws cloudformation delete-stack \
  --stack-name DevOpsAgentServiceAccountStack \
  --region <REGION>

aws cloudformation wait stack-delete-complete \
  --stack-name DevOpsAgentServiceAccountStack \
  --region <REGION>

# Delete the main stack last
aws cloudformation delete-stack \
  --stack-name DevOpsAgentStack \
  --region <REGION>
```

## Próximas etapas
<a name="next-steps"></a>

Depois de implantar seu AWS DevOps agente usando AWS CloudFormation:
+ 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).

# Introdução ao AWS DevOps Agent usando o Terraform
<a name="getting-started-with-aws-devops-agent-getting-started-with-aws-devops-agent-using-terraform"></a>

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

Este guia mostra como usar o Terraform para criar e implantar recursos do AWS DevOps Agente. A configuração do Terraform automatiza a criação de um espaço de agente, funções do IAM, um aplicativo de operador e associações de AWS contas.

A abordagem do Terraform automatiza as etapas manuais descritas no [guia de integração da CLI](https://docs.aws.amazon.com/devopsagent/latest/userguide/getting-started-with-aws-devops-agent-cli-onboarding-guide.html), definindo todos os recursos necessários como infraestrutura como código.

AWS DevOps O agente está disponível nas seguintes 6 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, você deve ter o seguinte:
+ Terraform >= 1.0 instalado
+ AWS CLI instalada e configurada com as credenciais apropriadas
+ Uma AWS conta para a conta de monitoramento (primária)
+ (Opcional) Uma segunda AWS conta se você quiser configurar o monitoramento entre contas

## O que este guia aborda
<a name="what-this-guide-covers"></a>

Este guia está dividido em duas partes:
+ **Parte 1** — Implante um espaço de agente com um aplicativo de operador e uma AWS associação em sua conta de monitoramento. Depois de concluir essa parte, o agente pode monitorar problemas nessa conta.
+ **Parte 2 (opcional)** — Adicione uma AWS associação de origem para uma conta de serviço e implante uma função do IAM entre contas, além de um echo Lambda nessa conta. Isso permite que o espaço do agente monitore os recursos em todas as contas.

## Recursos criados
<a name="resources-created"></a>

### Parte 1: Conta de monitoramento
<a name="part-1-monitoring-account"></a>
+ **Função do IAM** (`DevOpsAgentRole-AgentSpace-*`) — assumida pelo serviço do DevOps agente para monitorar a conta. Inclui a política `AIDevOpsAgentAccessPolicy` gerenciada e uma política em linha que permite a criação da função vinculada ao serviço Resource Explorer.
+ **Função do IAM** (`DevOpsAgentRole-WebappAdmin-*`) — Função do aplicativo operador com a política `AIDevOpsOperatorAppAccessPolicy` gerenciada para operações do agente.
+ **Espaço do agente** (nome configurável) — O espaço do agente central, criado usando o `awscc_devopsagent_agent_space` recurso. Inclui a configuração do aplicativo do operador.
+ **Associação** (AWS monitor) — vincula a conta de monitoramento ao espaço do agente usando o `awscc_devopsagent_association` recurso.
+ **Associação** (AWS fonte) — (Opcional) Vincula a conta de serviço ao espaço do agente para monitoramento entre contas.

### Parte 2: Conta de serviço (opcional)
<a name="part-2-service-account-optional"></a>
+ **Função do IAM** (`DevOpsAgentRole-SecondaryAccount-TF`) — Função entre contas com um nome fixo. Confiável pelo espaço do agente na conta de monitoramento. Inclui a política `AIDevOpsAgentAccessPolicy` gerenciada e uma política em linha que permite a criação da função vinculada ao serviço Resource Explorer.
+ **Função Lambda** (`echo-service-tf`) — Um exemplo simples de serviço que reflete eventos de entrada.

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

### Etapa 1: clonar o repositório de amostra
<a name="step-1-clone-the-sample-repository"></a>

```
git clone https://github.com/aws-samples/sample-aws-devops-agent-terraform.git
cd sample-aws-devops-agent-terraform
```

### Etapa 2: configurar variáveis
<a name="step-2-configure-variables"></a>

Copie o arquivo de variáveis de exemplo e personalize-o para seu ambiente:

```
cp terraform.tfvars.example terraform.tfvars
```

Edite `terraform.tfvars` com o nome e a descrição do seu espaço de agente:

```
agent_space_name        = "MyCompanyAgentSpace"
agent_space_description = "DevOps Agent Space for monitoring production workloads"
```

## Parte 1: Implantar o espaço do agente
<a name="part-1-deploy-the-agent-space"></a>

Nesta seção, você cria o espaço do agente, as funções do IAM, o aplicativo do operador e uma AWS associação na sua conta de monitoramento.

### Etapa 1: implantar com automação (recomendado)
<a name="step-1-deploy-with-automation-recommended"></a>

Use o script de implantação fornecido para uma configuração simplificada:

```
./deploy.sh
```

Esse script automaticamente:
+ Verifica os pré-requisitos (Terraform, AWS CLI, credenciais)
+ Cria `terraform.tfvars` a partir do exemplo, se necessário
+ Inicializa, valida, planeja e aplica o Terraform

Como alternativa, se você preferir o controle manual:

```
terraform init
terraform plan
terraform apply
```

Digite `yes` quando solicitado para confirmar a implantação.

### Etapa 2: Grave as saídas
<a name="step-2-record-the-outputs"></a>

Após a conclusão da implantação, o Terraform imprime as saídas. Registre esses valores para uso posterior:

```
Outputs:
agent_space_id              = "abc123"
agent_space_arn             = "arn:aws:aidevops:<REGION>:<MONITORING_ACCOUNT_ID>:agentspace/abc123"
agent_space_name            = "MyCompanyAgentSpace"
devops_agentspace_role_arn  = "arn:aws:iam::<MONITORING_ACCOUNT_ID>:role/DevOpsAgentRole-AgentSpace-a1b2c3d4"
devops_operator_role_arn    = "arn:aws:iam::<MONITORING_ACCOUNT_ID>:role/DevOpsAgentRole-WebappAdmin-a1b2c3d4"
primary_account_id          = "<MONITORING_ACCOUNT_ID>"
primary_account_association_id = "assoc-xyz"
```

Se você planeja concluir a Parte 2, salve o `agent_space_arn` valor. Você precisará dele para configurar os recursos da conta de serviço.

### Etapa 3: verificar a implantação
<a name="step-3-verify-the-deployment"></a>

Execute o script de verificação pós-implantação:

```
./post-deploy.sh
```

Ou use a AWS CLI para verificar se o espaço do agente foi criado com êxito:

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

Nesse ponto, seu espaço de agente é implantado com o aplicativo do operador ativado e sua conta de monitoramento associada. O agente pode monitorar problemas nessa conta.

## Parte 2 (opcional): adicionar monitoramento entre contas
<a name="part-2-optional-add-cross-account-monitoring"></a>

Nesta seção, você estende a configuração para que o espaço do agente possa monitorar recursos em uma segunda AWS conta (a conta de serviço). Isso envolve duas ações:

1. Adicionar uma AWS associação de origem que aponta para a conta de serviço.

1. Implantação de uma função IAM entre contas e uma função echo Lambda na conta de serviço.

**Importante**  
**Você deve concluir a Parte 1 antes de continuar. Os recursos da conta de serviço exigem o resultado `agent_space_arn` da implantação da Parte 1.

### Etapa 1: configurar o ID da conta de serviço
<a name="step-1-configure-the-service-account-id"></a>

Em`terraform.tfvars`, defina o ID da sua conta de serviço:

```
service_account_id = "<YOUR_SERVICE_ACCOUNT_ID>"
```

### Etapa 2: definir o ARN do espaço do agente
<a name="step-2-set-the-agent-space-arn"></a>

Copie o `agent_space_arn` valor da saída da Parte 1 (Etapa 2) e defina-o em`terraform.tfvars`:

```
agent_space_arn = "arn:aws:aidevops:<REGION>:<MONITORING_ACCOUNT_ID>:agentspace/<SPACE_ID>"
```

Os recursos da conta de serviço usam esse valor para definir o escopo da política de confiança na função secundária da conta. Esses recursos são criados somente quando esse valor é definido.

### Etapa 3: configurar o provedor `aws.service`
<a name="step-3-configure-the-awsservice-provider"></a>

Em`main.tf`, configure o alias do `aws.service` provedor com as credenciais da conta de serviço. Você pode usar um perfil nomeado ou assumir uma função:

Usando um perfil:

```
provider "aws" {
  alias   = "service"
  region  = var.aws_region
  profile = "your-service-account-profile"
}
```

Ou usando assume a função:

```
provider "aws" {
  alias  = "service"
  region = var.aws_region
  assume_role {
    role_arn = "arn:aws:iam::<SERVICE_ACCOUNT_ID>:role/OrganizationAccountAccessRole"
  }
}
```

### Etapa 4: implantar
<a name="step-4-deploy"></a>

Aplique a configuração atualizada:

```
terraform apply
```

Isso cria os seguintes recursos na conta de serviço:
+ Uma função do IAM (`DevOpsAgentRole-SecondaryAccount-TF`) que confia no espaço do agente na conta de monitoramento
+ Uma função echo Lambda `echo-service-tf` () como um serviço de exemplo

Ele também cria uma AWS associação de origem na conta de monitoramento que vincula a conta de serviço.

### Etapa 5: verificar a implantação
<a name="step-5-verify-the-deployment"></a>

Teste o serviço echo para confirmar se a função Lambda foi implantada com sucesso:

```
aws lambda invoke \
  --function-name echo-service-tf \
  --payload '{"test": "hello world"}' \
  --profile <your-service-account-profile> \
  --region <REGION> \
  response.json
cat response.json
```

## Solução de problemas
<a name="troubleshooting"></a>

**Atrasos na propagação do IAM**
+ A configuração inclui 30 segundos `time_sleep` entre a criação da função do IAM e a criação do Agent Space. O serviço de DevOps agente valida a política de confiança da função de operador durante a criação do Agent Space, e isso pode falhar se o IAM não for totalmente propagado. Se você ainda encontrar erros na política de confiança, espere um minuto e execute `terraform apply` novamente. As funções do IAM já existirão e a aplicação continuará de onde parou.

**Erros de permissão**
+ Verifique se suas AWS credenciais têm as permissões necessárias do IAM para criar funções e políticas.
+ Verifique se as condições da política de confiança correspondem ao ID da sua conta.

**Falha na implantação entre contas**
+ O `aws.service` provedor deve ser configurado com as credenciais da conta de serviço. Use um perfil nomeado ou um bloco de assumir funções.
+ Verifique se o `agent_space_arn` valor corresponde ao ARN da saída da Parte 1.

**Tipo de recurso do Terraform não encontrado**
+ Verifique se você tem a versão do `awscc` provedor `~> 1.0` ou posterior. Os `awscc_devopsagent_association` recursos `awscc_devopsagent_agent_space` e exigem o provedor do AWS Cloud Control.

## Limpeza
<a name="cleanup"></a>

Para remover todos os recursos, destrua na ordem inversa se você implantou a Parte 2:

```
./cleanup.sh
```

Ou manualmente:

```
terraform destroy
```

**Aviso:** Isso exclui permanentemente seu espaço de agente e todos os dados associados. Certifique-se de ter feito backup de todas as informações importantes antes de continuar.

## Considerações sobre segurança
<a name="security-considerations"></a>
+ A configuração do Terraform cria funções do IAM com políticas de confiança que só permitem que o responsável pelo `aidevops.amazonaws.com` serviço as assuma.
+ As políticas de confiança incluem condições que restringem o acesso à sua AWS conta específica e ao ARN do espaço do agente.
+ Todas as políticas seguem o princípio do menor privilégio. Analise e personalize as políticas do IAM com base nos requisitos de segurança da sua organização.
+ A função entre contas (`DevOpsAgentRole-SecondaryAccount-TF`) usa um nome fixo e tem como escopo um ARN de espaço de agente específico.

## Próximas etapas
<a name="next-steps"></a>

Depois de implantar seu AWS DevOps agente usando o Terraform:

1. Saiba mais sobre a gama completa de recursos do DevOps Agente no [Guia do Usuário do AWS DevOps Agente](https://docs.aws.amazon.com/devopsagent/latest/userguide/).

1. Considere integrar a implantação do Terraform em seus CI/CD pipelines para gerenciamento automatizado da infraestrutura.

## Recursos adicionais do
<a name="additional-resources"></a>
+ [AWS DevOps Guia do usuário do agente](https://docs.aws.amazon.com/devopsagent/latest/userguide/)
+ [Exemplo de repositório Terraform](https://github.com/aws-samples/sample-aws-devops-agent-terraform)
+ [Guia de integração da CLI](https://docs.aws.amazon.com/devopsagent/latest/userguide/getting-started-with-aws-devops-agent-cli-onboarding-guide.html)