Descripción general de Requisitos previos Configuración de los roles de IAM Pasos de incorporación Verificación Siguientes pasos Notas

AWS DevOps Guía de incorporación de Agent CLI

Descripción general de

Con AWS DevOps Agent, puede monitorear y administrar su AWS infraestructura. Esta guía explica cómo configurar el AWS DevOps agente mediante la interfaz de línea de AWS comandos (AWS CLI). Puede crear funciones de IAM, configurar un espacio de agente y asociar su AWS cuenta. También habilitas la aplicación del operador y, de forma opcional, conectas integraciones de terceros. Esta guía tarda aproximadamente 20 minutos en completarse.

AWS DevOps El agente está disponible en seis AWS regiones: EE.UU. Este (Norte de Virginia), EE.UU. Oeste (Oregón), Asia Pacífico (Sídney), Asia Pacífico (Tokio), Europa (Fráncfort) y Europa (Irlanda). Para obtener más información sobre las regiones compatibles, consulteRegiones admitidas.

Requisitos previos

Antes de comenzar, asegúrese de que dispone de lo siguiente:

AWS CLI versión 2 instalada y configurada
Autenticación en su cuenta AWS de monitoreo
Permisos para crear AWS funciones de Identity and Access Management (IAM) y adjuntar políticas
Una AWS cuenta para usarla como cuenta de supervisión
Familiaridad con la sintaxis AWS CLI y JSON

A lo largo de esta guía, sustituya los siguientes valores de marcador de posición por los suyos propios:

<MONITORING_ACCOUNT_ID>— Su ID de AWS cuenta de 12 dígitos para la cuenta de monitoreo (principal)
<EXTERNAL_ACCOUNT_ID>— El ID de AWS cuenta de 12 dígitos de la cuenta secundaria que se va a monitorear (usado en el paso 4)
<REGION>— El código de AWS región de tu espacio de agente (por ejemplo, us-east-1 oeu-central-1)
<AGENT_SPACE_ID>— El identificador del espacio de agentes que devuelve el create-agent-space comando

Configuración de los roles de IAM

1. Cree el rol del espacio de DevOps agentes

Cree la política de confianza de IAM ejecutando el siguiente 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

Cree el rol de IAM:


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

Guarde el ARN del rol ejecutando el siguiente comando:


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

Adjunte la política AWS gestionada:


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

Cree y adjunte una política en línea para permitir la creación del rol vinculado al servicio 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. Cree el rol de IAM de la aplicación operadora

Cree la política de confianza de IAM ejecutando el siguiente 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

Cree el rol de IAM:


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

Guarde el ARN del rol ejecutando el siguiente comando:


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

Adjunte la política de la aplicación AWS gestionada por el operador:


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

Esta política gestionada concede a la aplicación del operador permisos para acceder a las funciones del espacio de agentes. Estas funciones incluyen investigaciones, recomendaciones, gestión del conocimiento, chat e integración de AWS Support. La política limita el acceso al espacio de agentes específico mediante el uso de la aws:PrincipalTag/AgentSpaceId condición. Para obtener más información sobre la lista completa de acciones, consulteDevOps Permisos de IAM para agentes.

Pasos de incorporación

1. Crea un espacio para agentes

Ejecute el siguiente comando para crear un espacio de agentes:


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

Si lo desea, especifique --kms-key-arn el uso de una clave AWS KMS administrada por el cliente para el cifrado. También puede utilizarla --tags para añadir etiquetas de recursos y --locale establecer el idioma de las respuestas de los agentes.

agentSpaceIdGuarde el contenido de la respuesta (ubicado enagentSpace.agentSpaceId).

Para enumerar los espacios de sus agentes más adelante, ejecute el siguiente comando:


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

2. Asocia tu AWS cuenta

Asocie su AWS cuenta para activar la detección de topología. accountTypeEstablézcalo en uno de los siguientes valores:

monitor— La cuenta principal en la que se encuentra el espacio de agentes. Esta cuenta aloja el agente y se utiliza para el descubrimiento de la topología.
source— Una cuenta adicional que el agente supervisa. Utilice este tipo cuando asocie cuentas externas en el paso 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. Habilita la aplicación del operador

Los flujos de autenticación pueden usar IAM, IAM Identity Center (IDC) o un proveedor de identidad externo (IdP). Ejecute el siguiente comando para habilitar la aplicación del operador en su espacio 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 la autenticación del Centro de Identidad de IAM, utilice --auth-flow idc y proporcione--idc-instance-arn. Para un proveedor de identidad externo, utilice --auth-flow idp y proporcione --issuer-url--idp-client-id, y--idp-client-secret. Para obtener más información, consulte Configuración de la autenticación de IAM Identity Center y Configuración de la autenticación de un proveedor de identidad externo (IdP).

