Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# AWS DevOps Leitfaden für das CLI Onboarding von Agenten
<a name="getting-started-with-aws-devops-agent-cli-onboarding-guide"></a>

## -Übersicht
<a name="overview"></a>

Mit AWS DevOps Agent können Sie Ihre AWS Infrastruktur überwachen und verwalten. Diese Anleitung führt Sie durch die Einrichtung des AWS DevOps Agenten mithilfe der AWS Befehlszeilenschnittstelle (AWS CLI). Sie erstellen IAM-Rollen, richten einen Agentenbereich ein und verknüpfen Ihr AWS Konto. Sie aktivieren auch die Operator-App und verbinden optional Integrationen von Drittanbietern. Das Ausfüllen dieses Handbuchs dauert ungefähr 20 Minuten.

AWS DevOps Der Agent ist in sechs AWS Regionen verfügbar: USA Ost (Nord-Virginia), USA West (Oregon), Asien-Pazifik (Sydney), Asien-Pazifik (Tokio), Europa (Frankfurt) und Europa (Irland). Weitere Informationen zu den unterstützten Regionen finden Sie unter[Unterstützte Regionen](about-aws-devops-agent-supported-regions.md).

## Voraussetzungen
<a name="prerequisites"></a>

Stellen Sie vor dem Beginn sicher, dass Sie über Folgendes verfügen:
+ AWS CLI Version 2 installiert und konfiguriert
+ Authentifizierung für Ihr AWS Monitoring-Konto
+ Berechtigungen zum Erstellen von AWS Identitäts- und Zugriffsmanagement-Rollen (IAM) und zum Anhängen von Richtlinien
+ Ein AWS Konto, das als Überwachungskonto verwendet werden soll
+ Vertrautheit mit der AWS CLI- und JSON-Syntax

Ersetzen Sie in diesem Handbuch die folgenden Platzhalterwerte durch Ihre eigenen:
+ `<MONITORING_ACCOUNT_ID>`— Ihre 12-stellige AWS Konto-ID für das (primäre) Überwachungskonto
+ `<EXTERNAL_ACCOUNT_ID>`— Die 12-stellige AWS Konto-ID des zu überwachenden Sekundärkontos (wird in Schritt 4 verwendet)
+ `<REGION>`— Der AWS Regionalcode für Ihren Agentenbereich (z. B. `us-east-1` oder`eu-central-1`)
+ `<AGENT_SPACE_ID>`— Die Agenten-Space-ID, die vom `create-agent-space` Befehl zurückgegeben wird

## Einrichtung von IAM-Rollen
<a name="iam-roles-setup"></a>

### 1. Erstellen Sie die DevOps Agent-Space-Rolle
<a name="1-create-the-devops-agent-space-role"></a>

Erstellen Sie die IAM-Vertrauensrichtlinie, indem Sie den folgenden Befehl ausführen:

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

Erstellen Sie die IAM-Rolle:

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

Speichern Sie den Rollen-ARN, indem Sie den folgenden Befehl ausführen:

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

Hängen Sie die AWS verwaltete Richtlinie an:

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

Erstellen Sie eine Inline-Richtlinie und fügen Sie sie an, um die Erstellung der serviceverknüpften Resource Explorer-Rolle zu ermöglichen:

```
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. Erstellen Sie die IAM-Rolle der Operator-App
<a name="2-create-the-operator-app-iam-role"></a>

Erstellen Sie die IAM-Vertrauensrichtlinie, indem Sie den folgenden Befehl ausführen:

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

Erstellen Sie die IAM-Rolle:

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

Speichern Sie den Rollen-ARN, indem Sie den folgenden Befehl ausführen:

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

Hängen Sie die Richtlinie für AWS verwaltete Operator-Apps an:

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

Diese verwaltete Richtlinie gewährt der Operator-App Berechtigungen für den Zugriff auf Funktionen im Agentenbereich. Zu diesen Funktionen gehören Untersuchungen, Empfehlungen, Wissensmanagement, Chat und AWS Support-Integration. Die Richtlinie beschränkt den Zugriff auf den jeweiligen Agentenbereich anhand der `aws:PrincipalTag/AgentSpaceId` Bedingung. Weitere Informationen zur vollständigen Liste der Aktionen finden Sie unter[DevOps IAM-Berechtigungen für Agenten](aws-devops-agent-security-devops-agent-iam-permissions.md).

## Schritte zum Onboarding
<a name="onboarding-steps"></a>

### 1. Erstellen Sie einen Agentenbereich
<a name="1-create-an-agent-space"></a>

Führen Sie den folgenden Befehl aus, um einen Agentenbereich zu erstellen:

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

Geben Sie optional `--kms-key-arn` an, dass ein vom Kunden verwalteter AWS KMS-Schlüssel für die Verschlüsselung verwendet werden soll. Sie können ihn auch verwenden`--tags`, um Ressourcen-Tags `--locale` hinzuzufügen und die Sprache für Agentenantworten festzulegen.

Speichern Sie das `agentSpaceId` aus der Antwort (befindet sich unter`agentSpace.agentSpaceId`).

Führen Sie den folgenden Befehl aus, um Ihre Agentenbereiche später aufzulisten:

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

### 2. Ordnen Sie Ihr AWS Konto zu
<a name="2-associate-your-aws-account"></a>

Ordnen Sie Ihr AWS Konto zu, um die Topologieerkennung zu aktivieren. Stellen Sie `accountType` für einen der folgenden Werte ein:
+ `monitor`— Das primäre Konto, in dem der Agentenbereich vorhanden ist. Dieses Konto hostet den Agenten und wird für die Topologieermittlung verwendet.
+ `source`— Ein zusätzliches Konto, das der Agent überwacht. Verwenden Sie diesen Typ, wenn Sie in Schritt 4 externe Konten zuordnen.

```
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. Aktivieren Sie die Operator-App
<a name="3-enable-the-operator-app"></a>

