Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# AWS DevOps Guide d'intégration de l'agent CLI
<a name="getting-started-with-aws-devops-agent-cli-onboarding-guide"></a>

## Présentation de
<a name="overview"></a>

Avec AWS DevOps Agent, vous pouvez surveiller et gérer votre AWS infrastructure. Ce guide explique comment configurer l' AWS DevOps agent à l'aide de l'interface de ligne de AWS commande (AWS CLI). Vous créez des rôles IAM, configurez un espace d'agent et associez votre AWS compte. Vous activez également l'application opérateur et connectez éventuellement des intégrations tierces. La réalisation de ce guide prend environ 20 minutes.

AWS DevOps L'agent est disponible dans six AWS régions : USA Est (Virginie du Nord), USA Ouest (Oregon), Asie-Pacifique (Sydney), Asie-Pacifique (Tokyo), Europe (Francfort) et Europe (Irlande). Pour plus d'informations sur les régions prises en charge, consultez[Régions prises en charge](about-aws-devops-agent-supported-regions.md).

## Conditions préalables
<a name="prerequisites"></a>

Avant de commencer, assurez-vous de disposer des éléments suivants :
+ AWS CLI version 2 installée et configurée
+ Authentification sur votre compte AWS de surveillance
+ Autorisations pour créer des rôles de gestion des AWS identités et des accès (IAM) et associer des politiques
+ Un AWS compte à utiliser comme compte de surveillance
+ Connaissance de la AWS CLI et de la syntaxe JSON

Tout au long de ce guide, remplacez les valeurs d'espace réservé suivantes par les vôtres :
+ `<MONITORING_ACCOUNT_ID>`— Votre identifiant de AWS compte à 12 chiffres pour le compte de surveillance (principal)
+ `<EXTERNAL_ACCOUNT_ID>`— L'identifiant de AWS compte à 12 chiffres du compte secondaire à surveiller (utilisé à l'étape 4)
+ `<REGION>`— Le code AWS régional de votre espace agent (par exemple, `us-east-1` ou`eu-central-1`)
+ `<AGENT_SPACE_ID>`— L'identifiant de l'espace agent renvoyé par la `create-agent-space` commande

## Configuration des rôles IAM
<a name="iam-roles-setup"></a>

### 1. Création du rôle d'espace DevOps agent
<a name="1-create-the-devops-agent-space-role"></a>

Créez la politique de confiance IAM en exécutant la commande suivante :

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

Créez le rôle IAM :

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

Enregistrez le rôle ARN en exécutant la commande suivante :

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

Joignez la politique AWS gérée :

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

Créez et joignez une politique en ligne pour permettre la création du rôle lié au service 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. Création du rôle IAM de l'application opérateur
<a name="2-create-the-operator-app-iam-role"></a>

Créez la politique de confiance IAM en exécutant la commande suivante :

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

Créez le rôle IAM :

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

Enregistrez le rôle ARN en exécutant la commande suivante :

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

Joignez la politique de l'application pour opérateurs AWS gérés :

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

Cette politique gérée accorde à l'application de l'opérateur les autorisations nécessaires pour accéder aux fonctionnalités de l'espace agent. Ces fonctionnalités incluent les enquêtes, les recommandations, la gestion des connaissances, le chat et l'intégration du AWS support. La politique définit l'accès à l'espace d'agent spécifique à l'aide de la `aws:PrincipalTag/AgentSpaceId` condition. Pour plus d'informations sur la liste complète des actions, consultez[DevOps Autorisations IAM des agents](aws-devops-agent-security-devops-agent-iam-permissions.md).

## Étapes d'intégration
<a name="onboarding-steps"></a>

### 1. Création d'un espace agent
<a name="1-create-an-agent-space"></a>

Exécutez la commande suivante pour créer un espace agent :

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

Vous pouvez éventuellement spécifier `--kms-key-arn` d'utiliser une clé AWS KMS gérée par le client pour le chiffrement. Vous pouvez également l'utiliser `--tags` pour ajouter des balises de ressources et `--locale` définir la langue des réponses des agents.