4. (Opcional) Asocia cuentas de origen adicionales

Para supervisar cuentas adicionales con el AWS DevOps agente, cree un rol multicuenta de IAM.

Cree el rol multicuenta en la cuenta externa

Cambie a la cuenta externa y cree la política de confianza. MONITORING_ACCOUNT_IDEs la cuenta principal que aloja el espacio de agentes que configuró en el paso 2. Esta configuración permite que el servicio de AWS DevOps agente asuma una función en las cuentas de origen secundarias en nombre de la cuenta de supervisión.

Ejecute el siguiente comando para crear la política de confianza:


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

Cree el rol de IAM multicuenta:


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

Guarde el ARN del rol ejecutando el siguiente comando:


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

Adjunte la política AWS gestionada:


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

Adjunte la política en línea para permitir la creación del rol vinculado al servicio Resource Explorer en la cuenta 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

Asocie la cuenta externa

Vuelva a su cuenta de supervisión y, a continuación, ejecute el siguiente comando para asociar la cuenta 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) Asociar GitHub

Para obtener instrucciones sobre cómo registrarse GitHub a través de la consola, consulteConexión a CI/CD tuberías.

Enumere los servicios registrados:


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

Guarde el <SERVICE_ID> para ServiceType:. github

Tras registrarse GitHub en la consola, asocie los GitHub repositorios ejecutando el siguiente 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 y asocie ServiceNow

Primero, registre el ServiceNow servicio con OAuth las credenciales:


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>

Guarde lo devuelto y<SERVICE_ID>, a continuación, asocie 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 y asocie Dynatrace

Primero, registre el servicio Dynatrace con las credenciales: OAuth


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>

Guarde las devueltas y, a continuación<SERVICE_ID>, asocie Dynatrace. Los recursos son opcionales. El entorno especifica el entorno de Dynatrace al que se debe asociar.


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>

La respuesta incluye información sobre webhooks para la integración. Puedes usar este webhook para iniciar una investigación por parte de Dynatrace. Para obtener más información, consulte Conectando Dynatrace.

8. (Opcional) Registra y asocia Splunk

En primer lugar, registre el servicio de Splunk con BearerToken las credenciales.

El punto final utiliza el siguiente 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>

Guarde lo devuelto y<SERVICE_ID>, a continuación, asocie 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>

La respuesta incluye información sobre el webhook para la integración. Puedes usar este webhook para iniciar una investigación en Splunk. Para obtener más información, consulte Conexión de Splunk.

9. (Opcional) Registra y asocia New Relic

En primer lugar, registre el servicio New Relic con las credenciales clave de la API.

Región: cualquiera de las dosUS. EU

Campos opcionales: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>

Guarda lo devuelto y<SERVICE_ID>, a continuación, asocia 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>

La respuesta incluye información sobre el webhook para la integración. Puedes usar este webhook para iniciar una investigación desde New Relic. Para obtener más información, consulte Conectando New Relic.

10. (Opcional) Registre y asocie Datadog

Primero debe registrar Datadog a través de la consola del AWS DevOps agente mediante el OAuth flujo antes de poder asociarlo a través de la CLI. Para obtener más información, consulte Conectando DataDog.

Enumere los servicios registrados:


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

Guarde el <SERVICE_ID> para ServiceType:. mcpserverdatadog

Luego asocie 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>

La respuesta incluye información sobre el webhook para la integración. Puedes usar este webhook para iniciar una investigación desde Datadog. Para obtener más información, consulte Conectando DataDog.

11. (Opcional) Elimine un espacio de agente

Al eliminar un espacio de agentes, se eliminan todas las asociaciones, configuraciones y datos de investigación de ese espacio de agentes. Esta acción no se puede deshacer.

Para eliminar un espacio de agentes, ejecute el siguiente comando:


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

Verificación

Para comprobar la configuración, ejecute los siguientes 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>

Siguientes pasos

Para conectar integraciones adicionales, consulteConfiguración de las capacidades del AWS DevOps agente.
Para obtener información sobre las habilidades y capacidades de los agentes, consulteDevOps Habilidades de agente.
Para entender la aplicación web del operador, consulte¿Qué es una aplicación web para DevOps agentes?.

Notas

Sustituya <AGENT_SPACE_ID> <MONITORING_ACCOUNT_ID><EXTERNAL_ACCOUNT_ID>,<REGION>,, y así sucesivamente por sus valores reales.
Para obtener una lista de las regiones admitidas, consulte Regiones admitidas.

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Creación de un espacio de agentes

Creación de un entorno de pruebas