Authentifizierungsabläufe können IAM, IAM Identity Center (IDC) oder einen externen Identitätsanbieter (IdP) verwenden. Führen Sie den folgenden Befehl aus, um die Operator-App für Ihren Agentenbereich zu aktivieren:

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

Verwenden `--auth-flow idc` und stellen Sie für die IAM Identity Center-Authentifizierung bereit`--idc-instance-arn`. Verwenden `--auth-flow idp` und stellen Sie für einen externen Identitätsanbieter `--issuer-url``--idp-client-id`, und `--idp-client-secret` bereit. Weitere Informationen erhalten Sie unter [Einrichtung der IAM Identity Center-Authentifizierung](aws-devops-agent-security-setting-up-iam-identity-center-authentication.md) und [Authentifizierung durch externen Identitätsanbieter (IdP) einrichten](aws-devops-agent-security-setting-up-external-identity-provider-idp-authentication.md).

**Hinweis:** Wenn Sie zuvor eine Operator-App-Rolle für einen anderen Agentenbereich in Ihrem Konto erstellt haben, können Sie diesen Rollen-ARN wiederverwenden.

### 4. (Optional) Ordnen Sie zusätzliche Quellkonten zu
<a name="4-optional-associate-additional-source-accounts"></a>

Um weitere Konten mit AWS DevOps Agent zu überwachen, erstellen Sie eine kontenübergreifende IAM-Rolle.

#### Erstellen Sie die kontoübergreifende Rolle im externen Konto
<a name="create-the-cross-account-role-in-the-external-account"></a>

Wechseln Sie zum externen Konto und erstellen Sie die Vertrauensrichtlinie. Das `MONITORING_ACCOUNT_ID` ist das Hauptkonto, das den Agent-Bereich hostet, den Sie in Schritt 2 eingerichtet haben. Diese Konfiguration ermöglicht es dem AWS DevOps Agent-Dienst, im Namen des Überwachungskontos eine Rolle in den sekundären Quellkonten zu übernehmen.

Führen Sie den folgenden Befehl aus, um die Vertrauensrichtlinie zu erstellen:

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

Erstellen Sie die kontoübergreifende IAM-Rolle:

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

Speichern Sie den Rollen-ARN, indem Sie den folgenden Befehl ausführen:

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

Hängen Sie die AWS verwaltete Richtlinie an:

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

Hängen Sie die Inline-Richtlinie an, um die Erstellung der mit dem Resource Explorer-Dienst verknüpften Rolle im externen Konto zu ermöglichen:

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

#### Ordnen Sie das externe Konto zu
<a name="associate-the-external-account"></a>

Wechseln Sie zurück zu Ihrem Überwachungskonto und führen Sie dann den folgenden Befehl aus, um das externe Konto zuzuordnen:

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

**Hinweis:** Sie müssen sich zuerst GitHub über die AWS DevOps Agentenkonsole registrieren, indem Sie den OAuth Flow verwenden, bevor Sie ihn über die CLI verknüpfen können.

Anweisungen zur Registrierung GitHub über die Konsole finden Sie unter[Anschluss an CI/CD Rohrleitungen](configuring-capabilities-for-aws-devops-agent-connecting-to-cicd-pipelines-index.md).

Listet die registrierten Dienste auf:

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

Speichern Sie den `<SERVICE_ID>` für ServiceType:. `github`

Nachdem Sie sich GitHub in der Konsole registriert haben, ordnen Sie GitHub Repositorys zu, indem Sie den folgenden Befehl ausführen:

```
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. (Optional) Registrieren und Zuordnen ServiceNow
<a name="6-optional-register-and-associate-servicenow"></a>

Registrieren Sie zunächst den ServiceNow Dienst mit den OAuth Anmeldeinformationen:

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

Speichern Sie die zurückgegebenen `<SERVICE_ID>` Daten und verknüpfen Sie dann 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. (Optional) Registrieren Sie Dynatrace und verknüpfen Sie es
<a name="7-optional-register-and-associate-dynatrace"></a>

Registrieren Sie zunächst den Dynatrace-Dienst mit Anmeldeinformationen: 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>
```

