• 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.
# AWS Systems Manager Run Command
Mithilfe Run Command eines Tools in AWS Systems Manager können Sie die Konfiguration Ihrer verwalteten Knoten remote und sicher verwalten. Ein *verwalteter Knoten* ist jede Amazon Elastic Compute Cloud (Amazon EC2) -Instanz oder EC2 Nicht-Maschine in Ihrer [Hybrid- und Multi-Cloud-Umgebung](operating-systems-and-machine-types.md#supported-machine-types), die für Systems Manager konfiguriert wurde. Run Commandermöglicht es Ihnen, allgemeine Verwaltungsaufgaben zu automatisieren und einmalige Konfigurationsänderungen in großem Umfang durchzuführen. Sie können Run Command von AWS-Managementkonsole, dem AWS Command Line Interface (AWS CLI) AWS Tools for Windows PowerShell, oder dem verwenden AWS SDKs. Run Commandwird ohne zusätzliche Kosten angeboten. Um mit Run Command zu beginnen, öffnen Sie die [Systems-Manager-Konsole](https://console.aws.amazon.com//systems-manager/run-command). Wählen Sie im Navigationsbereich **Run Command** aus.
Administratoren verwenden Run Command zum Installieren oder Bootstrapping von Anwendungen, Entwickeln einer Bereitstellungs-Pipeline, Erfassen von Protokolldateien nach Entfernung einer Instance aus einer Auto-Scaling-Gruppe, zum Anschließen von Instances an eine Windows-Domain und noch mehr.
Aufgrund der verteilten Natur des Systems, das die API unterstützt, folgt die Run Command-API einem eventuellen Konsistenzmodell. Dies bedeutet, dass das Ergebnis eines von Ihnen ausgeführten API-Befehls, der sich auf Ihre Ressourcen auswirkt, möglicherweise nicht sofort für alle nachfolgenden Befehle, die Sie ausführen, sichtbar ist. Sie sollten dies berücksichtigen, wenn Sie einen API-Befehl ausführen, der unmittelbar auf einen vorherigen API-Befehl folgt.
**Erste Schritte**
Die folgende Tabelle enthält Informationen, die Ihnen bei den ersten Schritten mit Run Command helfen werden.
****
| Thema | Details |
| --- | --- |
| [Einrichtung verwalteter Knoten für AWS Systems Manager](systems-manager-setting-up-nodes.md) | Stellen Sie sicher, dass Sie die Einrichtungsvoraussetzungen für Ihre Amazon Elastic Compute Cloud (Amazon EC2) -Instances und EC2 Nicht-Maschinen in einer [Hybrid- und Multi-Cloud-Umgebung](operating-systems-and-machine-types.md#supported-machine-types) erfüllt haben. |
| [Verwalten von Knoten in Hybrid- und Multi-Cloud-Umgebungen mit Systems Manager](systems-manager-hybrid-multicloud.md) | (Optional) Registrieren Sie lokale Server und VMs mit, AWS damit Sie sie mithilfe von verwalten können. Run Command |
| [Verwalten von Edge-Geräten mit Systems Manager](systems-manager-setting-up-edge-devices.md) | (Optional) Konfigurieren Sie Edge-Geräte, damit Sie sie mit Run Command verwalten können. |
| [Ausführen von Befehlen auf verwalteten Knoten](running-commands.md) | Erfahren Sie, wie Sie mit der AWS-Managementkonsole einen Befehl ausführen, der einen oder mehrere verwaltete Knoten anvisiert. |
| [Walkthroughs für Run Command](run-command-walkthroughs.md) | Erfahren Sie, wie Sie Befehle entweder mit Tools für Windows PowerShell oder mit dem AWS CLI ausführen. |
**EventBridge Unterstützung**
Dieses Systems Manager Manager-Tool wird in EventBridge Amazon-Regeln sowohl als *Ereignistyp* als auch als *Zieltyp* unterstützt. Weitere Informationen finden Sie unter [Überwachung von Systems Manager Manager-Ereignissen mit Amazon EventBridge](monitoring-eventbridge-events.md) und [Referenz: EventBridge Amazon-Ereignistypen und -muster für Systems Manager](reference-eventbridge-events.md).
**Weitere Informationen**
+ [Aus Run Command der Ferne auf einer EC2 Instance (10-minütiges Tutorial)](https://aws.amazon.com/getting-started/hands-on/remotely-run-commands-ec2-instance-systems-manager/)
+ [Systems Manager-Service Quotas](https://docs.aws.amazon.com/general/latest/gr/ssm.html#limits_ssm) im *Allgemeine Amazon Web Services-Referenz*
+ [AWS Systems Manager API Reference](https://docs.aws.amazon.com/systems-manager/latest/APIReference/)
**Topics**
+ [Einrichten von Run Command](run-command-setting-up.md)
+ [Ausführen von Befehlen auf verwalteten Knoten](running-commands.md)
+ [Verwendung von Beendigungscodes in Befehlen](run-command-handle-exit-status.md)
+ [Grundlegendes zu Befehlsstatus](monitor-commands.md)
+ [Walkthroughs für Run Command](run-command-walkthroughs.md)
+ [Fehlerbehebung von Systems Manager Run Command](troubleshooting-remote-commands.md)
# Einrichten von Run Command
Bevor Sie Knoten mithilfe eines Tools in verwalten können Run Command AWS Systems Manager, konfigurieren Sie eine AWS Identity and Access Management (IAM-) Richtlinie für jeden Benutzer, der Befehle ausführt. Wenn Sie in Ihren IAM-Richtlinien globale Bedingungsschlüssel für die `SendCommand`-Aktion verwenden, müssen Sie den `aws:ViaAWSService`-Bedingungsschlüssel angeben und den booleschen Wert auf `true` setzen. Im Folgenden wird ein -Beispiel gezeigt.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"ssm:SendCommand"
],
"Resource": [
"arn:aws:ssm:us-east-1:111122223333:document/YourDocument"
],
"Condition": {
"StringEquals": {
"aws:SourceVpce": [
"vpce-1234567890abcdef0"
]
}
}
},
{
"Effect": "Allow",
"Action": [
"ssm:SendCommand"
],
"Resource": [
"arn:aws:ssm:us-east-1:111122223333:document/YourDocument"
],
"Condition": {
"Bool": {
"aws:ViaAWSService": "true"
}
}
}
]
}
```
------
Sie müssen Ihre Knoten auch für Systems Manager konfigurieren. Weitere Informationen finden Sie unter [Einrichtung verwalteter Knoten für AWS Systems Manager](systems-manager-setting-up-nodes.md).
Wir empfehlen, die folgenden optionalen Einrichtungsaufgaben durchzuführen, um den Sicherheitsstatus und die day-to-day Verwaltung Ihrer verwalteten Knoten zu minimieren.
Überwachen Sie Befehlsausführungen mit Amazon EventBridge
Sie können es verwenden EventBridge , um Statusänderungen der Befehlsausführung zu protokollieren. Sie können eine Regel erstellen, die ausgeführt wird, sobald ein Statusübergang oder ein Übergang zu einem oder mehreren Status stattfindet, die für sie von Interesse sind. Sie können auch Run Command als Zielaktion angeben, wann ein EventBridge Ereignis eintritt. Weitere Informationen finden Sie unter [Konfiguration EventBridge für Systems Manager Manager-Ereignisse](monitoring-systems-manager-events.md).
Überwachen Sie Befehlsausführungen mithilfe von Amazon Logs CloudWatch
Sie können so konfigurierenRun Command, dass alle Befehlsausgaben und Fehlerprotokolle regelmäßig an eine CloudWatch Amazon-Protokollgruppe gesendet werden. Sie können diese Ausgabeprotokolle nahezu in Echtzeit überwachen, nach bestimmten Phrasen, Werten oder Mustern suchen und auf der Grundlage der Suche Warnungen erstellen. Weitere Informationen finden Sie unter [Konfiguration von Amazon CloudWatch Logs für Run Command](sysman-rc-setting-up-cwlogs.md).
Den Zugriff von Run Command auf bestimmte verwaltete Knoten beschränken
Sie können die Fähigkeit eines Benutzers einschränken, Befehle auf verwalteten Knoten auszuführen, indem Sie AWS Identity and Access Management (IAM) verwenden. Insbesondere können Sie eine IAM-Richtlinie mit der Bedingung erstellen, dass der Benutzer nur Befehle auf verwalteten Knoten ausführen kann, die mit bestimmten Tags gekennzeichnet sind. Weitere Informationen finden Sie unter [Den Zugriff von Run Command anhand von Tags beschränken](#tag-based-access).
## Den Zugriff von Run Command anhand von Tags beschränken
In diesem Abschnitt wird beschrieben, wie die Fähigkeit eines Benutzers eingeschränkt werden kann, Befehle für verwaltete Knoten auszuführen, indem eine Tag-Bedingung in einer IAM-Richtlinie angegeben wird. Zu den verwalteten Knoten gehören EC2 Amazon-Instances und EC2 Nicht-Knoten in einer [Hybrid- und Multi-Cloud-Umgebung](operating-systems-and-machine-types.md#supported-machine-types), die für Systems Manager konfiguriert sind. Die Informationen werden zwar nicht explizit dargestellt, Sie können aber auch den Zugriff auf verwaltete AWS IoT Greengrass Kerngeräte einschränken. Zuerst müssen Sie Ihre AWS IoT Greengrass -Geräte markieren. Weitere Informationen finden Sie unter [Markieren Ihrer AWS IoT Greengrass Version 2 -Ressourcen](https://docs.aws.amazon.com/greengrass/v2/developerguide/tag-resources.html) im *AWS IoT Greengrass Version 2 -Entwicklerhandbuch*.
Sie können die Befehlsausführung auf bestimmte verwaltete Knoten beschränken, indem Sie eine IAM-Richtlinie erstellen, die eine Bedingung enthält, dass der Benutzer Befehle nur auf Knoten mit bestimmten Tags ausführen kann. Im folgenden Beispiel darf der Benutzer () verwenden, indem er ein beliebiges SSM-Dokument Run Command (`Effect: Allow, Action: ssm:SendCommand`) auf einem beliebigen Knoten (`Resource: arn:aws:ssm:*:*:document/*``Resource: arn:aws:ec2:*:*:instance/*`) verwendet, unter der Bedingung, dass es sich bei dem Knoten um einen Finanzknoten WebServer (`ssm:resourceTag/Finance: WebServer`) handelt. Wenn der Benutzer einen Befehl an einen Knoten sendet, der nicht markiert ist oder ein anderes Tag als `Finance: WebServer` hat, zeigen die Ausführungsergebnisse `AccessDenied`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":[
"arn:aws:ssm:*:*:document/*"
]
},
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":[
"arn:aws:ec2:*:*:instance/*"
],
"Condition":{
"StringLike":{
"ssm:resourceTag/Finance":[
"WebServers"
]
}
}
}
]
}
```
------
Sie können IAM-Richtlinien erstellen, die es einem Benutzer erlauben, Befehle auf verwalteten Knoten auszuführen, die mit mehreren Tags markiert sind. Mit der folgenden Richtlinie hat der Benutzer die Möglichkeit, Befehle auf verwalteten Knoten auszuführen, die über zwei Tags verfügen. Wenn ein Benutzer einen Befehl an einen verwalteten Knoten sendet, der nicht mit beiden dieser Tags markiert ist, zeigen die Ausführungsergebnisse `AccessDenied`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":"*",
"Condition":{
"StringLike":{
"ssm:resourceTag/tag_key1":[
"tag_value1"
],
"ssm:resourceTag/tag_key2":[
"tag_value2"
]
}
}
},
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":[
"arn:aws:ssm:us-west-1::document/AWS-*",
"arn:aws:ssm:us-east-2::document/AWS-*"
]
},
{
"Effect":"Allow",
"Action":[
"ssm:UpdateInstanceInformation",
"ssm:ListCommands",
"ssm:ListCommandInvocations",
"ssm:GetDocument"
],
"Resource":"*"
}
]
}
```
------
Sie können auch IAM-Richtlinien erstellen, die es einem Benutzer erlauben, Befehle auf mehreren Gruppen von markierten verwalteten Knoten auszuführen. Die folgende Beispiel-Richtlinie erlaubt dem Benutzer die Ausführung von Befehlen entweder für eine der Gruppen von markierten Knoten oder für beide Gruppen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":"*",
"Condition":{
"StringLike":{
"ssm:resourceTag/tag_key1":[
"tag_value1"
]
}
}
},
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":"*",
"Condition":{
"StringLike":{
"ssm:resourceTag/tag_key2":[
"tag_value2"
]
}
}
},
{
"Effect":"Allow",
"Action":[
"ssm:SendCommand"
],
"Resource":[
"arn:aws:ssm:us-west-1::document/AWS-*",
"arn:aws:ssm:us-east-2::document/AWS-*"
]
},
{
"Effect":"Allow",
"Action":[
"ssm:UpdateInstanceInformation",
"ssm:ListCommands",
"ssm:ListCommandInvocations",
"ssm:GetDocument"
],
"Resource":"*"
}
]
}
```
------
Weitere Informationen zum Erstellen von IAM-Richtlinien finden Sie unter [Verwaltete Richtlinien und eingebundene Richtlinien](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html) im *IAM-Benutzerhandbuch*. Weitere Informationen über das Markieren verwalteter Knoten finden Sie unter [Tag-Editor](https://docs.aws.amazon.com/ARG/latest/userguide/tag-editor.html) im *AWS -Ressourcengruppen -Benutzerhandbuch*.
# Ausführen von Befehlen auf verwalteten Knoten
Dieser Abschnitt enthält Informationen darüber, wie Befehle aus der AWS Systems Manager -Konsole zu verwalteten Knoten gesendet werden. Dieser Abschnitt enthält auch Informationen zum Abbrechen eines Befehls.
Beachten Sie, dass Run Command Befehle nicht erfolgreich ausführen kann, wenn Ihr Knoten mit der `noexec`-Mount-Option für das Verzeichnis var konfiguriert ist.
**Wichtig**
Wenn Sie einen Befehl mit Run Command senden, schließen Sie keine vertraulichen Informationen ein, die als Klartext formatiert sind, z. B. Passwörter, Konfigurationsdaten oder andere Geheimnisse. Alle Systems Manager Manager-API-Aktivitäten in Ihrem Konto werden in einem S3-Bucket für AWS CloudTrail Protokolle protokolliert. Dies bedeutet, dass jeder Benutzer mit Zugriff auf den S3-Bucket die Klartextwerte dieser Geheimnisse anzeigen kann. Aus diesem Grund empfehlen wir, `SecureString`-Parameter zu erstellen und zu verwenden, um die sensiblen Daten zu verschlüsseln, die Sie in Ihren Systems-Manager-Operationen verwenden.
Weitere Informationen finden Sie unter [Einschränken des Zugriffs auf Parameter Store-Parameter mithilfe von IAM-Richtlinien](sysman-paramstore-access.md).
**Aufbewahrung des Ausführungsverlaufs**
Der Verlauf der einzelnen Befehle steht für bis zu 30 Tage zur Verfügung. Außerdem können Sie eine Kopie aller Protokolldateien in Amazon Simple Storage Service speichern oder einen Audit-Trail aller API-Aufrufe in AWS CloudTrail aufzeichnen.
**Ähnliche Informationen**
Weitere Informationen zum Ausführen von Befehlen über andere Tools finden Sie in den folgenden Themen:
+ [Exemplarische Vorgehensweise: Verwenden Sie das mit AWS Tools for Windows PowerShell Run Command](walkthrough-powershell.md)oder die Beispiele im [AWS Systems Manager Abschnitt der AWS -Tools für PowerShell Cmdlet-Referenz](https://docs.aws.amazon.com/powershell/latest/reference/items/AWS_Systems_Manager_cmdlets.html).
+ [Exemplarische Vorgehensweise: Verwenden Sie das mit AWS CLI Run Command](walkthrough-cli.md) oder die Beispiele in der [SSM-CLI-Referenz](https://docs.aws.amazon.com/cli/latest/reference/ssm/)
**Topics**
+ [Ausführen von Befehlen über die Konsole](running-commands-console.md)
+ [Ausführen von Befehlen mit einer bestimmten Dokumentversion](run-command-version.md)
+ [Ausführen von Befehlen in großem Maßstab](send-commands-multiple.md)
+ [Stornieren eines Befehls](cancel-run-command.md)
# Ausführen von Befehlen über die Konsole
Sie können ein Tool inRun Command, von verwenden AWS Systems Manager, um verwaltete Knoten AWS-Managementkonsole zu konfigurieren, ohne sich bei ihnen anmelden zu müssen. Dieses Thema enthält ein Beispiel für die Ausführung eines [SSM Agent-Updates](run-command-tutorial-update-software.md#rc-console-agentexample) auf einem verwalteten Knoten mithilfe von Run Command.
**Bevor Sie beginnen**
Bevor Sie einen Befehl mit Run Command senden, müssen Sie überprüfen, ob Ihre verwalteten Knoten die Systems-Manager-[Einrichtungs-Anforderungen](systems-manager-setting-up-nodes.md) erfüllen.
**So senden Sie einen Befehl mittels Run Command**
1. Öffnen Sie die AWS Systems Manager Konsole unter [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/).
1. Wählen Sie im Navigationsbereich **Run Command** aus.
1. Wählen Sie **Befehl ausführen** aus.
1. Wählen Sie in der Liste **Befehlsdokument** ein Systems Manager-Dokument.
1. Geben Sie im Abschnitt **Befehlsparameter** Werte für erforderliche Parameter an.
1. Identifizieren Sie für den Abschnitt **Targets** (Ziele) die verwalteten Knoten, auf denen Sie diese Operation ausführen möchten, indem Sie Tags angeben, Instances oder Edge-Geräte manuell auswählen oder eine Ressourcengruppe angeben.
**Tipp**
Wenn ein verwalteter Knoten, den Sie erwarten, nicht aufgeführt ist, finden Sie weitere Informationen unter [Problembehandlung bei der Verfügbarkeit verwalteter Knoten](fleet-manager-troubleshooting-managed-nodes.md) Tipps zur Fehlerbehebung.
1. Für **Weitere Parameter**:
+ Geben Sie im Feld **Kommentar** Informationen zu diesem Befehl ein.
+ Geben Sie für **Timeout (Sekunden)** in Sekunden an, wie lange gewartet werden soll, bis für die gesamte Befehlsausführung ein Fehler auftritt.
1. Für **Ratenregelung**:
+ Geben Sie unter **Nebenläufigkeit** entweder eine Zahl oder einen Prozentsatz der verwalteten Knoten an, auf denen der Befehl gleichzeitig ausgeführt werden soll.
**Anmerkung**
Wenn Sie Ziele ausgewählt haben, indem Sie Tags für verwaltete Knoten oder AWS Ressourcengruppen angegeben haben und Sie sich nicht sicher sind, wie viele verwaltete Knoten das Ziel sind, schränken Sie die Anzahl der Ziele ein, die das Dokument gleichzeitig ausführen können, indem Sie einen Prozentsatz angeben.
+ Geben Sie unter **Fehlerschwellenwert** an, wann die Ausführung des Befehls auf anderen verwalteten Knoten beendet werden soll, nachdem dafür entweder auf einer bestimmten Anzahl oder einem Prozentsatz von Knoten ein Fehler aufgetreten ist. Falls Sie beispielsweise drei Fehler angeben, sendet Systems Manager keinen Befehl mehr, wenn der vierte Fehler empfangen wird. Von verwalteten Knoten, auf denen der Befehl noch verarbeitet wird, werden unter Umständen ebenfalls Fehler gesendet.
1. (Optional) Wählen Sie einen CloudWatch Alarm aus, der auf Ihren Überwachungsbefehl angewendet werden soll. Um Ihrem Befehl einen CloudWatch Alarm hinzuzufügen, muss der IAM-Principal, der den Befehl ausführt, über die entsprechende Berechtigung verfügen`iam:createServiceLinkedRole`. Weitere Informationen zu CloudWatch Alarmen finden Sie unter [ CloudWatch Amazon-Alarme verwenden](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html). Beachten Sie, dass ausstehende Befehlsaufrufe nicht ausgeführt werden, wenn Ihr Alarm aktiviert wird.
1. (Optional) Wenn Sie im Abschnitt **Ausgabeoptionen** die Befehlsausgabe in einer Datei speichern möchten, aktivieren Sie das Kontrollkästchen **Schreiben in einen S3-Bucket aktivieren**. Geben Sie die Namen für den Bucket und das Präfix (Ordner) in die Textfelder ein.
**Anmerkung**
Bei den S3-Berechtigungen, die das Schreiben der Daten in einen S3-Bucket ermöglichen, handelt es sich um die Berechtigungen des Instance-Profils (für EC2 Instances) oder der IAM-Servicerolle (hybridaktivierte Maschinen), die der Instance zugewiesen wurden, nicht um die des IAM-Benutzers, der diese Aufgabe ausführt. Weitere Informationen finden Sie unter [Instance-Berechtigungen für Systems Manager konfigurieren](setup-instance-permissions.md) oder [Eine IAM-Servicerolle für eine Hybrid-Umgebung erstellen](hybrid-multicloud-service-role.md). Wenn sich der angegebene S3-Bucket in einem anderen AWS-Konto befindet, stellen Sie außerdem sicher, dass das Instance-Profil oder die IAM-Servicerolle, die dem verwalteten Knoten zugeordnet ist, über die erforderlichen Berechtigungen zum Schreiben in diesen Bucket verfügt.
1. Aktivieren Sie das Kontrollkästchen **SNS-Benachrichtigungen aktivieren** im Abschnitt **SNS-Benachrichtigungen**, wenn Sie über den Status der Befehlsausführung benachrichtigt werden möchten,
Weitere Informationen zum Konfigurieren von Amazon-SNS-Benachrichtigungen für Run Command finden Sie unter [Überwachung von Systems Manager-Statusänderungen mit Amazon SNS-Benachrichtigungen](monitoring-sns-notifications.md).
1. Klicken Sie auf **Ausführen**.
Weitere Informationen zum Abbrechen eines Befehls finden Sie unter [Stornieren eines Befehls](cancel-run-command.md).
## Erneutes Ausführen von Befehlen
Systems Manager enthält zwei Optionen, mit denen Sie einen Befehl auf der Seite **Run Command (Befehl ausführen)** in der Systems Manager-Konsole erneut ausführen können.
+ **Rerun (Erneut ausführen)**: Über diese Schaltfläche können Sie denselben Befehl ausführen, ohne Änderungen daran vorzunehmen.
+ **In neu kopieren**: Über diese Schaltfläche kopieren Sie die Einstellungen eines Befehls in einen neuen Befehl und erhalten die Möglichkeit, diese Einstellungen zu bearbeiten, bevor Sie den Befehl ausführen.
**So führen Sie einen Befehl erneut aus**
1. Öffnen Sie die Konsole unter. AWS Systems Manager [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/)
1. Wählen Sie im Navigationsbereich **Run Command** aus.
1. Wählen Sie einen Befehl aus, der erneut ausgeführt werden soll. Sie können einen Befehl unmittelbar nach der Ausführung von der Befehlsdetailseite aus erneut ausführen. Sie können auch einen Befehl auswählen, den Sie zuvor auf der Registerkarte **Command history (Befehlsverlauf)** ausgeführt haben.
1. Wählen Sie entweder **Rerun (Erneut ausführen)** aus, um denselben Befehl ohne Änderungen auszuführen, oder wählen Sie **Copy to new (In neuen kopieren)** aus, um die Befehlseinstellungen zu bearbeiten, bevor Sie den Befehl ausführen.
# Ausführen von Befehlen mit einer bestimmten Dokumentversion
Sie können den Dokumentversionsparameter verwenden, um anzugeben, welche Version eines AWS Systems Manager -Dokuments verwendet werden soll, wenn der Befehl ausgeführt wird. Sie können eine der folgenden Optionen für diesen Parameter festlegen:
+ \$1DEFAULT
+ \$1LATEST
+ Versionsnummer:
Gehen Sie wie folgt vor, um einen Befehl unter Verwendung des Dokumentversionsparameters auszuführen.
------
#### [ Linux ]
**Um Befehle mit dem AWS CLI auf lokalen Linux-Computern auszuführen**
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
Dieser Befehl listet alle für Ihr Konto verfügbaren Dokumente auf der Grundlage von AWS Identity and Access Management (IAM-) Berechtigungen auf.
```
aws ssm list-documents
```
1. Verwenden Sie den folgenden Befehl, um die verschiedenen Versionen eines Dokuments anzuzeigen. Ersetzen Sie es *document name* durch Ihre eigenen Informationen.
```
aws ssm list-document-versions \
--name "document name"
```
1. Führen Sie mit dem folgenden Befehl einen Befehl aus, der eine SSM-Dokumentversion verwendet. Ersetzen Sie jeden *example resource placeholder* durch Ihre Informationen.
```
aws ssm send-command \
--document-name "AWS-RunShellScript" \
--parameters commands="echo Hello" \
--instance-ids instance-ID \
--document-version '$LATEST'
```
------
#### [ Windows ]
**Um Befehle mit dem AWS CLI auf lokalen Windows-Computern auszuführen**
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
Dieser Befehl listet alle für Ihr Konto verfügbaren Dokumente auf der Grundlage von AWS Identity and Access Management (IAM-) Berechtigungen auf.
```
aws ssm list-documents
```
1. Verwenden Sie den folgenden Befehl, um die verschiedenen Versionen eines Dokuments anzuzeigen. Ersetzen Sie es *document name* durch Ihre eigenen Informationen.
```
aws ssm list-document-versions ^
--name "document name"
```
1. Führen Sie mit dem folgenden Befehl einen Befehl aus, der eine SSM-Dokumentversion verwendet. Ersetzen Sie jeden *example resource placeholder* durch Ihre Informationen.
```
aws ssm send-command ^
--document-name "AWS-RunShellScript" ^
--parameters commands="echo Hello" ^
--instance-ids instance-ID ^
--document-version "$LATEST"
```
------
#### [ PowerShell ]
**Um Befehle mit den Tools für auszuführen PowerShell**
1. Installieren und konfigurieren Sie die AWS -Tools für PowerShell (Tools für Windows PowerShell), falls Sie dies noch nicht getan haben.
Weitere Informationen finden Sie unter [Installieren des AWS -Tools für PowerShell](https://docs.aws.amazon.com/powershell/latest/userguide/pstools-getting-set-up.html).
1. Listen Sie alle verfügbaren Dokumente auf
Dieser Befehl listet alle für Ihr Konto verfügbaren Dokumente auf der Grundlage von AWS Identity and Access Management (IAM-) Berechtigungen auf.
```
Get-SSMDocumentList
```
1. Verwenden Sie den folgenden Befehl, um die verschiedenen Versionen eines Dokuments anzuzeigen. Ersetzen Sie es *document name* durch Ihre eigenen Informationen.
```
Get-SSMDocumentVersionList `
-Name "document name"
```
1. Führen Sie mit dem folgenden Befehl einen Befehl aus, der eine SSM-Dokumentversion verwendet. Ersetzen Sie jeden *example resource placeholder* durch Ihre Informationen.
```
Send-SSMCommand `
-DocumentName "AWS-RunShellScript" `
-Parameter @{commands = "echo helloWorld"} `
-InstanceIds "instance-ID" `
-DocumentVersion $LATEST
```
------
# Ausführen von Befehlen in großem Maßstab
Sie könnenRun Command, ein Tool in AWS Systems Manager, verwenden, um Befehle auf einer Flotte verwalteter Knoten auszuführen, indem Sie den verwenden`targets`. Der `targets`-Parameter nimmt eine `Key,Value`-Kombination basierend auf Tags an, die Sie für Ihre verwalteten Knoten angegeben haben. Wenn Sie den Befehl ausführen, versucht das System, den Befehl auf allen verwalteten Knoten auszuführen, die den angegebenen Tags entsprechen. Weitere Informationen zum Taggen verwalteter Instances finden Sie unter [Tagging Your AWS Resources](https://docs.aws.amazon.com/tag-editor/latest/userguide/tag-editor.html) im *Tagging AWS Resources* User Guide. Informationen zum Taggen Ihrer verwalteten IoT-Geräte finden Sie unter [Taggen Ihrer AWS IoT Greengrass Version 2 Ressourcen](https://docs.aws.amazon.com/greengrass/v2/developerguide/tag-resources.html) im *AWS IoT Greengrass Version 2 Entwicklerhandbuch*.
Sie können den `targets` Parameter auch verwenden, um eine Liste bestimmter verwalteter Knoten als Ziel IDs festzulegen, wie im nächsten Abschnitt beschrieben.
Zur Steuerung der Befehlsausführung auf Hunderten und Tausenden von verwalteten Knoten umfasst Run Command auch Parameter für die Einschränkung, wie viele Knoten gleichzeitig eine Anforderung verarbeitet können, und wie viele Fehler durch einen Befehl ausgelöst werden können, bevor der Befehl beendet wird.
**Topics**
+ [Mehrere verwaltete Knoten anvisieren](#send-commands-targeting)
+ [Verwenden von Ratensteuerungen](#send-commands-rate)
## Mehrere verwaltete Knoten anvisieren
Sie können einen Befehl ausführen und auf verwaltete Knoten abzielen, indem Sie Tags, AWS Ressourcengruppennamen oder verwaltete Knoten angeben IDs.
Die folgenden Beispiele zeigen das Befehlsformat bei der Verwendung Run Command von from the AWS Command Line Interface (AWS CLI ). Ersetzen Sie jeden *example resource placeholder* durch Ihre Informationen. Die Beispielbefehle werden in diesem Abschnitt sind mit `[...]` abgeschnitten.
**Beispiel 1: Angabe von Tags als Ziel**
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:tag-name,Values=tag-value \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:tag-name,Values=tag-value ^
[...]
```
------
**Beispiel 2: Eine AWS Ressourcengruppe anhand des Namens als Zielgruppenadressierung**
Sie können maximal einen Ressourcengruppenamen pro Befehlsaufruf angeben. Wenn Sie eine Ressourcengruppe erstellen, empfehlen wir, `AWS::SSM:ManagedInstance` und `AWS::EC2::Instance` als Ressourcentypen in dem Gruppierungskriterium aufzunehmen.
**Anmerkung**
Um Befehle senden zu können, die auf eine Ressourcengruppe abzielen, müssen Ihnen AWS Identity and Access Management (IAM) Berechtigungen zum Auflisten oder Anzeigen der Ressourcen, die zu dieser Gruppe gehören, erteilt worden sein. Weitere Informationen finden Sie unter [Einrichten von Berechtigungen](https://docs.aws.amazon.com/ARG/latest/userguide/gettingstarted-prereqs.html#gettingstarted-prereqs-permissions) im *AWS -Ressourcengruppen -Benutzerhandbuch*.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=resource-groups:Name,Values=resource-group-name \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=resource-groups:Name,Values=resource-group-name ^
[...]
```
------
**Beispiel 3: Ausrichtung auf eine AWS Ressourcengruppe nach Ressourcentyp**
Sie können maximal fünf Ressourcengruppentypen pro Befehlsaufruf angeben. Wenn Sie eine Ressourcengruppe erstellen, empfehlen wir, `AWS::SSM:ManagedInstance` und `AWS::EC2::Instance` als Ressourcentypen in dem Gruppierungskriterium aufzunehmen.
**Anmerkung**
Zum Senden von Befehlen mit einer Ressourcengruppe als Ziel benötigen Sie IAM-Berechtigungen zum Auflisten oder Anzeigen der Ressourcen, die zu der Gruppe gehören. Weitere Informationen finden Sie unter [Einrichten von Berechtigungen](https://docs.aws.amazon.com/ARG/latest/userguide/gettingstarted-prereqs.html#gettingstarted-prereqs-permissions) im *AWS -Ressourcengruppen -Benutzerhandbuch*.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=resource-groups:ResourceTypeFilters,Values=resource-type-1,resource-type-2 \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=resource-groups:ResourceTypeFilters,Values=resource-type-1,resource-type-2 ^
[...]
```
------
**Beispiel 4: Zielinstanz IDs**
Die folgenden Beispiele veranschaulichen, wie verwaltete Knoten mithilfe des `instanceids`-Schlüssels mit dem `targets`-Parameter anvisiert werden können. Sie können diesen Schlüssel verwenden, um verwaltete AWS IoT Greengrass Kerngeräte als Ziel zu verwenden, da jedem Gerät ein Mi- zugewiesen ist*ID\$1number*. Sie können das Gerät IDs in anzeigenFleet Manager, ein Tool in AWS Systems Manager.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=instanceids,Values=instance-ID-1,instance-ID-2,instance-ID-3 \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=instanceids,Values=instance-ID-1,instance-ID-2,instance-ID-3 ^
[...]
```
------
Wenn Sie verwaltete Knoten für unterschiedliche Umgebungen mit einem `Key` namens `Environment` und `Values` von `Development`, `Test`, `Pre-production` und`Production` markiert haben, könnten Sie einen Befehl an alle verwalteten Knoten in *einer* dieser Umgebungen mit dem `targets`-Parameter mit der folgenden Syntax senden.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Environment,Values=Development \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Environment,Values=Development ^
[...]
```
------
Sie könnten weitere verwaltete Knoten in anderen Umgebungen auswählen, indem Sie sie zur `Values`-Liste hinzufügen. Trennen Sie die Elemente durch Kommas.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Environment,Values=Development,Test,Pre-production \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Environment,Values=Development,Test,Pre-production ^
[...]
```
------
**Variation**: Anpassung Ihrer Ziele mit mehreren `Key`-Kriterien
Sie können die Anzahl der Ziele für Ihren Befehl verfeinern, indem Sie mehrere `Key` Kriterien berücksichtigen. Wenn Sie mehr als ein `Key`-Kriterium einschließen, wird das System verwaltete Knoten anvisieren, die *alle* Kriterien erfüllen. Mit dem folgenden Befehl werden alle verwaltete Knoten anvisiert, die für die Finanzabteilung *und* für die Datenbankserver-Rolle markiert sind.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Department,Values=Finance Key=tag:ServerRole,Values=Database \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Department,Values=Finance Key=tag:ServerRole,Values=Database ^
[...]
```
------
**Variation**: Verwenden mehrerer `Key`- und `Value`-Kriterien
Aufbauend auf dem vorherigen Beispiel können Sie mehrere Abteilungen und mehrere Server-Rollen auswählen, indem zusätzliche Elemente in die `Values` Kriterien einfügen.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Department,Values=Finance,Marketing Key=tag:ServerRole,Values=WebServer,Database \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Department,Values=Finance,Marketing Key=tag:ServerRole,Values=WebServer,Database ^
[...]
```
------
**Variation**: Anvisieren markierter verwalteter Knoten mithilfe von mehreren `Values`-Kriterien
Wenn Sie verwaltete Knoten für unterschiedliche Umgebungen mit einem `Key` namens `Department` und `Values` von `Sales` und `Finance` markiert haben, könnten Sie einen Befehl an alle Knoten in diesen Umgebungen mit dem `targets`-Parameter mit der folgenden Syntax senden.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Department,Values=Sales,Finance \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Department,Values=Sales,Finance ^
[...]
```
------
Sie können maximal fünf Schlüssel und fünf Werte für jeden Schlüssel angeben.
Wenn entweder ein Tag-Schlüssel (der Variablenname) oder eine Tag-Wert Leerzeichen enthält, setzen Sie den Tagschlüssel oder den Wert in Anführungszeichen, wie in den folgenden Beispielen gezeigt.
**Beispiel**: Leerzeichen in `Value`-Tag
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:OS,Values="Windows Server 2016" \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:OS,Values="Windows Server 2016" ^
[...]
```
------
**Beispiel**: Leerzeichen in `tag`-Schlüssel und `Value`
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key="tag:Operating System",Values="Windows Server 2016" \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key="tag:Operating System",Values="Windows Server 2016" ^
[...]
```
------
**Beispiel**: Leerzeichen in einem Element in einer Liste von `Values`
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--targets Key=tag:Department,Values="Sales","Finance","Systems Mgmt" \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--targets Key=tag:Department,Values="Sales","Finance","Systems Mgmt" ^
[...]
```
------
## Verwenden von Ratensteuerungen
Sie können das Tempo steuern, mit dem Befehle an verwaltete Knoten in einer Gruppe gesendet werden, indem Sie *Nebenläufigkeits-Kontrollen* und *Fehlerkontrollen* verwenden.
**Topics**
+ [Verwenden von Gleichzeitigkeitssteuerungen](#send-commands-velocity)
+ [Verwenden von Fehlersteuerungen](#send-commands-maxerrors)
### Verwenden von Gleichzeitigkeitssteuerungen
Sie können die Anzahl der verwalteten Knoten steuern, die einen Befehl gleichzeitig ausführen, indem Sie den `max-concurrency`-Parameter verwenden (die **Concurrency** (Nebenläufigkeit)-Optionen auf der Seite **Run a command** (Befehl ausführen). Sie können entweder eine absolute Anzahl an verwalteten Knoten, z. B. **10**, oder einen Prozentsatz des festgelegten Ziels, beispielsweise **10%**, angeben. Das Warteschlangensystem liefert den Befehl an einen einzelnen Knoten und wartet, bis das System den ersten Aufruf bestätigt hat, bevor der Befehl an zwei weitere Knoten gesendet wird. Das System sendet exponentiell Befehle an mehrere Knoten, bis das System den Wert `max-concurrency` erreicht hat. Der Standardwert `max-concurrency` beträgt 50. Die folgenden Beispiele zeigen, wie Sie Werte für den Parameter `max-concurrency` angeben.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--max-concurrency 10 \
--targets Key=tag:Environment,Values=Development \
[...]
```
```
aws ssm send-command \
--document-name document-name \
--max-concurrency 10% \
--targets Key=tag:Department,Values=Finance,Marketing Key=tag:ServerRole,Values=WebServer,Database \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--max-concurrency 10 ^
--targets Key=tag:Environment,Values=Development ^
[...]
```
```
aws ssm send-command ^
--document-name document-name ^
--max-concurrency 10% ^
--targets Key=tag:Department,Values=Finance,Marketing Key=tag:ServerRole,Values=WebServer,Database ^
[...]
```
------
### Verwenden von Fehlersteuerungen
Sie können auch die Ausführung eines Befehls auf Hunderten oder Tausenden von verwalteten Knoten steuern, indem Sie eine Fehlerbegrenzung mit den `max-errors`-Parametern einstellen (das Feld **Error threshold** (Fehlerschwelle) auf der Seite **Run a command** (Befehl ausführen)). Der Parameter gibt an, wie viele Fehler zulässig sind, bevor das System keinen Befehl mehr an zusätzliche verwaltete Knoten sendet. Sie können entweder eine absolute Anzahl an Fehlern, z. B. **10**, oder einen Prozentsatz des festgelegten Ziels, beispielsweise **10%**, festlegen. Wenn Sie z. B. **3** angeben, sendet das System keinen Befehl mehr, wenn der vierte Fehler empfangen wird. Wenn Sie **0** angeben, sendet das System keinen weiteren Befehl an zusätzliche verwaltete Knoten, nachdem das erste Fehlerergebnis zurückgegeben wird. Wenn Sie einen Befehl an 50 verwaltete Knoten senden und `max-errors` auf **10%** einstellen, sendet das System keinen Befehl mehr an weitere Knoten, wenn der sechste Fehler empfangen wird.
Aufrufe, die bereits einen Befehl ausführen, wenn `max-errors` erreicht ist, dürfen abgeschlossen werden, jedoch können einige dieser Aufrufe ebenso fehlschlagen. Wenn Sie sicherstellen müssen, dass es nicht mehr als `max-errors` fehlgeschlagene Aufrufe geben wird, setzen Sie `max-concurrency` auf **1**, sodass die Aufrufe jeweils um eins fortfahren. Die Standardwert für max-errors ist 0. Die folgenden Beispiele zeigen, wie Sie Werte für den Parameter `max-errors` angeben.
------
#### [ Linux & macOS ]
```
aws ssm send-command \
--document-name document-name \
--max-errors 10 \
--targets Key=tag:Database,Values=Development \
[...]
```
```
aws ssm send-command \
--document-name document-name \
--max-errors 10% \
--targets Key=tag:Environment,Values=Development \
[...]
```
```
aws ssm send-command \
--document-name document-name \
--max-concurrency 1 \
--max-errors 1 \
--targets Key=tag:Environment,Values=Production \
[...]
```
------
#### [ Windows ]
```
aws ssm send-command ^
--document-name document-name ^
--max-errors 10 ^
--targets Key=tag:Database,Values=Development ^
[...]
```
```
aws ssm send-command ^
--document-name document-name ^
--max-errors 10% ^
--targets Key=tag:Environment,Values=Development ^
[...]
```
```
aws ssm send-command ^
--document-name document-name ^
--max-concurrency 1 ^
--max-errors 1 ^
--targets Key=tag:Environment,Values=Production ^
[...]
```
------
# Stornieren eines Befehls
Sie können versuchen, einen Befehl abzubrechen, solange der Service entweder im Ausstehenden oder Ausführenden Status angezeigt wird. Wenn jedoch ein Befehl sich nach wie vor in einem dieser Zustände befindet, können wir nicht garantieren, dass der Befehl beendet wird und der zugrunde liegenden Prozess gestoppt wurde.
**So stornieren Sie einen Befehl mithilfe der Konsole**
1. Öffnen Sie die AWS Systems Manager-Konsole unter [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/).
1. Wählen Sie im Navigationsbereich **Run Command** aus.
1. Wählen Sie den Befehlsaufruf, den Sie stornieren möchten.
1. Wählen Sie **Cancel Command**.
**So stornieren Sie einen Befehl mithilfe der AWS CLI**
Führen Sie den folgenden Befehl aus. Ersetzen Sie jeden *Beispiel Platzhalter für Ressourcen* mit Ihren eigenen Informationen.
------
#### [ Linux & macOS ]
```
aws ssm cancel-command \
--command-id "command-ID" \
--instance-ids "instance-ID"
```
------
#### [ Windows ]
```
aws ssm cancel-command ^
--command-id "command-ID" ^
--instance-ids "instance-ID"
```
------
Weitere Informationen über den Status eines stornierten Befehls finden Sie unter [Grundlegendes zu Befehlsstatus](monitor-commands.md).
# Verwendung von Beendigungscodes in Befehlen
In einigen Fällen müssen Sie möglicherweise mithilfe von Beendigungscodes verwalten, wie Ihre Befehle verarbeitet werden.
## Angabe von Beendigungscodes in Befehlen
Mit Run Command, einem Tool in AWS Systems Manager, können Sie Beendigungscodes angeben, um festzulegen, wie Befehle verarbeitet werden. Standardmäßig wird der Beendigungscode des letzten in einem Skript ausgeführten Befehls als Beendigungscode für das gesamte Skript gemeldet. Sie haben beispielsweise ein Skript, das drei Befehle enthält. Der erste schlägt fehl, die folgenden werden jedoch erfolgreich ausgeführt. Da der letzte Befehl erfolgreich war, wird der Status der Ausführung als `succeeded` gemeldet.
**Shell-Skripts**
Damit das gesamte Skript beim ersten Befehlsfehler fehlschlägt, können Sie eine bedingte Shell-Anweisung einschließen, sodass das Skript beendet wird, wenn ein Befehl vor dem letzten Befehl fehlschlägt. Gehen Sie wie folgt vor.
```
if [ $? != 0 ]
then
exit
fi
```
Im folgenden Beispiel schlägt das gesamte Skript fehl, wenn der erste Befehl fehlschlägt.
```
cd /test
if [ $? != 0 ]
then
echo "Failed"
exit 1
fi
date
```
**PowerShell-Skripts**
PowerShell erfordert, dass Sie `exit` explizit in Ihren Skripts aufrufen, damit Run Command den Beendigungscode erfolgreich erfassen kann.
```
if ($?) {}
else {exit }
exit
```
Ein Beispiel:
```
cd C:\
if ($?) {echo "Success"}
else {exit 1}
date
```
# Umgang mit Neustarts beim Ausführen von Befehlen
Wenn Sie ein Tool in verwenden Run Command AWS Systems Manager, um Skripts auszuführen, die verwaltete Knoten neu starten, empfehlen wir, dass Sie in Ihrem Skript einen Exit-Code angeben. Wenn Sie versuchen, einen Knoten von einem Skript aus mit einem anderen Verfahren neu zu starten, wird der Ausführungsstatus des Skripts möglicherweise nicht korrekt aktualisiert. Dies passiert auch dann, wenn der Neustart der letzte Schritt in Ihrem Skript ist. Für Windows-verwaltete Knoten geben Sie `exit 3010` in Ihrem Skript an. Für Linux- und macOS-verwaltete Knoten geben Sie `exit 194` an. Der Exit-Code weist AWS Systems Manager Agent (SSM Agent) an, den verwalteten Knoten neu zu starten und das Skript nach Abschluss des Neustarts neu zu starten. Vor dem Neustart informiert SSM Agent den Systems Manager-Service in der Cloud, dass die Kommunikation während des Serverneustarts unterbrochen werden wird.
**Anmerkung**
Das Neustartskript kann nicht Teil eines `aws:runDocument`-Plugins sein. Wenn ein Dokument das Neustartskript enthält und ein anderes Dokument versucht, dieses Dokument über das `aws:runDocument`-Plugin auszuführen, gibt SSM Agent einen Fehler zurück.
**Idempotente Skripts erstellen**
Bei der Entwicklung von Skripts, die verwaltete Knoten neu starten, machen Sie die Skripts idempotent, damit die Skriptausführung nach dem Neustart an der Stelle fortgesetzt wird, wo sie unterbrochen wurde. Idempotente Skripts verwalten den Status und prüfen, ob die Aktion ausgeführt wurde oder nicht. Dadurch wird verhindert, dass ein Schritt mehrmals ausgeführt wird, wenn er nur einmal ausgeführt werden soll.
Hier finden Sie ein Beispiel für ein idempotentes Skript, das einen verwalteten Knoten mehrfach neu startet.
```
$name = Get current computer name
If ($name –ne $desiredName)
{
Rename computer
exit 3010
}
$domain = Get current domain name
If ($domain –ne $desiredDomain)
{
Join domain
exit 3010
}
If (desired package not installed)
{
Install package
exit 3010
}
```
**Beispiele**
Die folgenden Skript-Beispiele verwenden Beendigungscodes für den Neustart von verwalteten Knoten. Das Linux-Beispiel installiert Paket-Updates auf Amazon Linux und startet den Knoten dann neu. Das Windows Server-Beispiel installiert den Telnet-Client auf dem Knoten und startet ihn dann neu.
------
#### [ Amazon Linux 2 ]
```
#!/bin/bash
yum -y update
needs-restarting -r
if [ $? -eq 1 ]
then
exit 194
else
exit 0
fi
```
------
#### [ Windows ]
```
$telnet = Get-WindowsFeature -Name Telnet-Client
if (-not $telnet.Installed)
{
# Install Telnet and then send a reboot request to SSM Agent.
Install-WindowsFeature -Name "Telnet-Client"
exit 3010
}
```
------
# Grundlegendes zu Befehlsstatus
Run Command, ein Tool in AWS Systems Manager, meldet detaillierte Statusinformationen zu den verschiedenen Zuständen, die ein Befehl während der Verarbeitung erlebt, und für jeden verwalteten Knoten, der den Befehl verarbeitet hat. Sie können Befehlsstatus mithilfe der folgenden Methoden überwachen:
+ Wählen Sie das Symbol **Refresh** (Aktualisieren) auf der Registerkarte **Commands** (Befehle) in der Run Command-Konsolenschnittstelle.
+ Rufen Sie [list-commands](https://docs.aws.amazon.com/cli/latest/reference/ssm/list-commands.html) auf oder [list-command-invocations](https://docs.aws.amazon.com/cli/latest/reference/ssm/list-command-invocations.html)verwenden Sie die AWS Command Line Interface ()AWS CLI. Oder rufen Sie [Get- SSMCommand](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-SSMCommand.html) oder [Get- SSMCommand Invocation](https://docs.aws.amazon.com/powershell/latest/reference/items/Get-SSMCommandInvocation.html) auf mit. AWS Tools for Windows PowerShell
+ Konfigurieren Sie Amazon so EventBridge , dass es auf Status- oder Statusänderungen reagiert.
+ Konfigurieren Sie Amazon Simple Notification Service (Amazon SNS), um Benachrichtigungen für alle Statusänderungen oder bestimmte Status wie `Failed` oder `TimedOut` zu senden.
## Run Command-Status
Run Command berichtet Statusdetails für drei Bereiche: Plugins, Aufrufe und eine allgemeinen Compliance-Befehl. Ein *Plugin* ist ein Code-Ausführungsblock, der im SSM-Dokument des Befehls definiert ist. Weitere Informationen zu den Plugins finden Sie unter [Referenz für Befehlsdokument-Plugins](documents-command-ssm-plugin-reference.md).
Wenn Sie einen Befehl an mehrere verwaltete Knoten gleichzeitig senden, ist jede Kopie des Befehls, die jeden Knoten anvisiert, ein *Befehlsaufruf*. Wenn Sie z. B. das `AWS-RunShellScript`-Dokument verwenden und einen `ifconfig`-Befehl an 20 Linux-Instances senden, hat dieser Befehl 20 Aufrufe. Jeder Befehlsaufruf berichtet einzeln einen Status. Die Plugins für einen bestimmten Befehlsaufruf berichten ebenfalls einzeln einen Berichtstatus.
Schließlich umfasst Run Command einen zusammenfassenden Befehlsstatus für alle Plugins und Aufrufe. Der aggregierte Befehlsstatus kann von dem Status, der von Plugins oder Aufrufen gemeldet wird, wie in den folgenden Tabellen gezeigt, abweichen.
**Anmerkung**
Wenn Sie Befehle mit den Parametern `max-concurrency` oder `max-errors` für eine großen Anzahl von verwalteten Knoten ausführen, spiegelt der Befehlsstatus die durch diese Parameter auferlegten Grenzen wider, wie in den folgenden Tabellen beschrieben. Weitere Informationen zu diesen Parametern finden Sie unter [Ausführen von Befehlen in großem Maßstab](send-commands-multiple.md).
**Detaillierter Status für Befehls-Plugins und Aufrufe**
| Status | Details |
| --- | --- |
| Ausstehend | Der Befehl wurde noch nicht an den verwalteten Knoten gesendet oder wurde nicht vom SSM Agent empfangen. Wird der Befehl nicht vor Ablauf der Zeitspanne, die der Summe aus dem Parameter Timeout (seconds) und dem Parameter Execution timeout entspricht, vom Agenten empfangen, ändert sich der Status in Delivery Timed Out. |
| InProgress | Systems Manager versucht, den Befehl an den verwalteten Knoten zu senden, oder der Befehl wurde vom SSM Agent empfangen und wird auf der Instance ausgeführt. Je nach Ergebnis aller Befehls-Plugins ändert sich der Status in Success, Failed, Delivery Timed Out, oder Execution Timed Out. Ausnahme: Wenn der Agent nicht ausgeführt oder auf dem Knoten nicht verfügbar ist, bleibt der Befehlsstatus bei In Progress, bis der Agent wieder verfügbar ist oder bis das Ausführungs-Timeout-Limit erreicht ist. Der Status wechselt dann in einen Terminal-Status. |
| Verzögert | Das System versuchte, den Befehl an den verwalteten Knoten zu senden, war jedoch nicht erfolgreich. Das System startet einen erneuten Versuch. |
| Herzlichen Glückwunsch | Dieser Status wird unter verschiedenen Bedingungen zurückgegeben. Dieser Status bedeutet nicht, dass der Befehl auf dem Knoten verarbeitet wurde. Der Befehl kann beispielsweise SSM Agent auf dem verwalteten Knoten empfangen werden und den Exit-Code Null zurückgeben, wenn Sie die Ausführung des Befehls PowerShell ExecutionPolicy verhindern. Diese ist ein Terminalstatus. Bedingungen, die dazu führen, dass ein Befehl einen Success Status zurückgibt, sind: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/systems-manager/latest/userguide/monitor-commands.html) Dieselben Bedingungen gelten für die Ausrichtung auf Ressourcengruppen. Um Fehler zu beheben oder weitere Informationen über die Befehlsausführung zu erhalten, senden Sie einen Befehl, der Fehler oder Ausnahmen handhabt, indem er entsprechende Beendigungscodes (Ausgangscodes für fehlgeschlagenen Befehl (nicht null)) zurückgibt. |
| DeliveryTimedOut | Der Befehl wurde nicht an den verwalteten Knoten übermittelt, bevor die gesamte Zeitbeschränkung abgelaufen ist. Gesamtausfälle werden nicht auf die übergeordnete Befehlsbegrenzung angerechnet max-errors, aber sie tragen dazu bei, ob der übergeordnete Befehlsstatus Success, Incomplete oder Delivery Timed Out ist. Diese ist ein Terminalstatus. |
| ExecutionTimedOut | Die Befehlsautomatisierung begann auf dem verwalteten Knoten, aber der Befehl wurde vor Ablauf des Ausführungs-Timeouts nicht abgeschlossen. Ausführungs-Timeouts zählen als Fehler, wodurch eine Antwort ungleich Null gesendet wird, und Systems Manager beendet den Versuch, die Befehlsautomatisierung auszuführen, und meldet einen Fehlerstatus. |
| Fehlgeschlagen | Der Befehl war auf dem verwalteten Knoten nicht erfolgreich. Für ein Plugin bedeutet dies, dass der Ergebniscode nicht null war. Für einen Befehlsaufruf bedeutet dies, dass der Ergebniscode für ein oder mehrere Plugins nicht null war. Zeitüberschreitungen beim Aufrufen werden auf das max-errors Limit des übergeordneten Befehls angerechnet. Diese ist ein Terminalstatus. |
| Abgebrochen | Der Befehl wurde beendet, bevor er abgeschlossen wurde. Diese ist ein Terminalstatus. |
| Unzustellbar | Der Befehl kann nicht an den verwalteten Knoten übermittelt werden. Der Knoten existiert möglicherweise nicht oder antwortet nicht. Unzustellbare Aufrufe werden nicht auf die übergeordnete Befehlsbegrenzung angerechnet max-errors, aber sie tragen dazu bei, ob der übergeordnete Befehlsstatus Success oder Incomplete ist. Wenn beispielsweise alle Aufrufe in einem Befehl den Status Undeliverable haben, lautet der zurückgegebene Befehlsstatus Failed. Wenn ein Befehl jedoch fünf Aufrufe hat, von denen vier den Status Undeliverable zurückgeben und einer den Status Success zurückgibt, lautet der Status des übergeordneten Befehls Success. Diese ist ein Terminalstatus. |
| Beendet | Der übergeordnete Befehl hat sein Limit max-errors überschritten, und nachfolgende Befehlsaufrufe wurden vom System abgebrochen. Diese ist ein Terminalstatus. |
| InvalidPlatform | Der Befehl wurde an einen verwalteten Knoten gesendet, der nicht den erforderlichen Plattformen entspricht, wie sie im ausgewählten Dokument festgelegt wurden. Invalid Platform wird nicht auf die maximale Fehlerbegrenzung des übergeordneten Befehls angerechnet, aber es trägt dazu bei, ob der übergeordnete Befehlsstatus Success oder Failed lautet. Wenn beispielsweise alle Aufrufe in einem Befehl den Status Invalid Platform haben, lautet der zurückgegebene Befehlsstatus Failed. Wenn ein Befehl jedoch fünf Aufrufe hat, von denen vier den Status Invalid Platform zurückgeben und einer den Status Success zurückgibt, lautet der Status des übergeordneten Befehls Success. Diese ist ein Terminalstatus. |
| AccessDenied | Der AWS Identity and Access Management (IAM-) Benutzer oder die Rolle, die den Befehl initiiert hat, hat keinen Zugriff auf den verwalteten Zielknoten. Access Deniedwird nicht auf das max-errors Limit des übergeordneten Befehls angerechnet, trägt aber dazu bei, ob der Status des übergeordneten Befehls oder lautetSuccess. Failed Wenn beispielsweise alle Aufrufe in einem Befehl den Status Access Denied haben, lautet der zurückgegebene Befehlsstatus Failed. Wenn ein Befehl jedoch fünf Aufrufe hat, von denen vier den Status Access Denied zurückgeben und einer den Status Success zurückgibt, lautet der Status des übergeordneten Befehls Success. Diese ist ein Terminalstatus. |
**Detaillierter Status für einen Befehl**
| Status | Details |
| --- | --- |
| Ausstehend | Der Befehl wurde noch von keinem Agenten auf einem verwalteten Knoten empfangen. |
| InProgress | Der Befehl wurde an mindestens einen verwalteten Knoten gesendet, hat aber keinen endgültigen Status auf allen Knoten erreicht. |
| Verzögert | Das System versuchte, den Befehl an den Knoten zu senden, war jedoch nicht erfolgreich. Das System startet einen erneuten Versuch. |
| Herzlichen Glückwunsch | Der Befehl wurde vom SSM Agent auf allen angegebenen oder anvisierten verwalteten Knoten empfangen und ein Ausgangscode von null wurde zurückgegeben. Alle Befehlsaufrufe haben einen endgültigen Status erreicht, und der Wert von max-errors wurde nicht erreicht. Dieser Status bedeutet nicht, dass der Befehl auf allen angegebenen oder anvisierten verwalteten Knoten erfolgreich verarbeitet wurde. Diese ist ein Terminalstatus. Um Fehler zu beheben oder weitere Informationen über die Befehlsausführung zu erhalten, senden Sie einen Befehl, der Fehler oder Ausnahmen handhabt, indem er entsprechende Beendigungscodes (Ausgangscodes für fehlgeschlagenen Befehl (nicht null)) zurückgibt. |
| DeliveryTimedOut | Der Befehl wurde nicht an den verwalteten Knoten übermittelt, bevor die gesamte Zeitbeschränkung abgelaufen ist. Der Wert max-errors oder weitere Befehlsaufrufe zeigen den Status Delivery Timed Out. Diese ist ein Terminalstatus. |
| Fehlgeschlagen | Der Befehl war auf dem verwalteten Knoten nicht erfolgreich. Der Wert `max-errors` oder weitere Befehlsaufrufe zeigen den Status `Failed`. Diese ist ein Terminalstatus. |
| Unvollständig | Der Befehl wurde auf allen verwalteten Knoten versucht und einer oder mehrere der Aufrufe haben nicht den Wert Success. Jedoch sind nicht genügend Aufrufe fehlgeschlagen für den Status Failed. Diese ist ein Terminalstatus. |
| Abgebrochen | Der Befehl wurde beendet, bevor er abgeschlossen wurde. Diese ist ein Terminalstatus. |
| RateExceeded | Die Anzahl der verwalteten Knoten, die durch den Befehl anvisiert wurden, überschritt das Kontingent Ihres Kontos für ausstehende Aufrufe. Das System hat den Befehl vor der Ausführung auf einem Knoten abgebrochen. Diese ist ein Terminalstatus. |
| AccessDenied | Der Benutzer oder die Rolle, der oder die den Befehl initiiert, hat keinen Zugriff auf die Zielressourcengruppe. AccessDenied zählt nicht zum max-errors-Limit des übergeordneten Befehls, trägt aber dazu bei, ob der Status des übergeordneten Befehls Success oder Failed ist. (Wenn beispielsweise alle Aufrufe in einem Befehl den Status AccessDenied haben, dann lautet der zurückgegebene Befehlsstatus Failed. Wenn ein Befehl jedoch 5 Aufrufe hat, von denen 4 den Status AccessDenied anzeigen und 1 davon den Status Success anzeigt, dann lautet der Status des übergeordneten Befehls Success.) Diese ist ein Terminalstatus. |
| Keine Instances im Tag | Der Tag-Schlüsselpaar-Wert oder die Ressourcengruppe, auf die der Befehl ausgerichtet ist, stimmt mit keinem verwalteten Knoten überein. Diese ist ein Terminalstatus. |
## Informationen zu Timeout-Werten von Befehlen
Systems Manager erzwingt die folgenden Timeout-Werte bei der Ausführung von Befehlen.
**Gesamt-Timeout**
Geben Sie in der Systems-Manager-Konsole den Zeitbeschränkungs-Wert im Feld **Timeout (seconds)** (Zeitbeschränkung (Sekunden)) ein. Nachdem ein Befehl gesendet wurde, prüft Run Command, ob der Befehl abgelaufen ist oder nicht. Wenn ein Befehl das Ablauflimit des Befehls (Gesamtzeitlimit) erreicht, ändert er den Status in `DeliveryTimedOut` für alle Aufrufe, die den Status `InProgress`, `Pending` oder `Delayed` haben.
![\[Das Feld Timeout (seconds) in der Systems Manager-Konsole\]](http://docs.aws.amazon.com/de_de/systems-manager/latest/userguide/images/run-command-delivery-time-out-time-out-seconds.png)
Technisch gesehen ist die gesamte Zeitbeschränkung (**Timeout (Sekunden)**) eine Kombination aus zwei Timeout-Werten, wie hier gezeigt:
`Total timeout = "Timeout(seconds)" from the console + "timeoutSeconds": "{{ executionTimeout }}" from your SSM document`
Beispielsweise beträgt der Standardwert von **Timeout (seconds) (Timeout (Sekunden))** 600 Sekunden in der Systems Manager-Konsole. Wenn Sie einen Befehl mit dem `AWS-RunShellScript`-SSM-Dokument ausführen, beträgt der Standardwert von **„timeoutSeconds“: „\$1\$1executionTimeout\$1\$1“** 3600 Sekunden, wie im folgenden Dokumentbeispiel gezeigt:
```
"executionTimeout": {
"type": "String",
"default": "3600",
"runtimeConfig": {
"aws:runShellScript": {
"properties": [
{
"timeoutSeconds": "{{ executionTimeout }}"
```
Das bedeutet, dass der Befehl 4 200 Sekunden (70 Minuten) lang ausgeführt wird, bevor das System den Befehlsstatus auf `DeliveryTimedOut` setzt.
**Execution Timeout**
In der Systems Manager-Konsole geben Sie den Wert für die Ausführungszeitüberschreitung im Feld **Execution Timeout** an, sofern verfügbar. Nicht alle SSM-Dokumente erfordern die Angabe eines Ausführungs-Timeout. Das Feld **Execution Timeout** (Ausführungszeitlimit) wird nur angezeigt, wenn ein entsprechender Eingabeparameter im SSM-Dokument definiert wurde. Falls angegeben, muss der Befehl innerhalb dieser Zeitspanne abgeschlossen werden.
**Anmerkung**
Run Command stützt sich auf die SSM Agent-Dokument-Terminalantwort, um zu bestimmen, ob der Befehl an den Agenten übermittelt wurde oder nicht. SSM Agent muss ein `ExecutionTimedOut`-Signal senden, damit ein Aufruf oder Befehl als `ExecutionTimedOut` markiert wird.
![\[Das Feld Execution Timeout (Ausführungs-Timeout) in der Systems Manager-Konsole\]](http://docs.aws.amazon.com/de_de/systems-manager/latest/userguide/images/run-command-execution-timeout-console.png)
**Standard-Ausführungs-Timeout**
Wenn ein SSM-Dokument nicht erfordert, dass Sie explizit einen Ausführungs-Timeout-Wert angeben, erzwingt Systems Manager den fest programmierten Standard-Ausführungs-Timeout.
**Wie Systems Manager Timeouts meldet**
Empfängt Systems Manager eine `execution timeout`-Antwort von SSM Agent auf einem Ziel, dann markiert Systems Manager den Befehlsaufruf als `executionTimeout`.
Erhält Run Command keine Dokumentterminalantwort von SSM Agent, wird der Befehlsaufruf als `deliveryTimeout`gekennzeichnet.
Um den Timeout-Status für ein Ziel zu bestimmen, kombiniert SSM Agent alle Parameter und den Inhalt des SSM-Dokuments, um `executionTimeout` zu berechnen. Wenn SSM Agent feststellt, dass ein Befehl einen Timeout hat, sendet es `executionTimeout` an den Service.
Der Standardwert für **Timeout (seconds) (Timeout (Sekunden))** beträgt 3600 Sekunden. Der Standardwert für **Execution Timeout** beträgt ebenfalls 3600 Sekunden. Daher beträgt die gesamte Standard-Timeout für einen Befehl 7200 Sekunden.
**Anmerkung**
SSM Agent verarbeitet `executionTimeout` unterschiedlich, je nach Art des SSM-Dokuments und der Dokumentversion.
# Walkthroughs für Run Command
Die Anleitungen in diesem Abschnitt zeigen die Ausführung von Befehlen mit Run Command, einem Tool in AWS Systems Manager, über die AWS Command Line Interface (AWS CLI) oder AWS Tools for Windows PowerShell.
**Topics**
+ [Aktualisierung von Software mithilfe von Run Command](run-command-tutorial-update-software.md)
+ [Exemplarische Vorgehensweise: Verwenden Sie das mit AWS CLI Run Command](walkthrough-cli.md)
+ [Exemplarische Vorgehensweise: Verwenden Sie das mit AWS Tools for Windows PowerShell Run Command](walkthrough-powershell.md)
Sie können auch Beispiele für Befehle in den folgenden Referenzen anzeigen.
+ [Systems ManagerAWS CLI-Referenz](https://docs.aws.amazon.com/cli/latest/reference/ssm/)
+ [AWS Tools for Windows PowerShell - AWS Systems Manager](https://docs.aws.amazon.com/powershell/latest/reference/items/SimpleSystemsManagement_cmdlets.html)
# Aktualisierung von Software mithilfe von Run Command
In den folgenden Verfahren wird beschrieben, wie Sie Software auf Ihren verwalteten Knoten aktualisieren.
## Aktualisierung von SSM Agent mithilfe von Run Command
Im folgenden Verfahren wird beschrieben, wie Sie den SSM Agent auf Ihren verwalteten Knoten aktualisieren können. Sie können entweder auf die neueste Version des SSM Agent aktualisieren oder ein Downgrade auf eine ältere Version durchführen. Wenn Sie den Befehl ausführen, lädt das System die Version von herunter AWS, installiert sie und deinstalliert dann die Version, die vor der Ausführung des Befehls vorhanden war. Wenn während dieses Prozesses ein Fehler auftritt, wird das System auf die Version auf dem Server zurückgesetzt, bevor der Befehl ausgeführt wurde, und der Befehlsstatus zeigt, dass der Befehl fehlgeschlagen ist.
**Anmerkung**
Wenn auf einer Instance macOS-Version 13.0 (Ventura) oder höher ausgeführt wird, muss die Instance über die SSM Agent-Version 3.1.941.0 oder höher verfügen, um das AWS-UpdateSSMAgent-Dokument auszuführen. Wenn auf der Instance eine Version von SSM Agent ausgeführt wird, die vor 3.1.941.0 veröffentlicht wurde, können Sie Ihr SSM Agent aktualisieren, um das AWS-UpdateSSMAgent-Dokument auszuführen, indem Sie die `brew update`- und `brew upgrade amazon-ssm-agent`-Befehle ausführen.
Wenn Sie über SSM Agent-Aktualisierungen benachrichtigt werden möchten, abonnieren Sie die Seite [SSM Agent-Versionshinweise](https://github.com/aws/amazon-ssm-agent/blob/mainline/RELEASENOTES.md) auf GitHub.
**So aktualisieren Sie SSM Agent mittels Run Command**
1. Öffnen Sie die AWS Systems Manager Konsole unter. [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/)
1. Wählen Sie im Navigationsbereich **Run Command** aus.
1. Wählen Sie **Befehl ausführen** aus.
1. Wählen Sie in der Liste **Befehlsdokument** die Option **`AWS-UpdateSSMAgent`** aus.
1. Geben Sie im Abschnitt **Command parameters** ggf. Werte für die folgenden Parameter an:
1. (Optional) Geben Sie in **Version (Version)** die zu installierende SSM Agent-Version ein. Sie können [ältere Versionen](https://github.com/aws/amazon-ssm-agent/blob/mainline/RELEASENOTES.md) des Agenten installieren. Wenn Sie keine Version angeben, installiert der Service die neueste Version.
1. (Optional) Wählen Sie in **Allow Downgrade (Downgrade erlauben)** die Option **true (wahr)** aus, um eine frühere SSM Agent-Version zu installieren. Wenn Sie diese Option auswählen, geben Sie die [frühere](https://github.com/aws/amazon-ssm-agent/blob/mainline/RELEASENOTES.md) Versionsnummer an. Wählen Sie **false**, um nur die neueste Version des Dienstes zu installieren.
1. Identifizieren Sie für den Abschnitt **Targets** (Ziele) die verwalteten Knoten, auf denen Sie diese Operation ausführen möchten, indem Sie Tags angeben, Instances oder Edge-Geräte manuell auswählen oder eine Ressourcengruppe angeben.
**Tipp**
Wenn ein verwalteter Knoten, den Sie erwarten, nicht aufgeführt ist, finden Sie weitere Informationen unter [Problembehandlung bei der Verfügbarkeit verwalteter Knoten](fleet-manager-troubleshooting-managed-nodes.md) Tipps zur Fehlerbehebung.
1. Für **Weitere Parameter**:
+ Geben Sie im Feld **Kommentar** Informationen zu diesem Befehl ein.
+ Geben Sie für **Timeout (Sekunden)** in Sekunden an, wie lange gewartet werden soll, bis für die gesamte Befehlsausführung ein Fehler auftritt.
1. Für **Ratenregelung**:
+ Geben Sie unter **Nebenläufigkeit** entweder eine Zahl oder einen Prozentsatz der verwalteten Knoten an, auf denen der Befehl gleichzeitig ausgeführt werden soll.
**Anmerkung**
Wenn Sie Ziele ausgewählt haben, indem Sie Tags für verwaltete Knoten oder AWS Ressourcengruppen angegeben haben und Sie sich nicht sicher sind, wie viele verwaltete Knoten das Ziel sind, schränken Sie die Anzahl der Ziele ein, die das Dokument gleichzeitig ausführen können, indem Sie einen Prozentsatz angeben.
+ Geben Sie unter **Fehlerschwellenwert** an, wann die Ausführung des Befehls auf anderen verwalteten Knoten beendet werden soll, nachdem dafür entweder auf einer bestimmten Anzahl oder einem Prozentsatz von Knoten ein Fehler aufgetreten ist. Falls Sie beispielsweise drei Fehler angeben, sendet Systems Manager keinen Befehl mehr, wenn der vierte Fehler empfangen wird. Von verwalteten Knoten, auf denen der Befehl noch verarbeitet wird, werden unter Umständen ebenfalls Fehler gesendet.
1. (Optional) Wenn Sie im Abschnitt **Ausgabeoptionen** die Befehlsausgabe in einer Datei speichern möchten, aktivieren Sie das Kontrollkästchen **Schreiben in einen S3-Bucket aktivieren**. Geben Sie die Namen für den Bucket und das Präfix (Ordner) in die Textfelder ein.
**Anmerkung**
Die S3-Berechtigungen zum Schreiben von Daten in einen S3-Bucket sind diejenigen des Instance-Profils (für EC2-Instances) oder der IAM-Servicerolle (hybrid-aktivierte Maschinen), die der Instance zugewiesen sind, und nicht diejenigen des IAM-Benutzers, der diese Aufgabe ausführt. Weitere Informationen finden Sie unter [Instance-Berechtigungen für Systems Manager konfigurieren](setup-instance-permissions.md) oder [Eine IAM-Servicerolle für eine Hybrid-Umgebung erstellen](hybrid-multicloud-service-role.md). Wenn sich der angegebene S3-Bucket in einem anderen AWS-Konto befindet, stellen Sie außerdem sicher, dass das Instance-Profil oder die IAM-Servicerolle, die dem verwalteten Knoten zugeordnet ist, über die erforderlichen Berechtigungen zum Schreiben in diesen Bucket verfügt.
1. Aktivieren Sie das Kontrollkästchen **SNS-Benachrichtigungen aktivieren** im Abschnitt **SNS-Benachrichtigungen**, wenn Sie über den Status der Befehlsausführung benachrichtigt werden möchten,
Weitere Informationen zum Konfigurieren von Amazon-SNS-Benachrichtigungen für Run Command finden Sie unter [Überwachung von Systems Manager-Statusänderungen mit Amazon SNS-Benachrichtigungen](monitoring-sns-notifications.md).
1. Klicken Sie auf **Ausführen**.
## Aktualisierung PowerShell mit Run Command
Im folgenden Verfahren wird beschrieben, wie Sie auf Ihren verwalteten R2-Knoten Windows Server 2012 und 2012 auf Version 5.1 aktualisieren PowerShell . Das in diesem Verfahren bereitgestellte Skript lädt das Update für Windows Management Framework (WMF) Version 5.1 herunter und startet die Installation des Updates. Der Knoten wird während dieses Prozesses neu gestartet, da dies bei der Installation von WMF 5.1 erforderlich ist. Download und Installation des Updates dauern insgesamt etwa fünf Minuten.
**Um zu aktualisieren PowerShell mit Run Command**
1. Öffnen Sie die AWS Systems Manager Konsole unter [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/).
1. Wählen Sie im Navigationsbereich **Run Command** aus.
1. Wählen Sie **Befehl ausführen** aus.
1. Wählen Sie in der Liste **Command document (Befehlsdokument)** die Option **`AWS-RunPowerShellScript`** aus.
1. Fügen Sie die folgenden Befehle für Ihr Betriebssystem im Abschnitt **Befehle** ein.
------
#### [ Windows Server 2012 R2 ]
```
Set-Location -Path "C:\Windows\Temp"
Invoke-WebRequest "https://go.microsoft.com/fwlink/?linkid=839516" -OutFile "Win8.1AndW2K12R2-KB3191564-x64.msu"
Start-Process -FilePath "$env:systemroot\system32\wusa.exe" -Verb RunAs -ArgumentList ('Win8.1AndW2K12R2-KB3191564-x64.msu', '/quiet')
```
------
#### [ Windows Server 2012 ]
```
Set-Location -Path "C:\Windows\Temp"
Invoke-WebRequest "https://go.microsoft.com/fwlink/?linkid=839513" -OutFile "W2K12-KB3191565-x64.msu"
Start-Process -FilePath "$env:systemroot\system32\wusa.exe" -Verb RunAs -ArgumentList ('W2K12-KB3191565-x64.msu', '/quiet')
```
------
1. Identifizieren Sie für den Abschnitt **Targets** (Ziele) die verwalteten Knoten, auf denen Sie diese Operation ausführen möchten, indem Sie Tags angeben, Instances oder Edge-Geräte manuell auswählen oder eine Ressourcengruppe angeben.
**Tipp**
Wenn ein verwalteter Knoten, den Sie erwarten, nicht aufgeführt ist, finden Sie weitere Informationen unter [Problembehandlung bei der Verfügbarkeit verwalteter Knoten](fleet-manager-troubleshooting-managed-nodes.md) Tipps zur Fehlerbehebung.
1. Für **Weitere Parameter**:
+ Geben Sie im Feld **Kommentar** Informationen zu diesem Befehl ein.
+ Geben Sie für **Timeout (Sekunden)** in Sekunden an, wie lange gewartet werden soll, bis für die gesamte Befehlsausführung ein Fehler auftritt.
1. Für **Ratenregelung**:
+ Geben Sie unter **Nebenläufigkeit** entweder eine Zahl oder einen Prozentsatz der verwalteten Knoten an, auf denen der Befehl gleichzeitig ausgeführt werden soll.
**Anmerkung**
Wenn Sie Ziele ausgewählt haben, indem Sie Tags für verwaltete Knoten oder AWS Ressourcengruppen angegeben haben und Sie sich nicht sicher sind, wie viele verwaltete Knoten das Ziel sind, schränken Sie die Anzahl der Ziele ein, die das Dokument gleichzeitig ausführen können, indem Sie einen Prozentsatz angeben.
+ Geben Sie unter **Fehlerschwellenwert** an, wann die Ausführung des Befehls auf anderen verwalteten Knoten beendet werden soll, nachdem dafür entweder auf einer bestimmten Anzahl oder einem Prozentsatz von Knoten ein Fehler aufgetreten ist. Falls Sie beispielsweise drei Fehler angeben, sendet Systems Manager keinen Befehl mehr, wenn der vierte Fehler empfangen wird. Von verwalteten Knoten, auf denen der Befehl noch verarbeitet wird, werden unter Umständen ebenfalls Fehler gesendet.
1. (Optional) Wenn Sie im Abschnitt **Ausgabeoptionen** die Befehlsausgabe in einer Datei speichern möchten, aktivieren Sie das Kontrollkästchen **Schreiben in einen S3-Bucket aktivieren**. Geben Sie die Namen für den Bucket und das Präfix (Ordner) in die Textfelder ein.
**Anmerkung**
Die S3-Berechtigungen zum Schreiben von Daten in einen S3-Bucket sind diejenigen des Instance-Profils (für EC2-Instances) oder der IAM-Servicerolle (hybrid-aktivierte Maschinen), die der Instance zugewiesen sind, und nicht diejenigen des IAM-Benutzers, der diese Aufgabe ausführt. Weitere Informationen finden Sie unter [Instance-Berechtigungen für Systems Manager konfigurieren](setup-instance-permissions.md) oder [Eine IAM-Servicerolle für eine Hybrid-Umgebung erstellen](hybrid-multicloud-service-role.md). Wenn sich der angegebene S3-Bucket in einem anderen AWS-Konto befindet, stellen Sie außerdem sicher, dass das Instance-Profil oder die IAM-Servicerolle, die dem verwalteten Knoten zugeordnet ist, über die erforderlichen Berechtigungen zum Schreiben in diesen Bucket verfügt.
1. Aktivieren Sie das Kontrollkästchen **SNS-Benachrichtigungen aktivieren** im Abschnitt **SNS-Benachrichtigungen**, wenn Sie über den Status der Befehlsausführung benachrichtigt werden möchten,
Weitere Informationen zum Konfigurieren von Amazon-SNS-Benachrichtigungen für Run Command finden Sie unter [Überwachung von Systems Manager-Statusänderungen mit Amazon SNS-Benachrichtigungen](monitoring-sns-notifications.md).
1. Klicken Sie auf **Ausführen**.
Nachdem der verwaltete Knoten neu gestartet wurde und die Installation des Updates abgeschlossen ist, stellen Sie eine Verbindung zu Ihrem Knoten her, um zu überprüfen, ob das Upgrade auf Version 5.1 PowerShell erfolgreich war. Um die Version von PowerShell auf Ihrem Node zu überprüfen, öffnen Sie die Datei PowerShell und geben Sie die Eingabetaste ein`$PSVersionTable`. Der `PSVersion`-Wert in der Ausgabetabelle zeigt 5.1, wenn das Upgrade erfolgreich war.
Wenn der `PSVersion`-Wert nicht 5.1 ist, zum Beispiel 3.0 oder 4.0, überprüfen Sie die **Setup**-Protokolle im Event Viewer unter **Windows-Protokolle**. Diese Protokolle geben an, warum die Update-Installation fehlgeschlagen ist.
# 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"
]
}
}
```
# Exemplarische Vorgehensweise: Verwenden Sie das mit AWS Tools for Windows PowerShell Run Command
In den folgenden Beispielen wird gezeigt, wie Sie mithilfe von Informationen AWS Tools for Windows PowerShell zu Befehlen und Befehlsparametern anzeigen, Befehle ausführen und den Status dieser Befehle anzeigen können. Diese Anleitung umfasst ein Beispiel für jedes der vordefinierten AWS Systems Manager -Dokumente.
**Wichtig**
Nur vertrauenswürdige Administratoren sollten Systems Manager-vorkonfigurierte Dokumente in diesem Thema verwenden dürfen. Die in Systems-Manager-Dokumenten festgelegten Befehle oder Skripts werden mit einer Administratorberechtigung auf Ihren verwalteten Knoten ausgeführt. Wenn ein Benutzer berechtigt ist, eines der vordefinierten Systems Manager Manager-Dokumente (jedes Dokument, das mit beginnt AWS) auszuführen, 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**
+ [Konfigurieren Sie die AWS Tools for Windows PowerShell Sitzungseinstellungen](#walkthrough-powershell-settings)
+ [Listen Sie alle verfügbaren Dokumente auf](#walkthrough-powershell-all-documents)
+ [Führen Sie PowerShell Befehle oder Skripts aus](#walkthrough-powershell-run-script)
+ [Installieren einer Anwendung mithilfe des `AWS-InstallApplication`-Dokuments](#walkthrough-powershell-install-application)
+ [Installieren Sie ein PowerShell Modul mithilfe des `AWS-InstallPowerShellModule` JSON-Dokuments](#walkthrough-powershell-install-module)
+ [Verbinden eines verwalteten Knotens mit einer Domain mithilfe des `AWS-JoinDirectoryServiceDomain`-JSON-Dokuments](#walkthrough-powershell-domain-join)
+ [Senden Sie Windows-Metriken mithilfe des `AWS-ConfigureCloudWatch` Dokuments an Amazon CloudWatch Logs](#walkthrough-powershell-windows-metrics)
+ [Aktivieren oder deaktivieren Sie die automatische Windows-Aktualisierung mithilfe des `AWS-ConfigureWindowsUpdate`-Dokuments.](#walkthrough-powershell-enable-windows-update)
+ [Verwalten von Windows-Updates mit Run Command](#walkthough-powershell-windows-updates)
## Konfigurieren Sie die AWS Tools for Windows PowerShell Sitzungseinstellungen
**Angeben Ihrer Anmeldeinformationen**
Öffnen Sie **Tools für Windows PowerShell** auf Ihrem lokalen Computer und führen Sie den folgenden Befehl aus, um Ihre Anmeldeinformationen anzugeben. Sie müssen entweder über Administratorrechte für die verwalteten Knoten verfügen, die Sie konfigurieren möchten, oder Ihnen müssen die entsprechenden Berechtigungen in AWS Identity and Access Management (IAM) erteilt worden sein. Weitere Informationen finden Sie unter [Einrichtung verwalteter Knoten für AWS Systems Manager](systems-manager-setting-up-nodes.md).
```
Set-AWSCredentials –AccessKey key-name –SecretKey key-name
```
**Legen Sie einen Standard fest AWS-Region**
Führen Sie den folgenden Befehl aus, um die Region für Ihre PowerShell Sitzung festzulegen. Das Beispiel verwendet die Region USA Ost (Ohio) (us-east-2). 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.
```
Set-DefaultAWSRegion `
-Region us-east-2
```
## Listen Sie alle verfügbaren Dokumente auf
Mit diesem Befehl werden alle verfügbaren Dokumente für Ihrem Konto aufgelistet.
```
Get-SSMDocumentList
```
## Führen Sie PowerShell Befehle oder Skripts aus
Mit Run Command und dem `AWS-RunPowerShell`-Dokument können Sie Befehle oder Skripts auf einem verwalteten Knoten ausführen, als ob Sie lokal angemeldet wären. Sie können Befehle ausgeben oder einen Pfad zu einem lokalen Skript eingeben, um den Befehl auszuführen.
**Anmerkung**
Informationen zum Neustarten von verwalteten Knoten bei Verwendung von Run Command für den Aufruf von Skripts finden Sie unter [Umgang mit Neustarts beim Ausführen von Befehlen](send-commands-reboot.md).
**Die Beschreibung und verfügbare Parameter anzeigen**
```
Get-SSMDocumentDescription `
-Name "AWS-RunPowerShellScript"
```
**Weitere Informationen über Parameter anzeigen**
```
Get-SSMDocumentDescription `
-Name "AWS-RunPowerShellScript" | Select -ExpandProperty Parameters
```
### Senden Sie einen Befehl mithilfe des `AWS-RunPowerShellScript`-Dokuments
Mit dem folgenden Befehl werden der Inhalt des `"C:\Users"`-Verzeichnisses und der Inhalt des `"C:\"`-Verzeichnisses auf zwei verwalteten Knoten angezeigt.
```
$runPSCommand = Send-SSMCommand `
-InstanceIds @("instance-ID-1", "instance-ID-2") `
-DocumentName "AWS-RunPowerShellScript" `
-Comment "Demo AWS-RunPowerShellScript with two instances" `
-Parameter @{'commands'=@('dir C:\Users', 'dir C:\')}
```
**Abrufen der Befehlsabfragedetails**
Mit dem folgenden Befehl wird die `CommandId` verwendet, um den Status der Befehlsausführung auf beiden verwalteten Knoten abzurufen. In diesem Beispiel wird die `CommandId` verwendet, die im vorherigen Befehl zurückgegeben wurde.
```
Get-SSMCommand `
-CommandId $runPSCommand.CommandId
```
Der Status des Befehls in diesem Beispiel kann „Erfolgreich“, „Ausstehend“ oder „Ausstehend“ lauten InProgress.
**Abrufen von Befehlsinformationen pro verwalteter Knoten**
Mit dem folgenden Befehl wird die `CommandId` vom vorherigen Befehl verwendet, um den Status der Befehlsausführung pro verwalteten Knoten abzurufen.
```
Get-SSMCommandInvocation `
-CommandId $runPSCommand.CommandId
```
**Abrufen von Befehlsinformationen mit Antwortdaten für einen bestimmten verwalteten Knoten**
Mit dem folgenden Befehl wird die Ausgabe des ursprünglichen `Send-SSMCommand` für einen bestimmten verwalteten Knoten zurückgegeben.
```
Get-SSMCommandInvocation `
-CommandId $runPSCommand.CommandId `
-Details $true `
-InstanceId instance-ID | Select -ExpandProperty CommandPlugins
```
### Abbrechen eines Befehls
Mit dem folgenden Befehl wird `Send-SSMCommand` für das `AWS-RunPowerShellScript`-Dokument abgebrochen.
```
$cancelCommand = Send-SSMCommand `
-InstanceIds @("instance-ID-1","instance-ID-2") `
-DocumentName "AWS-RunPowerShellScript" `
-Comment "Demo AWS-RunPowerShellScript with two instances" `
-Parameter @{'commands'='Start-Sleep –Seconds 120; dir C:\'}
Stop-SSMCommand -CommandId $cancelCommand.CommandId
```
**Überprüfen des Befehlsstatus**
Mit dem folgenden Befehl wird der Status des `Cancel`-Befehls überprüft
```
Get-SSMCommand `
-CommandId $cancelCommand.CommandId
```
## Installieren einer Anwendung mithilfe des `AWS-InstallApplication`-Dokuments
Mit Run Command und dem `AWS-InstallApplication`-Dokument können Sie Anwendungen auf verwalteten Knoten installieren, reparieren oder deinstallieren. Der Befehl erfordert den Pfad oder die Adresse für ein MSI.
**Anmerkung**
Informationen zum Neustarten von verwalteten Knoten bei Verwendung von Run Command für den Aufruf von Skripts finden Sie unter [Umgang mit Neustarts beim Ausführen von Befehlen](send-commands-reboot.md).
**Die Beschreibung und verfügbare Parameter anzeigen**
```
Get-SSMDocumentDescription `
-Name "AWS-InstallApplication"
```
**Weitere Informationen über Parameter anzeigen**
```
Get-SSMDocumentDescription `
-Name "AWS-InstallApplication" | Select -ExpandProperty Parameters
```
### Senden Sie einen Befehl mithilfe des `AWS-InstallApplication`-Dokuments
Mit dem folgenden Befehl wird eine Version von Python auf Ihrerm verwalteten Knoten im unbeaufsichtigten Modus installiert und die Ausgabe in einer lokalen Textdatei auf dem Laufwerk `C:` protokolliert.
```
$installAppCommand = Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallApplication" `
-Parameter @{'source'='https://www.python.org/ftp/python/2.7.9/python-2.7.9.msi'; 'parameters'='/norestart /quiet /log c:\pythoninstall.txt'}
```
**Abrufen von Befehlsinformationen pro verwalteter Knoten**
Mit dem folgenden Befehl wird die `CommandId` verwendet, um den Status der Befehlsausführung abzurufen.
```
Get-SSMCommandInvocation `
-CommandId $installAppCommand.CommandId `
-Details $true
```
**Abrufen von Befehlsinformationen mit Antwortdaten für einen bestimmten verwalteten Knoten**
Mit dem folgenden Befehl werden die Ergebnisse der Python-Installation zurückgegeben.
```
Get-SSMCommandInvocation `
-CommandId $installAppCommand.CommandId `
-Details $true `
-InstanceId instance-ID | Select -ExpandProperty CommandPlugins
```
## Installieren Sie ein PowerShell Modul mithilfe des `AWS-InstallPowerShellModule` JSON-Dokuments
Sie können es verwendenRun Command, um PowerShell Module auf verwalteten Knoten zu installieren. Weitere Informationen zu PowerShell Modulen finden Sie unter [ PowerShell Windows-Module](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_modules?view=powershell-6).
**Die Beschreibung und verfügbare Parameter anzeigen**
```
Get-SSMDocumentDescription `
-Name "AWS-InstallPowerShellModule"
```
**Weitere Informationen über Parameter anzeigen**
```
Get-SSMDocumentDescription `
-Name "AWS-InstallPowerShellModule" | Select -ExpandProperty Parameters
```
### Installieren Sie ein PowerShell Modul
Mit dem folgenden Befehl wird die EZOut ZIP-Datei heruntergeladen, installiert und anschließend ein zusätzlicher Befehl zur Installation des XPS-Viewers ausgeführt. Schließlich wird die Ausgabe dieses Befehls auf einen S3-Bucket mit dem Namen „amzn-s3-demo-bucket“ hochgeladen.
```
$installPSCommand = Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallPowerShellModule" `
-Parameter @{'source'='https://gallery.technet.microsoft.com/EZOut-33ae0fb7/file/110351/1/EZOut.zip';'commands'=@('Add-WindowsFeature -name XPS-Viewer -restart')} `
-OutputS3BucketName amzn-s3-demo-bucket
```
**Abrufen von Befehlsinformationen pro verwalteter Knoten**
Mit dem folgenden Befehl wird die `CommandId` verwendet, um den Status der Befehlsausführung abzurufen.
```
Get-SSMCommandInvocation `
-CommandId $installPSCommand.CommandId `
-Details $true
```
**Abrufen von Befehlsinformationen mit Antwortdaten für den verwalteten Knoten**
Mit dem folgenden Befehl wird die Ausgabe des ursprünglichen `Send-SSMCommand`-Befehls für die spezielle `CommandId` zurückgegeben.
```
Get-SSMCommandInvocation `
-CommandId $installPSCommand.CommandId `
-Details $true | Select -ExpandProperty CommandPlugins
```
## Verbinden eines verwalteten Knotens mit einer Domain mithilfe des `AWS-JoinDirectoryServiceDomain`-JSON-Dokuments
Mit Run Command dieser Option können Sie einen verwalteten Knoten schnell einer Domäne hinzufügen. AWS Directory Service [Erstellen Sie ein Verzeichnis](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_getting_started_create_directory.html) vor dem Ausführen dieses Befehls. Wir empfehlen außerdem, sich mit der Directory Service besser vertraut zu machen. Weitere Informationen finden Sie im [Administrationshandbuch zu AWS Directory Service](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/).
Sie können nur einen verwalteten Knoten mit einer Domain verbinden. Sie können keinen Knoten aus einer Domain entfernen.
**Anmerkung**
Informationen zu verwalteten Knoten bei Verwendung von Run Command für den Aufruf von Skripts finden Sie unter [Umgang mit Neustarts beim Ausführen von Befehlen](send-commands-reboot.md).
**Die Beschreibung und verfügbare Parameter anzeigen**
```
Get-SSMDocumentDescription `
-Name "AWS-JoinDirectoryServiceDomain"
```
**Weitere Informationen über Parameter anzeigen**
```
Get-SSMDocumentDescription `
-Name "AWS-JoinDirectoryServiceDomain" | Select -ExpandProperty Parameters
```
### Verbinden eines verwalteten Knotens mit einer Domain
Der folgende Befehl verbindet einen verwalteten Knoten mit der angegebenen Directory Service Domain und lädt alle generierten Ausgaben in den Amazon Simple Storage Service (Amazon S3) -Beispiel-Bucket hoch.
```
$domainJoinCommand = Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-JoinDirectoryServiceDomain" `
-Parameter @{'directoryId'='d-example01'; 'directoryName'='ssm.example.com'; 'dnsIpAddresses'=@('192.168.10.195', '192.168.20.97')} `
-OutputS3BucketName amzn-s3-demo-bucket
```
**Abrufen von Befehlsinformationen pro verwalteter Knoten**
Mit dem folgenden Befehl wird die `CommandId` verwendet, um den Status der Befehlsausführung abzurufen.
```
Get-SSMCommandInvocation `
-CommandId $domainJoinCommand.CommandId `
-Details $true
```
**Abrufen von Befehlsinformationen mit Antwortdaten für den verwalteten Knoten**
Dieser Befehl gibt die Ausgabe des ursprünglichen `Send-SSMCommand` für die spezifische `CommandId` zurück.
```
Get-SSMCommandInvocation `
-CommandId $domainJoinCommand.CommandId `
-Details $true | Select -ExpandProperty CommandPlugins
```
## Senden Sie Windows-Metriken mithilfe des `AWS-ConfigureCloudWatch` Dokuments an Amazon CloudWatch Logs
Sie können Windows Server Nachrichten in den Anwendungs-, System-, Sicherheits- und Event Tracing for Windows (ETW) -Protokollen an Amazon CloudWatch Logs senden. Wenn Sie die Protokollierung zum ersten Mal aktivieren, sendet Systems Manager alle Protokolle, die innerhalb von 1 Minute generiert werden, sobald Sie mit dem Hochladen von Protokollen für die Anwendungs-, System-, Sicherheits- und ETW-Protokolle beginnen. Protokolle, die davor auftraten, werden nicht berücksichtigt. Wenn Sie die Protokollierung deaktivieren und später wieder aktivieren, sendet Systems Manager Protokolle ab dem Zeitpunkt, an dem die Unterbrechung stattfand. Für alle benutzerdefinierten Protokolldateien und IIS- (Internet Information Services)-Protokolle liest Systems Manager die Protokolldateien von Anfang an. Darüber hinaus kann Systems Manager auch Leistungsindikatordaten an CloudWatch Logs senden.
Wenn Sie zuvor die CloudWatch Integration in EC2 Config aktiviert haben, überschreiben die Systems Manager Manager-Einstellungen alle Einstellungen, die lokal auf dem verwalteten Knoten in der `C:\Program Files\Amazon\EC2ConfigService\Settings\AWS.EC2.Windows.CloudWatch.json` Datei gespeichert sind. Weitere Informationen zur Verwendung von EC2 Config zur Verwaltung von Leistungsindikatoren und Protokollen auf einem einzelnen verwalteten Knoten finden Sie unter [Sammeln von Metriken und Protokollen von Amazon EC2 EC2-Instances und lokalen Servern mit dem CloudWatch Agenten im * CloudWatch Amazon-Benutzerhandbuch*](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Install-CloudWatch-Agent.html).
**Die Beschreibung und verfügbare Parameter anzeigen**
```
Get-SSMDocumentDescription `
-Name "AWS-ConfigureCloudWatch"
```
**Weitere Informationen über Parameter anzeigen**
```
Get-SSMDocumentDescription `
-Name "AWS-ConfigureCloudWatch" | Select -ExpandProperty Parameters
```
### Senden Sie Anwendungsprotokolle an CloudWatch
Mit dem folgenden Befehl wird der verwaltete Knoten konfiguriert und die Windows-Anwendungsprotokolle dorthin CloudWatch verschoben.
```
$cloudWatchCommand = Send-SSMCommand `
-InstanceID instance-ID `
-DocumentName "AWS-ConfigureCloudWatch" `
-Parameter @{'properties'='{"engineConfiguration": {"PollInterval":"00:00:15", "Components":[{"Id":"ApplicationEventLog", "FullName":"AWS.EC2.Windows.CloudWatch.EventLog.EventLogInputComponent,AWS.EC2.Windows.CloudWatch", "Parameters":{"LogName":"Application", "Levels":"7"}},{"Id":"CloudWatch", "FullName":"AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch", "Parameters":{"Region":"region", "LogGroup":"my-log-group", "LogStream":"instance-id"}}], "Flows":{"Flows":["ApplicationEventLog,CloudWatch"]}}}'}
```
**Abrufen von Befehlsinformationen pro verwalteter Knoten**
Mit dem folgenden Befehl wird die `CommandId` verwendet, um den Status der Befehlsausführung abzurufen.
```
Get-SSMCommandInvocation `
-CommandId $cloudWatchCommand.CommandId `
-Details $true
```
**Abrufen von Befehlsinformationen mit Antwortdaten für einen bestimmten verwalteten Knoten**
Der folgende Befehl gibt die Ergebnisse der CloudWatch Amazon-Konfiguration zurück.
```
Get-SSMCommandInvocation `
-CommandId $cloudWatchCommand.CommandId `
-Details $true `
-InstanceId instance-ID | Select -ExpandProperty CommandPlugins
```
### Senden Sie Leistungsindikatoren an die CloudWatch Verwendung des Dokuments `AWS-ConfigureCloudWatch`
Mit dem folgenden Demonstrationsbefehl werden Leistungsindikatoren in hochgeladen. CloudWatch Weitere Informationen finden Sie im *[ CloudWatch Amazon-Benutzerhandbuch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/)*.
```
$cloudWatchMetricsCommand = Send-SSMCommand `
-InstanceID instance-ID `
-DocumentName "AWS-ConfigureCloudWatch" `
-Parameter @{'properties'='{"engineConfiguration": {"PollInterval":"00:00:15", "Components":[{"Id":"PerformanceCounter", "FullName":"AWS.EC2.Windows.CloudWatch.PerformanceCounterComponent.PerformanceCounterInputComponent,AWS.EC2.Windows.CloudWatch", "Parameters":{"CategoryName":"Memory", "CounterName":"Available MBytes", "InstanceName":"", "MetricName":"AvailableMemory", "Unit":"Megabytes","DimensionName":"", "DimensionValue":""}},{"Id":"CloudWatch", "FullName":"AWS.EC2.Windows.CloudWatch.CloudWatch.CloudWatchOutputComponent,AWS.EC2.Windows.CloudWatch", "Parameters":{"AccessKey":"", "SecretKey":"","Region":"region", "NameSpace":"Windows-Default"}}], "Flows":{"Flows":["PerformanceCounter,CloudWatch"]}}}'}
```
## Aktivieren oder deaktivieren Sie die automatische Windows-Aktualisierung mithilfe des `AWS-ConfigureWindowsUpdate`-Dokuments.
Mit Run Command und dem `AWS-ConfigureWindowsUpdate`-Dokument können Sie automatische Windows-Updates auf Ihren von Windows Server verwalteten Knoten aktivieren oder deaktivieren. Mit diesem Befehl wird der Windows Update-Agent konfiguriert, um Windows-Updates an dem Tag und in der Stunde, die Sie angeben, herunterzuladen und zu installieren. Wenn ein Update einen Neustart erfordert, startet der verwaltete Knoten automatisch 15 Minuten nach der Installation der Updates neu. Mit diesem Befehl können Sie konfigurieren, dass Windows Update auf Updates prüft, diese aber nicht installiert. Das Dokument `AWS-ConfigureWindowsUpdate` wird in Windows Server 2012 und späteren Versionen offiziell unterstützt.
**Die Beschreibung und verfügbare Parameter anzeigen**
```
Get-SSMDocumentDescription `
–Name "AWS-ConfigureWindowsUpdate"
```
**Weitere Informationen über Parameter anzeigen**
```
Get-SSMDocumentDescription `
-Name "AWS-ConfigureWindowsUpdate" | Select -ExpandProperty Parameters
```
### Aktivieren des automatischen Windows Updates
Mit dem folgenden Befehl wird Windows Update konfiguriert, um Updates automatisch täglich um 22.00 Uhr herunterzuladen und zu installieren.
```
$configureWindowsUpdateCommand = Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-ConfigureWindowsUpdate" `
-Parameters @{'updateLevel'='InstallUpdatesAutomatically'; 'scheduledInstallDay'='Daily'; 'scheduledInstallTime'='22:00'}
```
**Anzeigen des Befehlsstatus zum Aktivieren von automatischen Windows Updates**
Mit dem folgenden Befehl wird die `CommandId` verwendet, um den Status der Befehlsausführung für die Aktivierung von Windows Automatic Updates abzurufen.
```
Get-SSMCommandInvocation `
-Details $true `
-CommandId $configureWindowsUpdateCommand.CommandId | Select -ExpandProperty CommandPlugins
```
### Deaktivieren des automatischen Windows Updates
Mit dem folgenden Befehl wird die Windows-Update-Benachrichtigungsebene herabgesetzt, damit das System prüft, ob Updates vorliegen, diese jedoch nicht automatisch auf dem verwalteten Knoten installiert.
```
$configureWindowsUpdateCommand = Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-ConfigureWindowsUpdate" `
-Parameters @{'updateLevel'='NeverCheckForUpdates'}
```
**Anzeigen des Befehlsstatus zum Deaktivieren von automatischen Windows Updates**
Mit dem folgenden Befehl wird die `CommandId` verwendet, um den Status der Befehlsausführung für die Aktivierung von Windows Automatic Updates abzurufen.
```
Get-SSMCommandInvocation `
-Details $true `
-CommandId $configureWindowsUpdateCommand.CommandId | Select -ExpandProperty CommandPlugins
```
## Verwalten von Windows-Updates mit Run Command
Mit Run Command und dem `AWS-InstallWindowsUpdates`-Dokument können Sie Updates für von Windows Server verwaltete Knoten verwalten. Dieser Befehl scannt nach oder installiert fehlende Updates auf Ihren verwalteten Knoten und führt nach der Installation optional einen Neustart durch. Sie können auch die entsprechenden Klassifizierungen und Schweregrade für Aktualisierungen angeben, die in Ihrer Umgebung installiert werden sollen.
**Anmerkung**
Informationen zum Neustarten von verwalteten Knoten bei Verwendung von Run Command für den Aufruf von Skripts finden Sie unter [Umgang mit Neustarts beim Ausführen von Befehlen](send-commands-reboot.md).
Die folgenden Beispiele zeigen, wie Sie die angegebenen Windows Update-Verwaltungsaufgaben durchführen.
### Suche nach allen fehlenden Windows-Updates
```
Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallWindowsUpdates" `
-Parameters @{'Action'='Scan'}
```
### Installieren von bestimmten Windows-Updates
```
Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallWindowsUpdates" `
-Parameters @{'Action'='Install';'IncludeKbs'='kb-ID-1,kb-ID-2,kb-ID-3';'AllowReboot'='True'}
```
### Installieren wichtiger fehlender Windows-Updates
```
Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallWindowsUpdates" `
-Parameters @{'Action'='Install';'SeverityLevels'='Important';'AllowReboot'='True'}
```
### Installieren fehlender Windows-Updates mit bestimmten Ausschlüssen
```
Send-SSMCommand `
-InstanceId instance-ID `
-DocumentName "AWS-InstallWindowsUpdates" `
-Parameters @{'Action'='Install';'ExcludeKbs'='kb-ID-1,kb-ID-2';'AllowReboot'='True'}
```
# Fehlerbehebung von Systems Manager Run Command
Run Command, ein Tool in AWS Systems Manager, bietet Statusdetails zu jeder Befehlsausführung. Weitere Informationen zu den Befehlsstatus-Details finden Sie unter [Grundlegendes zu Befehlsstatus](monitor-commands.md). Sie können auch die Informationen in diesem Thema verwenden, um Probleme mit Run Command zu beheben.
**Topics**
+ [Einige meiner verwalteten Knoten fehlen](#where-are-instances)
+ [Ein Schritt in meinem Skript ist fehlgeschlagen, der Gesamtstatus wird jedoch als "Succeeded" (Erfolgreich) angezeigt.](#ts-exit-codes)
+ [SSM Agent wird nicht ordnungsgemäß ausgeführt.](#ts-ssmagent-linux)
## Einige meiner verwalteten Knoten fehlen
Auf der Seite **Run a command** (Einen Befehl ausführen) können Sie, nachdem Sie ein auszuführendes SSM-Dokument ausgewählt und im Abschnitt **Targets** (Ziele) die **manuelle Auswahl von Instances** gewählt haben, wird eine Liste von verwalteten Knoten angezeigt, die Sie für die Ausführung des Befehls auswählen können.
Wenn ein verwalteter Knoten, den Sie erwarten, nicht aufgeführt ist, finden Sie weitere Informationen unter [Problembehandlung bei der Verfügbarkeit verwalteter Knoten](fleet-manager-troubleshooting-managed-nodes.md) Tipps zur Fehlerbehebung.
Nachdem Sie einen verwalteten Knoten erstellt, aktiviert, neu gestartet oder neu gestartet, Run Command auf einem Knoten installiert oder ein AWS Identity and Access Management (IAM-) Instanzprofil an einen Knoten angehängt haben, kann es einige Minuten dauern, bis der verwaltete Knoten der Liste hinzugefügt wird.
## Ein Schritt in meinem Skript ist fehlgeschlagen, der Gesamtstatus wird jedoch als "Succeeded" (Erfolgreich) angezeigt.
Mit Run Command können Sie festlegen, wie Ihre Skripte mit Exit-Codes umgehen. Standardmäßig wird der Beendigungscode des letzten in einem Skript ausgeführten Befehls als Beendigungscode für das gesamte Skript gemeldet. Sie können jedoch eine bedingte Anweisung einschließen, damit das Skript beendet wird, wenn ein Befehl vor dem letzten Befehl fehlschlägt. Weitere Informationen und Beispiele finden Sie unter [Angabe von Beendigungscodes in Befehlen](run-command-handle-exit-status.md#command-exit-codes).
## SSM Agent wird nicht ordnungsgemäß ausgeführt.
Bei Problemen beim Ausführen von Befehlen mittels Run Command liegt möglicherweise ein Problem mit SSM Agent vor. Informationen zum Untersuchen von Problemen mit SSM Agent finden Sie unter [Fehlerbehebung für SSM Agent](troubleshooting-ssm-agent.md).