Enregistrez le `agentSpaceId` extrait de la réponse (situé dans`agentSpace.agentSpaceId`).

Pour répertorier vos espaces d'agent ultérieurement, exécutez la commande suivante :

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

### 2. Associez votre AWS compte
<a name="2-associate-your-aws-account"></a>

Associez votre AWS compte pour activer la découverte de la topologie. Définissez `accountType` l'une des valeurs suivantes :
+ `monitor`— Le compte principal sur lequel se trouve l'espace agent. Ce compte héberge l'agent et est utilisé pour la découverte de la topologie.
+ `source`— Un compte supplémentaire que l'agent surveille. Utilisez ce type lorsque vous associez des comptes externes à l'étape 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. Activez l'application de l'opérateur
<a name="3-enable-the-operator-app"></a>

Les flux d'authentification peuvent utiliser IAM, IAM Identity Center (IDC) ou un fournisseur d'identité externe (IdP). Exécutez la commande suivante pour activer l'application opérateur pour votre espace agent :

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

Pour l'authentification IAM Identity Center, utilisez `--auth-flow idc` et fournissez`--idc-instance-arn`. Pour un fournisseur d'identité externe, utilisez `--auth-flow idp` et fournissez `--issuer-url``--idp-client-id`, et`--idp-client-secret`. Pour plus d’informations, consultez [Configuration de l'authentification IAM Identity Center](aws-devops-agent-security-setting-up-iam-identity-center-authentication.md) et [Configuration de l'authentification par fournisseur d'identité externe (IdP)](aws-devops-agent-security-setting-up-external-identity-provider-idp-authentication.md).

**Remarque : ** Si vous avez déjà créé un rôle d'application d'opérateur pour un autre espace d'agent de votre compte, vous pouvez réutiliser l'ARN de ce rôle.

### 4. (Facultatif) Associer des comptes sources supplémentaires
<a name="4-optional-associate-additional-source-accounts"></a>

Pour surveiller des comptes supplémentaires avec AWS DevOps Agent, créez un rôle inter-comptes IAM.

#### Créez le rôle multicompte dans le compte externe
<a name="create-the-cross-account-role-in-the-external-account"></a>

Passez au compte externe et créez la politique de confiance. Grâce à cette politique de confiance, le principal du service de l' AWS DevOps agent (`aidevops.amazonaws.com`) peut assumer directement le rôle dans le compte secondaire. Les `aws:SourceArn` conditions `aws:SourceAccount` et créent une confusion dans la prévention adjointe. Ce contrôle de sécurité empêche un service non autorisé d'utiliser votre rôle pour accéder à vos ressources. Ces conditions autorisent uniquement votre espace agent du compte principal à assumer le rôle. `MONITORING_ACCOUNT_ID`Remplacez-le par l'ID du compte principal qui héberge l'espace agent que vous avez configuré à l'étape 2.

Exécutez la commande suivante pour créer la politique de confiance :

```
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>"
        },
        "ArnLike": {
          "aws:SourceArn": "arn:aws:aidevops:<REGION>:<MONITORING_ACCOUNT_ID>:agentspace/<AGENT_SPACE_ID>"
        }
      }
    }
  ]
}
EOF
```

Créez le rôle IAM inter-comptes :

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

Enregistrez le rôle ARN en exécutant la commande suivante :

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

Joignez la politique AWS gérée :

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

Joignez la politique en ligne pour permettre la création du rôle lié au service Resource Explorer dans le compte externe :

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

#### Associer le compte externe
<a name="associate-the-external-account"></a>

Revenez à votre compte de surveillance, puis exécutez la commande suivante pour associer le compte externe :

```
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. Associé (Facultatif) GitHub
<a name="5-optional-associate-github"></a>

**Remarque : ** Vous devez d'abord vous enregistrer GitHub via la console de l' AWS DevOps agent à l'aide du flux OAuth avant de pouvoir l'associer via l'interface de ligne de commande.

Pour obtenir des instructions sur l'enregistrement GitHub via la console, consultez[Raccordement aux CI/CD canalisations](configuring-integrations-and-knowledge-connecting-to-cicd-pipelines-index.md).

Répertoriez les services enregistrés :

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

Enregistrez le `<SERVICE_ID>` pour ServiceType :. `github`

Après vous être enregistré GitHub dans la console, associez GitHub les référentiels en exécutant la commande suivante :

```
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. (Facultatif) Inscrivez-vous et associez-vous ServiceNow
<a name="6-optional-register-and-associate-servicenow"></a>

Tout d'abord, enregistrez le ServiceNow service à l'aide des informations d'identification OAuth :

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

Enregistrez les fichiers renvoyés`<SERVICE_ID>`, puis associez 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. (Facultatif) Enregistrez et associez Dynatrace
<a name="7-optional-register-and-associate-dynatrace"></a>

Tout d'abord, enregistrez le service Dynatrace à l'aide des informations d'identification 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>
```

Enregistrez le retour`<SERVICE_ID>`, puis associez Dynatrace. Les ressources sont facultatives. L'environnement spécifie l'environnement Dynatrace à associer.

```
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 réponse inclut des informations sur le webhook pour l'intégration. Vous pouvez utiliser ce webhook pour lancer une enquête auprès de Dynatrace. Pour de plus amples informations, veuillez consulter [Connecter Dynatrace](connecting-telemetry-sources-connecting-dynatrace.md).

### 8. (Facultatif) Enregistrez et associez Splunk
<a name="8-optional-register-and-associate-splunk"></a>

Tout d'abord, enregistrez le service Splunk à l'aide de BearerToken vos informations d'identification.

Le point de terminaison utilise le format suivant : `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>
```

Enregistrez le fichier renvoyé`<SERVICE_ID>`, puis associez 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 réponse inclut des informations sur le webhook pour l'intégration. Vous pouvez utiliser ce webhook pour lancer une enquête depuis Splunk. Pour de plus amples informations, veuillez consulter [Connecter Splunk](connecting-telemetry-sources-connecting-splunk.md).

### 9. (Facultatif) Enregistrez et associez New Relic
<a name="9-optional-register-and-associate-new-relic"></a>

Tout d'abord, enregistrez le service New Relic à l'aide des informations d'identification de la clé API.

Région : soit, `US` soit`EU`.

Champs facultatifs :`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>
```

Enregistrez le fichier renvoyé`<SERVICE_ID>`, puis associez 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 réponse inclut des informations sur le webhook pour l'intégration. Vous pouvez utiliser ce webhook pour lancer une enquête depuis New Relic. Pour de plus amples informations, veuillez consulter [Connecter New Relic](connecting-telemetry-sources-connecting-new-relic.md).

### 10. (Facultatif) Enregistrez et associez Datadog
<a name="10-optional-register-and-associate-datadog"></a>

Vous devez d'abord enregistrer Datadog via la console de l' AWS DevOps Agent à l'aide du flux OAuth avant de pouvoir l'associer via l'interface de ligne de commande. Pour de plus amples informations, veuillez consulter [Connecter DataDog](connecting-telemetry-sources-connecting-datadog.md).

Répertoriez les services enregistrés :

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

Enregistrez le `<SERVICE_ID>` pour ServiceType :. `mcpserverdatadog`

Associez ensuite 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 réponse inclut des informations sur le webhook pour l'intégration. Vous pouvez utiliser ce webhook pour lancer une enquête depuis Datadog. Pour de plus amples informations, veuillez consulter [Connecter DataDog](connecting-telemetry-sources-connecting-datadog.md).

### 11. (Facultatif) Créez une compétence, un agent personnalisé et un déclencheur programmé
<a name="11-optional-create-a-skill-custom-agent-and-scheduled-trigger"></a>

Vous pouvez donner à l'agent des connaissances personnalisées et les automatiser selon un calendrier en créant des actifs et un déclencheur dans l'espace agent. Cet exemple crée une compétence, un agent personnalisé et un déclencheur temporel qui exécute l'agent personnalisé quotidiennement. Pour plus d'informations sur la gestion des actifs, consultez[Gestion des ressources](about-aws-devops-agent-managing-assets.md).

Créez une compétence que l'agent charge le cas échéant :

```
aws devops-agent create-asset \
  --agent-space-id <AGENT_SPACE_ID> \
  --asset-type skill \
  --metadata '{"name":"rds-performance-investigation","description":"Investigation procedures for RDS performance issues.","agent_types":["GENERIC"]}' \
  --content '{"file":{"path":"SKILL.md","body":{"text":"# RDS Performance Investigation\nUse this skill when investigating database latency, connection errors, or query timeouts."}}}' \
  --region <REGION>
```

Créez un agent personnalisé qu'un déclencheur peut invoquer. Notez cela `assetId` dans la réponse : le déclencheur y fait référence comme suit : `custom:<assetId>`

```
aws devops-agent create-asset \
  --agent-space-id <AGENT_SPACE_ID> \
  --asset-type custom_agent \
  --metadata '{"name":"rds-firefighter","skills":["rds-performance-investigation"]}' \
  --content '{"file":{"path":"AGENT.md","body":{"text":"# RDS Firefighter\nCustom agent for RDS incidents."}}}' \
  --region <REGION>
```

Créez un déclencheur temporel qui exécute l'agent personnalisé quotidiennement. Remplacer `<CUSTOM_AGENT_ASSET_ID>` par le `assetId` texte de la réponse précédente :

```
aws devops-agent create-trigger \
  --agent-space-id <AGENT_SPACE_ID> \
  --type TIME_BASED \
  --condition '{"schedule":{"expression":"rate(1 day)"}}' \
  --action '{"actionType":"create:task","task":{"agent":"custom:<CUSTOM_AGENT_ASSET_ID>"}}' \
  --status Active \
  --region <REGION>
```

La réponse inclut un`triggerId`. Notez cette valeur. Vous l'utiliserez comme `<TRIGGER_ID>` dans la commande suivante.

Pour suspendre le déclencheur sans le supprimer, mettez à jour son état comme suit `Inactive` :

```
aws devops-agent update-trigger \
  --agent-space-id <AGENT_SPACE_ID> \
  --trigger-id <TRIGGER_ID> \
  --status Inactive \
  --region <REGION>
```

### 12. (Facultatif) Supprimer un espace agent
<a name="12-optional-delete-an-agent-space"></a>

La suppression d'un espace d'agent supprime toutes les associations, configurations et données d'investigation relatives à cet espace d'agent. Cette action ne peut être annulée.

Pour supprimer un espace d'agent, exécutez la commande suivante :

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

## Vérification
<a name="verification"></a>

Pour vérifier votre configuration, exécutez les commandes suivantes :

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

## Étapes suivantes
<a name="next-steps"></a>
+ Pour connecter des intégrations supplémentaires, consultez[Configuration des intégrations et des connaissances](configuring-integrations-and-knowledge.md).
+ Pour en savoir plus sur les compétences et les capacités des agents, consultez[DevOps Compétences des agents](about-aws-devops-agent-devops-agent-skills.md).
+ Pour plus d'informations sur la gestion des compétences, des agents personnalisés et d'autres actifs sous forme d'infrastructure sous forme de code, consultez[Gestion des ressources](about-aws-devops-agent-managing-assets.md).
+ Pour comprendre l'application Web destinée aux opérateurs, consultez[Qu'est-ce qu'une application Web d' DevOps agent ?](about-aws-devops-agent-what-is-a-devops-agent-web-app.md).

## Remarques
<a name="notes"></a>
+ Remplacez `<AGENT_SPACE_ID>``<MONITORING_ACCOUNT_ID>`,`<EXTERNAL_ACCOUNT_ID>`,`<REGION>`,, etc. par vos valeurs réelles.
+ Pour obtenir une liste des régions prises en charge, consultez [Régions prises en charge](about-aws-devops-agent-supported-regions.md).