• Das AWS Systems Manager CloudWatch Dashboard wird nach dem 30. April 2026 nicht mehr verfügbar sein. Kunden können weiterhin die CloudWatch Amazon-Konsole verwenden, um ihre CloudWatch Amazon-Dashboards anzusehen, zu erstellen und zu verwalten, so wie sie es heute tun. Weitere Informationen finden Sie in der [Amazon CloudWatch Dashboard-Dokumentation](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Dashboards.html).
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.
# Exemplarische Vorgehensweise: Verwenden Sie das mit AWS CLI Run Command
In der folgenden exemplarischen Vorgehensweise wird gezeigt, wie Sie mithilfe von AWS Command Line Interface (AWS CLI) Informationen zu Befehlen und Befehlsparametern anzeigen, Befehle ausführen und den Status dieser Befehle anzeigen können.
**Wichtig**
Nur vertrauenswürdige Administratoren sollten die in diesem Thema aufgeführten AWS Systems Manager vorkonfigurierten Dokumente verwenden dürfen. Die in Systems-Manager-Dokumenten festgelegten Befehle oder Skripts werden mit Administratorberechtigungen auf Ihren verwalteten Knoten ausgeführt. Wenn ein Benutzer über die Berechtigung zum Ausführen der vordefinierten Systems-Manager-Dokumente (alle Dokumente, die mit `AWS-` beginnen) verfügt, hat dieser Benutzer auch Administratorzugriff auf den Knoten. Für alle anderen Benutzer sollten Sie restriktive Dokumente erstellen und sie mit bestimmten Benutzern teilen.
**Topics**
+ [Schritt 1: Erste Schritte](#walkthrough-cli-settings)
+ [Schritt 2: Ausführen von Shell-Skripten zum Anzeigen von Ressourcendetails](#walkthrough-cli-run-scripts)
+ [Schritt 3: Senden einfacher Befehle mit dem `AWS-RunShellScript`-Dokument](#walkthrough-cli-example-1)
+ [Schritt 4: Ausführen eines einfachen Python-Skripts mit Run Command](#walkthrough-cli-example-2)
+ [Schritt 5: Führen Sie ein Bash-Skript mit Run Command aus](#walkthrough-cli-example-3)
## Schritt 1: Erste Schritte
Sie müssen entweder über Administratorberechtigungen auf dem verwalteten Knoten verfügen, den Sie konfigurieren möchten, oder Sie müssen über die geeignete Berechtigung in AWS Identity and Access Management (IAM) verfügen. Beachten Sie auch, dass in diesem Beispiel die Region USA Ost (Ohio) (us-east-2) verwendet wird. Run Commandist in den in [Systems Manager AWS-Regionen aufgelisteten Dienstendpunkten](https://docs.aws.amazon.com/general/latest/gr/ssm.html#ssm_region) in der *Allgemeine Amazon Web Services-Referenz*verfügbar. Weitere Informationen finden Sie unter [Einrichtung verwalteter Knoten für AWS Systems Manager](systems-manager-setting-up-nodes.md).
**Um Befehle mit dem auszuführen AWS CLI**
1. Installieren und konfigurieren Sie AWS Command Line Interface (AWS CLI), falls Sie dies noch nicht getan haben.
Weitere Informationen finden Sie unter [Installieren oder Aktualisieren der neuesten Version von AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
1. Listen Sie alle verfügbaren Dokumente auf.
Mit diesem Befehl werden alle verfügbaren Dokumente für Ihr Konto basierend auf IAM-Berechtigungen ausgeführt.
```
aws ssm list-documents
```
1. Überprüfen Sie, ob ein verwalteter Knoten zum Empfangen von Befehlen bereit ist.
Die Ausgabe des folgenden Befehls zeigt, ob verwaltete Knoten online sind.
------
#### [ Linux & macOS ]
```
aws ssm describe-instance-information \
--output text --query "InstanceInformationList[*]"
```
------
#### [ Windows ]
```
aws ssm describe-instance-information ^
--output text --query "InstanceInformationList[*]"
```
------
1. Verwenden Sie den folgenden Befehl, um weitere Details zu einem bestimmten verwalteten Knoten anzuzeigen.
**Anmerkung**
Um die Befehle in dieser exemplarischen Vorgehensweise auszuführen, ersetzen Sie die Instanz und den Befehl IDs. Verwenden Sie für verwaltete AWS IoT Greengrass Core-Geräte die Instanz-ID mi- *ID\$1number* for. Die Befehls-ID wird als Antwort an **send-command** zurückgegeben. Instanzen IDs sind verfügbar unterFleet Manager, einem Tool in AWS Systems Manager..
------
#### [ Linux & macOS ]
```
aws ssm describe-instance-information \
--instance-information-filter-list key=InstanceIds,valueSet=instance-ID
```
------
#### [ Windows ]
```
aws ssm describe-instance-information ^
--instance-information-filter-list key=InstanceIds,valueSet=instance-ID
```
------
## Schritt 2: Ausführen von Shell-Skripten zum Anzeigen von Ressourcendetails
Mit Run Command und dem `AWS-RunShellScript`-Dokument können Sie Befehle oder Skripts auf einem verwalteten Knoten ausführen, als ob Sie lokal angemeldet wären.
**Die Beschreibung und verfügbare Parameter anzeigen**
Führen Sie den folgenden Befehl aus, um eine Beschreibung des Systems Manager JSON-Dokuments anzuzeigen.
------
#### [ Linux & macOS ]
```
aws ssm describe-document \
--name "AWS-RunShellScript" \
--query "[Document.Name,Document.Description]"
```
------
#### [ Windows ]
```
aws ssm describe-document ^
--name "AWS-RunShellScript" ^
--query "[Document.Name,Document.Description]"
```
------
Führen Sie den folgenden Befehl aus, um die verfügbaren Parameter und Details zu diesen Parametern anzuzeigen.
------
#### [ Linux & macOS ]
```
aws ssm describe-document \
--name "AWS-RunShellScript" \
--query "Document.Parameters[*]"
```
------
#### [ Windows ]
```
aws ssm describe-document ^
--name "AWS-RunShellScript" ^
--query "Document.Parameters[*]"
```
------
## Schritt 3: Senden einfacher Befehle mit dem `AWS-RunShellScript`-Dokument
Führen Sie den folgenden Befehl aus, um IP-Informationen für einen Linux-verwalteten Knoten abzurufen.
Wenn Sie einen von Windows Server verwalteten Knoten anvisieren, ändern Sie den `document-name` zu `AWS-RunPowerShellScript` und ändern Sie den `command` von `ifconfig` zu `ipconfig`.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--instance-ids "instance-ID" \
--document-name "AWS-RunShellScript" \
--comment "IP config" \
--parameters commands=ifconfig \
--output text
```
------
#### [ Windows ]
```
aws ssm send-command ^
--instance-ids "instance-ID" ^
--document-name "AWS-RunShellScript" ^
--comment "IP config" ^
--parameters commands=ifconfig ^
--output text
```
------
**Abrufen der Befehlsinformation mit Antwortdaten**
Mit dem folgenden Befehl wird die Befehls-ID verwendet, die vom vorherigen Befehl zurückgegeben wurde, um die Details und Antwortdaten der Ausführung des Befehls abzurufen. Das System gibt die Antwortdaten zurück, wenn der Befehl abgeschlossen ist. Wenn die Befehlsausführung `"Pending"` oder `"InProgress"` anzeigt, führen Sie diesen Befehl erneut aus, um die Antwortdaten zu sehen.
------
#### [ Linux & macOS ]
```
aws ssm list-command-invocations \
--command-id $sh-command-id \
--details
```
------
#### [ Windows ]
```
aws ssm list-command-invocations ^
--command-id $sh-command-id ^
--details
```
------
**Benutzer identifizieren**
Mit dem folgenden Befehl wird der Standard-Benutzer angezeigt, der die Befehle ausführt.
------
#### [ Linux & macOS ]
```
sh_command_id=$(aws ssm send-command \
--instance-ids "instance-ID" \
--document-name "AWS-RunShellScript" \
--comment "Demo run shell script on Linux managed node" \
--parameters commands=whoami \
--output text \
--query "Command.CommandId")
```
------
**Abrufen des Befehlsstatus**
Mit dem folgenden Befehl wird die Befehls-ID verwendet, um den Status der Befehlsausführung auf dem verwalteten Knoten abzurufen. In diesem Beispiel wird die Befehls-ID verwendet, die im vorherigen Befehl zurückgegeben wurde.
------
#### [ Linux & macOS ]
```
aws ssm list-commands \
--command-id "command-ID"
```
------
#### [ Windows ]
```
aws ssm list-commands ^
--command-id "command-ID"
```
------
**Abrufen der Befehlsdetails**
Mit dem folgenden Befehl wird die Befehls-ID vom vorherigen Befehl verwendet, um den Status der Befehlsausführung pro verwalteten Knoten abzurufen.
------
#### [ Linux & macOS ]
```
aws ssm list-command-invocations \
--command-id "command-ID" \
--details
```
------
#### [ Windows ]
```
aws ssm list-command-invocations ^
--command-id "command-ID" ^
--details
```
------
**Abrufen von Befehlsinformationen mit Antwortdaten für einen bestimmten verwalteten Knoten**
Mit dem folgenden Befehl wird die Ausgabe der ursprünglichen `aws ssm send-command`-Anforderung für einen bestimmten verwalteten Knoten zurückgegeben.
------
#### [ Linux & macOS ]
```
aws ssm list-command-invocations \
--instance-id instance-ID \
--command-id "command-ID" \
--details
```
------
#### [ Windows ]
```
aws ssm list-command-invocations ^
--instance-id instance-ID ^
--command-id "command-ID" ^
--details
```
------
**Anzeigen der Python-Version**
Mit dem folgenden Befehl wird die Version von Python zurückgegeben, die auf einem Knoten ausgeführt wird.
------
#### [ Linux & macOS ]
```
sh_command_id=$(aws ssm send-command \
--instance-ids "instance-ID" \
--document-name "AWS-RunShellScript" \
--comment "Demo run shell script on Linux Instances" \
--parameters commands='python -V' \
--output text --query "Command.CommandId") \
sh -c 'aws ssm list-command-invocations \
--command-id "$sh_command_id" \
--details \
--query "CommandInvocations[].CommandPlugins[].{Status:Status,Output:Output}"'
```
------
## Schritt 4: Ausführen eines einfachen Python-Skripts mit Run Command
Mit dem folgenden Befehl wird ein einfaches Python-Skript „Hello World“ unter Verwendung von Run Command ausgeführt.
------
#### [ Linux & macOS ]
```
sh_command_id=$(aws ssm send-command \
--instance-ids "instance-ID" \
--document-name "AWS-RunShellScript" \
--comment "Demo run shell script on Linux Instances" \
--parameters '{"commands":["#!/usr/bin/python","print \"Hello World from python\""]}' \
--output text \
--query "Command.CommandId") \
sh -c 'aws ssm list-command-invocations \
--command-id "$sh_command_id" \
--details \
--query "CommandInvocations[].CommandPlugins[].{Status:Status,Output:Output}"'
```
------
## Schritt 5: Führen Sie ein Bash-Skript mit Run Command aus
Die Beispiele in diesem Abschnitt zeigen, wie Sie das folgende Bash-Skript mit Run Commandausführen.
Für Beispiele für die Verwendung von Run Command, um Skripts auszuführen, die an Remote-Speicherorten gespeichert sind, siehe [Ausführen von Skripts von Amazon S3](integration-s3.md) und [Ausführen von Skripts von GitHub](integration-remote-scripts.md).
```
#!/bin/bash
yum -y update
yum install -y ruby
cd /home/ec2-user
curl -O https://aws-codedeploy-us-east-2.s3.amazonaws.com/latest/install
chmod +x ./install
./install auto
```
Dieses Skript installiert den AWS CodeDeploy Agenten auf Amazon Linux- und Red Hat Enterprise Linux (RHEL) -Instances, wie unter [Amazon EC2 EC2-Instance erstellen für CodeDeploy](https://docs.aws.amazon.com/codedeploy/latest/userguide/instances-ec2-create.html) im *AWS CodeDeploy Benutzerhandbuch* beschrieben.
Das Skript installiert den CodeDeploy Agenten aus einem AWS verwalteten S3-Bucket in der Region USA Ost (Ohio) (us-east-2),. `aws-codedeploy-us-east-2`
**Führen Sie ein Bash-Skript in einem Befehl aus AWS CLI **
Das folgende Beispiel zeigt, wie Sie das Bash-Skript mit der Option `--parameters` in einen CLI-Befehl einbinden.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name "AWS-RunShellScript" \
--targets '[{"Key":"InstanceIds","Values":["instance-id"]}]' \
--parameters '{"commands":["#!/bin/bash","yum -y update","yum install -y ruby","cd /home/ec2-user","curl -O https://aws-codedeploy-us-east-2.s3.amazonaws.com/latest/install","chmod +x ./install","./install auto"]}'
```
------
**Führen Sie ein Bash-Skript in einer JSON-Datei aus**
Im folgenden Beispiel wird der Inhalt des Bash-Skripts in einer JSON-Datei gespeichert, und die Datei wird mit der Option `--cli-input-json` in den Befehl aufgenommen.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name "AWS-RunShellScript" \
--targets "Key=InstanceIds,Values=instance-id" \
--cli-input-json file://installCodeDeployAgent.json
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name "AWS-RunShellScript" ^
--targets "Key=InstanceIds,Values=instance-id" ^
--cli-input-json file://installCodeDeployAgent.json
```
------
Der Inhalt der referenzierten `installCodeDeployAgent.json`-Datei ist im folgenden Beispiel dargestellt.
```
{
"Parameters": {
"commands": [
"#!/bin/bash",
"yum -y update",
"yum install -y ruby",
"cd /home/ec2-user",
"curl -O https://aws-codedeploy-us-east-2.s3.amazonaws.com/latest/install",
"chmod +x ./install",
"./install auto"
]
}
}
```