-Übersicht Voraussetzungen Einrichtung der IAM-Rollen Schritte beim Onboarding Verifizierung Nächste Schritte Hinweise

AWS DevOps Anleitung zum Onboarding der Agenten-CLI

-Übersicht

Mit AWS DevOps Agent können Sie Ihre AWS Infrastruktur überwachen und verwalten. Diese Anleitung führt Sie Schritt für Schritt 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. Die Fertigstellung dieses Handbuchs nimmt ungefähr 20 Minuten in Anspruch.

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 unterUnterstützte Regionen.

Voraussetzungen

Stellen Sie vor dem Beginn sicher, dass Sie über Folgendes verfügen:

AWS CLI Version 2 ist installiert und konfiguriert
Authentifizierung für Ihr AWS Überwachungskonto
Berechtigungen zum Erstellen von AWS Identitäts- und Zugriffsmanagement (IAM) -Rollen 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 sekundären Kontos, das überwacht werden soll (wird in Schritt 4 verwendet)
<REGION>— Der AWS Regionalcode für Ihren Agentenbereich (z. B. us-east-1 odereu-central-1)
<AGENT_SPACE_ID>— Die ID des Agentenbereichs, die vom create-agent-space Befehl zurückgegeben wird

Einrichtung der IAM-Rollen

1. Erstellen Sie die Rolle „ DevOps Agent Space“

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 dienstverknü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

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 App-Richtlinie für AWS verwaltete Operatoren an:


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

Diese verwaltete Richtlinie gewährt der Betreiber-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 regelt den Zugriff auf den spezifischen Agentenbereich anhand der aws:PrincipalTag/AgentSpaceId Bedingung. Weitere Informationen zur vollständigen Liste der Aktionen finden Sie unterDevOps IAM-Berechtigungen für Agenten.

Schritte beim Onboarding

1. Erstellen Sie einen Agentenbereich

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, einen vom Kunden verwalteten AWS KMS-Schlüssel für die Verschlüsselung zu verwenden. Sie können es 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 unteragentSpace.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 Ihre zu AWS Konto

Verknüpfen Sie Ihr AWS Konto, um die Topologieerkennung zu aktivieren. Stellen Sie den accountType auf 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 verknüpfen.


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

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>

Für die IAM Identity Center-Authentifizierung verwenden --auth-flow idc und bereitstellen--idc-instance-arn. Verwenden Sie --auth-flow idp und stellen Sie für einen externen Identitätsanbieter bereit --issuer-url--idp-client-id, und--idp-client-secret. Weitere Informationen erhalten Sie unter Einrichtung der IAM Identity Center-Authentifizierung und Authentifizierung mit einem externen Identitätsanbieter (IdP) einrichten.

4. (Optional) Ordnen Sie zusätzliche Quellkonten zu

Um zusätzliche Konten mit AWS DevOps Agent zu überwachen, erstellen Sie eine kontoübergreifende IAM-Rolle.

Erstellen Sie die kontoübergreifende Rolle im externen Konto

Wechseln Sie zum externen Konto und erstellen Sie die Vertrauensrichtlinie. Mit dieser Vertrauensrichtlinie kann der AWS DevOps Agent-Dienstprinzipal (aidevops.amazonaws.com) die Rolle im sekundären Konto direkt übernehmen. Die aws:SourceArn Bedingungen aws:SourceAccount und sorgen für eine verwirrende stellvertretende Prävention. Diese Sicherheitskontrolle verhindert, dass ein nicht autorisierter Dienst Ihre Rolle für den Zugriff auf Ihre Ressourcen verwendet. Aufgrund dieser Bedingungen kann nur Ihr Agentenbereich im Hauptkonto die Rolle übernehmen. MONITORING_ACCOUNT_IDErsetzen Sie es durch die ID des Hauptkontos, das den Agentenbereich hostet, den Sie in Schritt 2 eingerichtet haben.

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>"
        },
        "ArnLike": {
          "aws:SourceArn": "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 dienstverknüpften Resource Explorer-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

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) Assoziieren GitHub