Speichern Sie das zurückgesendete Dynatrace `<SERVICE_ID>` und ordnen Sie es dann zu. Ressourcen sind optional. Die Umgebung gibt an, welcher Dynatrace-Umgebung zugeordnet werden soll.

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

Die Antwort enthält Webhook-Informationen für die Integration. Sie können diesen Webhook verwenden, um eine Untersuchung von Dynatrace auszulösen. Weitere Informationen finden Sie unter [Dynatrace verbinden](connecting-telemetry-sources-connecting-dynatrace.md).

### 8. (Optional) Registrieren Sie Splunk und verknüpfen Sie es
<a name="8-optional-register-and-associate-splunk"></a>

Registrieren Sie zunächst den Splunk-Service mit Zugangsdaten. BearerToken 

Der Endpunkt verwendet das folgende Format: `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>
```

Speichern Sie den zurückgegebenen Text `<SERVICE_ID>` und verknüpfen Sie ihn anschließend mit 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>
```

Die Antwort enthält Webhook-Informationen für die Integration. Sie können diesen Webhook verwenden, um eine Untersuchung von Splunk auszulösen. Weitere Informationen finden Sie unter [Splunk verbinden](connecting-telemetry-sources-connecting-splunk.md).

### 9. (Optional) Registrieren Sie New Relic und verknüpfen Sie es
<a name="9-optional-register-and-associate-new-relic"></a>

Registrieren Sie zunächst den New Relic-Service mit den API-Schlüsselanmeldedaten.

Region: Entweder `US` oder`EU`.

Optionale Felder:`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>
```

Speichern Sie das zurückgegebene `<SERVICE_ID>` und verknüpfen Sie es dann mit 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>
```

Die Antwort enthält Webhook-Informationen für die Integration. Sie können diesen Webhook verwenden, um eine Untersuchung von New Relic auszulösen. Weitere Informationen finden Sie unter [New Relic verbinden](connecting-telemetry-sources-connecting-new-relic.md).

### 10. (Optional) Registrieren Sie Datadog und verknüpfen Sie es
<a name="10-optional-register-and-associate-datadog"></a>

Sie müssen Datadog zuerst über die AWS DevOps Agentenkonsole mithilfe des OAuth Flows registrieren, bevor Sie es über die CLI verknüpfen können. Weitere Informationen finden Sie unter [Verbindung herstellen DataDog](connecting-telemetry-sources-connecting-datadog.md).

Listet die registrierten Dienste auf:

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

Speichern Sie den `<SERVICE_ID>` für ServiceType:. `mcpserverdatadog`

Dann ordne Datadog zu:

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

Die Antwort enthält Webhook-Informationen für die Integration. Sie können diesen Webhook verwenden, um eine Untersuchung von Datadog auszulösen. Weitere Informationen finden Sie unter [Verbindung herstellen DataDog](connecting-telemetry-sources-connecting-datadog.md).

### 11. (Optional) Löschen Sie einen Agentenbereich
<a name="11-optional-delete-an-agent-space"></a>

Durch das Löschen eines Agentenbereichs werden alle Zuordnungen, Konfigurationen und Ermittlungsdaten für diesen Agentenbereich entfernt. Diese Aktion kann nicht rückgängig gemacht werden.

Führen Sie den folgenden Befehl aus, um einen Agentenbereich zu löschen:

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

## Verifizierung
<a name="verification"></a>

Führen Sie die folgenden Befehle aus, um Ihr Setup zu überprüfen:

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

## Nächste Schritte
<a name="next-steps"></a>
+ Informationen zum Verbinden zusätzlicher Integrationen finden Sie unter[Funktionen für den AWS DevOps Agenten konfigurieren](configuring-capabilities-for-aws-devops-agent.md).
+ Weitere Informationen zu den Fähigkeiten und Fertigkeiten von Agenten finden Sie unter[DevOps Fähigkeiten der Agenten](about-aws-devops-agent-devops-agent-skills.md).
+ Weitere Informationen zur Web-App für Operatoren finden Sie unter[Was ist eine DevOps Agent-Web-App?](about-aws-devops-agent-what-is-a-devops-agent-web-app.md).

## Hinweise
<a name="notes"></a>
+ Ersetzen Sie `<AGENT_SPACE_ID>` `<MONITORING_ACCOUNT_ID>``<EXTERNAL_ACCOUNT_ID>`,`<REGION>`,, usw. durch Ihre tatsächlichen Werte.
+ Eine Liste der unterstützten -Regionen finden Sie unter [Unterstützte Regionen](about-aws-devops-agent-supported-regions.md).