Anweisungen zur Registrierung GitHub über die Konsole finden Sie unter. An CI/CD Rohrleitungen anschließen

Listen Sie die registrierten Dienste auf:


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

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

Nachdem Sie sich GitHub in der Konsole registriert haben, verknüpfen Sie die GitHub Repositorys, 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 verknüpfen ServiceNow

Registrieren Sie den ServiceNow Dienst zunächst 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 das zurückgegebene <SERVICE_ID> 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 und verknüpfen Sie Dynatrace

Registrieren Sie zunächst den Dynatrace-Dienst mit OAuth-Anmeldeinformationen:


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 die zurückgegebenen Daten und verknüpfen Sie dann <SERVICE_ID> Dynatrace. Ressourcen sind optional. Die Umgebung gibt an, mit welcher Dynatrace-Umgebung eine Verknüpfung hergestellt 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.

8. (Optional) Registrieren und verknüpfen Sie Splunk

Registrieren Sie zunächst den Splunk-Dienst mit Anmeldeinformationen. 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 das zurückgegebene <SERVICE_ID> und verknüpfen Sie dann 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.

9. (Optional) Registrieren Sie sich und verknüpfen Sie New Relic

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

Region: Entweder US oderEU.

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> Objekt und verknüpfen Sie dann 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.

10. (Optional) Registrieren und verknüpfen Sie Datadog

Sie müssen Datadog zuerst über die AWS DevOps Agent-Konsole mithilfe des OAuth-Workflows registrieren, bevor Sie es über die CLI verknüpfen können. Weitere Informationen finden Sie unter Verbindung herstellen DataDog.

Liste die registrierten Dienste auf:


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

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

Ordnen Sie dann 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.

11. (Optional) Erstellen Sie einen Skill, einen benutzerdefinierten Agenten und einen geplanten Trigger

Sie können dem Agenten benutzerdefiniertes Wissen vermitteln und es nach einem Zeitplan automatisieren, indem Sie Ressourcen und einen Auslöser im Agentenbereich erstellen. In diesem Beispiel werden ein Skill, ein benutzerdefinierter Agent und ein zeitbasierter Trigger erstellt, der den benutzerdefinierten Agenten täglich ausführt. Weitere Informationen zur Verwaltung von Vermögenswerten finden Sie unterVerwaltung von Komponenten.

Erstellen Sie einen Skill, den der Agent bei Bedarf lädt:


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>

Erstellen Sie einen benutzerdefinierten Agenten, den ein Trigger aufrufen kann. Beachten Sie das assetId in der Antwort — der Trigger referenziert es als: 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>

Erstellen Sie einen zeitbasierten Trigger, der den benutzerdefinierten Agenten täglich ausführt. Ersetzen Sie <CUSTOM_AGENT_ASSET_ID> durch die Antwort assetId aus der vorherigen Antwort:


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>

Die Antwort beinhaltet einetriggerId. Notieren Sie sich diesen Wert — Sie verwenden ihn wie <TRIGGER_ID> im nächsten Befehl.

Um den Trigger anzuhalten, ohne ihn zu löschen, aktualisieren Sie seinen Status auf: Inactive


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

12. (Optional) Löschen Sie einen Agentenbereich

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

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

Informationen zum Verbinden zusätzlicher Integrationen finden Sie unterKonfiguration von Integrationen und Wissen.
Weitere Informationen zu den Fähigkeiten und Fähigkeiten von Agenten finden Sie unterDevOps Fähigkeiten von Agenten.
Weitere Informationen zur Verwaltung von Fähigkeiten, benutzerdefinierten Agenten und anderen Ressourcen als Infrastruktur in Form von Code finden Sie unterVerwaltung von Komponenten.
Informationen zur Operator-Web-App finden Sie unterWas ist eine DevOps Agenten-Web-App?.

Hinweise

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.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Einen Agentenbereich erstellen

Erstellen einer Testumgebung