• 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.
# Tutorials
Die Tutorials in diesem Abschnitt veranschaulichen, wie Sie mit Wartungsfenstern gängige Aufgaben durchführen.
**Erfüllen der Voraussetzungen**
Erfüllen Sie die folgenden Voraussetzungen, bevor Sie diese Tutorials ausführen.
+ **Konfigurieren der AWS CLI auf Ihrem lokalen Computer**: Bevor Sie AWS CLI-Befehle ausführen können, müssen Sie die CLI auf Ihrem lokalen Computer installieren und konfigurieren. Weitere Informationen finden Sie unter [Installieren oder Aktualisieren der neuesten Version der AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) und [Installieren des AWS -Tools für PowerShell](https://docs.aws.amazon.com/powershell/latest/userguide/pstools-getting-set-up.html).
+ **Überprüfen der Wartungsfenster-Rollen und -Berechtigungen**: Ein AWS-Administrator in Ihrem Konto muss Ihnen die AWS Identity and Access Management (IAM)-Berechtigungen gewähren, die Sie zur Verwaltung von Wartungsfenstern mithilfe der CLI benötigen. Weitere Informationen finden Sie unter [Einrichten von Maintenance Windows](setting-up-maintenance-windows.md).
+ **Erstellen oder Konfigurieren einer mit Systems Manager kompatiblen Instance** Sie benötigen mindestens eine Amazon Elastic Compute Cloud (Amazon EC2)-Instance, die für die Verwendung mit Systems Manager konfiguriert ist, um die Tutorials abzuschließen. Dies bedeutet, dass SSM Agent auf der Instance installiert ist und der Instance ein IAM-Instance-Profil für Systems Manager zugeordnet ist.
Wir empfehlen, eine Instance von einem AWS verwalteten Amazon Machine Image (AMI) mit vorinstalliertem Agent zu starten. Weitere Informationen finden Sie unter [Finden Sie AMIs mit dem vorinstallierten SSM Agent](ami-preinstalled-agent.md).
Weitere Informationen zum Installieren von SSM Agent auf einer Instance finden Sie in den folgenden Themen:
+ [Manuelle Installation und Deinstallation des SSM Agent auf EC2-Instances für Windows Server](manually-install-ssm-agent-windows.md)
+ [Manuelle Installation und Deinstallation des SSM Agent auf EC2-Instances für Linux](manually-install-ssm-agent-linux.md)
Informationen zum Konfigurieren von IAM-Berechtigungen für Systems Manager für Ihre Instance finden Sie unter [Konfigurieren von erforderlichen Instance-Berechtigungen für Systems Manager](setup-instance-permissions.md).
+ **Erstellen zusätzlicher Ressourcen nach Bedarf**: Run Command, ein Tool in Systems Manager, enthält viele Aufgaben, für die Sie keine anderen Ressourcen erstellen müssen als die, die in diesem Thema über die Voraussetzungen aufgeführt sind. Aus diesem Grund stellen wir Ihnen eine einfache Run Command-Aufgabe bereit, die Sie verwenden können, wenn Sie sich das erste Mal durch die Tutorials arbeiten. Sie benötigen außerdem eine EC2-Instance, die für die Verwendung mit Systems Manager konfiguriert ist, wie weiter oben in diesem Thema beschrieben. Nachdem Sie diese Instance konfiguriert haben, können Sie eine einfache Run Command-Aufgabe registrieren.
Das Systems-Manager-Tool Maintenance Windows unterstützt vier Arten von Aufgaben:
+ Run Command-Befehle
+ Systems Manager Automation-Workflows
+ AWS Lambda-Funktionen
+ AWS Step Functions-Aufgaben
Wenn eine Wartungsfensteraufgabe, die Sie ausführen möchten, zusätzliche Ressourcen erfordert, gilt im Allgemeinen, dass Sie diese zuerst erstellen sollten. Beispiel: Wenn Sie in einem Wartungsfenster eine AWS Lambda-Funktion ausführen möchten, erstellen Sie zuerst die Lambda-Funktion, bevor Sie beginnen. Erstellen Sie für eine Run Command-Aufgabe zuerst den S3-Bucket zum Speichern der Befehlsausgabe (sofern Sie dies vorhaben) usw.
**Topics**
+ [Tutorials: Wartungsfenster erstellen und verwalten mit dem AWS CLI](maintenance-window-tutorial-cli.md)
+ [Tutorial: Erstellen Sie ein Wartungsfenster zum Patchen über die Konsole](maintenance-window-tutorial-patching.md)
# Tutorials: Wartungsfenster erstellen und verwalten mit dem AWS CLI
Dieser Abschnitt enthält Tutorials, die Sie mit der Verwendung der AWS Command Line Interface (AWS CLI) zur Ausführung der folgenden Schritte vertraut machen:
+ Erstellen und Konfigurieren eines Wartungsfensters
+ Anzeigen von Informationen zu Wartungsfenstern
+ Anzeigen von Informationen über Wartungsfenster-Aufgaben und Aufgabenausführungen
+ Aktualisieren eines Wartungsfensters
+ Löschen eines Wartungsfensters
**Behalten Sie den Überblick über die Ressourcen IDs**
Behalten Sie bei der Ausführung der Aufgaben in diesen AWS CLI Tutorials den Überblick über die Ressourcen, die durch die von Ihnen ausgeführten Befehle IDs generiert wurden. Sie können viele davon als Eingabe für nachfolgende Befehle verwenden. Wenn Sie beispielsweise das Wartungsfenster erstellen, stellt das System eine Wartungsfenster-ID im folgenden Format für Sie bereit.
```
{
"WindowId":"mw-0c50858d01EXAMPLE"
}
```
Notieren Sie sich die folgenden vom System generierten Informationen, IDs da sie in den Tutorials in diesem Abschnitt verwendet werden:
+ `WindowId`
+ `WindowTargetId`
+ `WindowTaskId`
+ `WindowExecutionId`
+ `TaskExecutionId`
+ `InvocationId`
+ `ExecutionId`
Sie benötigen außerdem die ID der EC2-Instance, die Sie in den Tutorials verwenden möchten. Beispiel: `i-02573cafcfEXAMPLE`
**Topics**
+ [Tutorial: Erstellen und konfigurieren Sie ein Wartungsfenster mit dem AWS CLI](maintenance-windows-cli-tutorials-create.md)
+ [Tutorial: Informationen zu Wartungsfenstern anzeigen mit dem AWS CLI](maintenance-windows-cli-tutorials-describe.md)
+ [Tutorial: Informationen zu Aufgaben und Aufgabenausführungen anzeigen mit dem AWS CLI](mw-cli-tutorial-task-info.md)
+ [Tutorial: Aktualisieren Sie ein Wartungsfenster mit dem AWS CLI](maintenance-windows-cli-tutorials-update.md)
+ [Tutorial: Löschen Sie ein Wartungsfenster mit dem AWS CLI](mw-cli-tutorial-delete-mw.md)
# Tutorial: Erstellen und konfigurieren Sie ein Wartungsfenster mit dem AWS CLI
In diesem Tutorial wird gezeigt, wie Sie mit AWS Command Line Interface (AWS CLI) ein Wartungsfenster sowie dessen Ziele und Aufgaben erstellen und konfigurieren. Der Hauptpfad durch das Tutorial besteht aus einfachen Schritten. Sie erstellen ein einziges Wartungsfenster, identifizieren ein einziges Ziel und richten eine einfache Aufgabe ein, die im Wartungsfenster ausgeführt werden soll. Entlang des Pfades stellen wir Informationen bereit, die Sie beim Ausprobieren komplexerer Szenarien unterstützen.
Wenn Sie die Schritte in diesem Tutorial befolgen, ersetzen Sie die Werte in kursivem *red* Text durch Ihre eigenen Optionen und. IDs Ersetzen Sie beispielsweise die ID des Wartungsfensters *mw-0c50858d01EXAMPLE* und die Instanz-ID durch die IDs von *i-02573cafcfEXAMPLE* Ihnen erstellten Ressourcen.
**Topics**
+ [Schritt 1: Erstellen Sie das Wartungsfenster mit dem AWS CLI](mw-cli-tutorial-create-mw.md)
+ [Schritt 2: Registrieren Sie einen Zielknoten im Wartungsfenster mithilfe des AWS CLI](mw-cli-tutorial-targets.md)
+ [Schritt 3: Registrieren Sie eine Aufgabe im Wartungsfenster mithilfe des AWS CLI](mw-cli-tutorial-tasks.md)
# Schritt 1: Erstellen Sie das Wartungsfenster mit dem AWS CLI
In diesem Schritt erstellen Sie ein Wartungsfenster und geben die grundlegenden Optionen, wie z. B. Name, Zeitplan und Dauer, an. In späteren Schritten, wählen Sie die Instance aus, die aktualisiert werden soll, und legen die Aufgabe fest, die ausgeführt wird.
In unserem Beispiel erstellen Sie ein Wartungsfenster, das alle fünf Minuten ausgeführt wird. Normalerweise würden Sie ein Wartungsfenster nicht so häufig ausführen. Mit dieser Rate werden Ihre Ergebnisse des Tutorials schneller ersichtlich. Wir zeigen Ihnen, wie Sie zu einer weniger häufigen Rate wechseln, nachdem die Aufgabe erfolgreich ausgeführt wurde.
**Anmerkung**
Eine Beschreibung des Verhältnisses zwischen den verschiedenen zeitplanbezogenen Optionen für Wartungsfenster finden Sie unter [Wartungsfenster-Optionen für Planung und aktive Zeiträume](maintenance-windows-schedule-options.md).
Weitere Informationen zum Arbeiten mit der `--schedule`-Option finden Sie unter [Referenz: Cron- und Rate-Ausdrücke für System Manager](reference-cron-and-rate-expressions.md).
**Um ein Wartungsfenster zu erstellen, verwenden Sie AWS CLI**
1. Öffnen Sie AWS Command Line Interface (AWS CLI) und führen Sie den folgenden Befehl auf Ihrem lokalen Computer aus, um ein Wartungsfenster zu erstellen, das Folgendes bewirkt:
+ Es wird (je nach Bedarf) über bis zu zwei Stunden hinweg alle fünf Minuten ausgeführt.
+ Verhindert, dass bis zu einer Stunde nach der Ausführung des Wartungsfensters neue Aufgaben gestartet werden.
+ Es ermöglicht nicht zugeordnete Ziele (Instances, die Sie nicht beim Wartungsfenster registriert haben).
+ Es gibt durch die Verwendung von benutzerdefinierten Tags an, dass sein Ersteller beabsichtigt, es in einem Tutorial zu verwenden.
------
#### [ Linux & macOS ]
```
aws ssm create-maintenance-window \
--name "My-First-Maintenance-Window" \
--schedule "rate(5 minutes)" \
--duration 2 \
--cutoff 1 \
--allow-unassociated-targets \
--tags "Key=Purpose,Value=Tutorial"
```
------
#### [ Windows ]
```
aws ssm create-maintenance-window ^
--name "My-First-Maintenance-Window" ^
--schedule "rate(5 minutes)" ^
--duration 2 ^
--cutoff 1 ^
--allow-unassociated-targets ^
--tags "Key"="Purpose","Value"="Tutorial"
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"WindowId":"mw-0c50858d01EXAMPLE"
}
```
1. Führen Sie jetzt den folgenden Befehl aus, um Details zu diesem und allen anderen Wartungsfenstern anzuzeigen, die Ihrem Konto bereits zugeordnet sind.
```
aws ssm describe-maintenance-windows
```
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"WindowIdentities":[
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"Enabled": true,
"Duration": 2,
"Cutoff": 1,
"NextExecutionTime": "2019-05-11T16:46:16.991Z"
}
]
}
```
Fahren Sie fort mit [Schritt 2: Registrieren Sie einen Zielknoten im Wartungsfenster mithilfe des AWS CLI](mw-cli-tutorial-targets.md).
# Schritt 2: Registrieren Sie einen Zielknoten im Wartungsfenster mithilfe des AWS CLI
In diesem Schritt registrieren Sie ein Ziel für Ihr neues Wartungsfenster. In diesem Fall geben Sie an, welcher Knoten aktualisiert werden soll, wenn das Wartungsfenster ausgeführt wird.
Ein Beispiel für die gleichzeitige Registrierung mehrerer Knoten mithilfe von Node IDs, Beispiele für die Verwendung von Tags zur Identifizierung mehrerer Knoten und Beispiele für die Angabe von Ressourcengruppen als Ziele finden Sie unter[Beispiele: Ziele für ein Wartungsfenster registrieren](mw-cli-tutorial-targets-examples.md).
**Anmerkung**
Sie sollten bereits eine in diesem Schritt zu verwendende Amazon Elastic Compute Cloud (Amazon EC2)-Instance nach der Beschreibung in den [Voraussetzungen für das Maintenance Windows-Tutorial](maintenance-windows-tutorials.md) erstellt haben.
**Um einen Zielknoten mit einem Wartungsfenster zu registrieren, verwenden Sie den AWS CLI**
1. Führen Sie den folgenden Befehl auf Ihrem lokalen Computer aus. Ersetzen Sie jeden *example resource placeholder* durch Ihre Informationen.
------
#### [ Linux & macOS ]
```
aws ssm register-target-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--resource-type "INSTANCE" \
--target "Key=InstanceIds,Values=i-02573cafcfEXAMPLE"
```
------
#### [ Windows ]
```
aws ssm register-target-with-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--resource-type "INSTANCE" ^
--target "Key=InstanceIds,Values=i-02573cafcfEXAMPLE"
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"WindowTargetId":"e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
}
```
1. Jetzt führen Sie den folgenden Befehl auf Ihrem lokalen Computer aus, um Details zu Ihrem Wartungsfensterziel anzuzeigen.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-targets \
--window-id "mw-0c50858d01EXAMPLE"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-targets ^
--window-id "mw-0c50858d01EXAMPLE"
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"Targets": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTargetId": "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE",
"ResourceType": "INSTANCE",
"Targets": [
{
"Key": "InstanceIds",
"Values": [
"i-02573cafcfEXAMPLE"
]
}
]
}
]
}
```
Fahren Sie fort mit [Schritt 3: Registrieren Sie eine Aufgabe im Wartungsfenster mithilfe des AWS CLI](mw-cli-tutorial-tasks.md).
# Beispiele: Ziele für ein Wartungsfenster registrieren
Sie können einen einzelnen Knoten mithilfe der Knoten-ID als Ziel registrieren. Die Anleitung dazu finden Sie unter [Schritt 2: Registrieren Sie einen Zielknoten im Wartungsfenster mithilfe des AWS CLI](mw-cli-tutorial-targets.md). Darüber hinaus haben Sie die Möglichkeit, einen oder mehrere Knoten mithilfe der Befehlsformate auf dieser Seite als Ziele zu registrieren.
Im Allgemeinen gibt es zwei Methoden, um Knoten als Ziele für das Wartungsfenster zu identifizieren: durch das Festlegen einzelner Knoten und mithilfe von Ressourcen-Tags. Die Ressourcen-Tags-Methode bietet weitere Optionen, wie in den Beispielen 2 bis 3 gezeigt.
Sie können auch eine oder mehrere Ressourcengruppen als Ziel eines Wartungsfensters angeben. Eine Ressourcengruppe kann Knoten und viele andere Arten unterstützter AWS Ressourcen enthalten. Die Beispiele 4 und 5 demonstrieren nun, wie Sie Ihren Zielen für das Wartungsfenster Ressourcengruppen hinzufügen.
**Anmerkung**
Wenn eine einzelne Wartungsfenster-Aufgabe mit mehreren Zielen registriert ist, werden ihre Aufrufe sequenziell und nicht parallel ausgeführt. Wenn Ihre Aufgabe gleichzeitig auf mehreren Zielen ausgeführt werden muss, registrieren Sie eine Aufgabe für jedes Ziel einzeln, und weisen Sie jeder Aufgabe dieselbe Prioritätsstufe zu.
Weitere Informationen zum Erstellen und Verwalten von Ressourcengruppen finden Sie unter [Was sind Ressourcengruppen?](https://docs.aws.amazon.com/ARG/latest/userguide/resource-groups.html) im *AWS -Ressourcengruppen -Benutzerhandbuch* und unter [Resource Groups and Tagging for AWS](https://aws.amazon.com/blogs/aws/resource-groups-and-tagging/) im *AWS News Blog*.
Weitere Informationen zu Kontingenten fürMaintenance Windows, ein Tool in AWS Systems Manager, zusätzlich zu den in den folgenden Beispielen angegebenen, finden Sie unter [Systems Manager Manager-Dienstkontingente](https://docs.aws.amazon.com/general/latest/gr/ssm.html#limits_ssm) in der *Allgemeine Amazon Web Services-Referenz*.
## Beispiel 1: Registrieren Sie mehrere Ziele mithilfe von Node IDs
Führen Sie den folgenden Befehl auf Ihrem lokalen Computerformat aus, um mehrere Knoten mithilfe ihres Knotens als Ziele zu registrieren IDs. Ersetzen Sie jeden *example resource placeholder* durch Ihre Informationen.
------
#### [ Linux & macOS ]
```
aws ssm register-target-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--resource-type "INSTANCE" \
--target "Key=InstanceIds,Values=i-02573cafcfEXAMPLE,i-0471e04240EXAMPLE,i-07782c72faEXAMPLE"
```
------
#### [ Windows ]
```
aws ssm register-target-with-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE ^
--resource-type "INSTANCE" ^
--target "Key=InstanceIds,Values=i-02573cafcfEXAMPLE,i-0471e04240EXAMPLE,i-07782c72faEXAMPLE
```
------
**Empfohlene Verwendung**: Besonders nützlich bei der erstmaligen Registrierung einer eindeutigen Gruppe von Knoten bei einem beliebigen Wartungsfenster, wenn die Knoten *nicht* über ein gemeinsames Knoten-Tag verfügen.
**Kontingente:** Sie können insgesamt bis zu 50 Knoten für jedes Wartungsfenster-Ziel angeben.
## Beispiel 2: Registrieren von Zielen mithilfe von Ressourcen-Tags, die auf Knoten angewendet werden
Führen Sie den folgenden Befehl auf Ihrer lokalen Maschine aus, um alle Knoten anzumelden, die bereits mit einem von Ihnen zugewiesenen Schlüssel-Wert-Paar markiert wurden. Ersetzen Sie jeden *example resource placeholder* durch Ihre Informationen.
------
#### [ Linux & macOS ]
```
aws ssm register-target-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--resource-type "INSTANCE" \
--target "Key=tag:Region,Values=East"
```
------
#### [ Windows ]
```
aws ssm register-target-with-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--resource-type "INSTANCE" ^
--target "Key=tag:Region,Values=East"
```
------
**Empfohlene Verwendung**: Besonders nützlich bei der erstmaligen Registrierung einer eindeutigen Gruppe von Knoten bei einem beliebigen Wartungsfenster, wenn die Knoten *schon* über ein gemeinsames Knoten-Tag verfügen.
**Kontingente:** Sie können insgesamt bis zu fünf Schlüssel-Wert-Paare für jedes Ziel festlegen. Wenn Sie mehr als ein Schlüssel-Wert-Paar angeben, muss ein Knoten mit *allen* Tag-Schlüsseln und Werten gekennzeichnet werden, die Sie für die Aufnahme in die Zielgruppe angeben.
**Anmerkung**
Sie können eine Gruppe von Knoten mit dem Tag-Schlüssel `Patch Group` oder `PatchGroup` markieren und die Knoten einem gemeinsamen Schlüsselwert zuweisen, z. B. `my-patch-group`. (Sie müssen `PatchGroup` ohne Leerzeichen verwenden, wenn Sie [Tags in EC2-Instance-Metadaten zugelassen haben](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#allow-access-to-tags-in-IMDS).) Patch Manager, ein Tool in Systems Manager, wertet den Schlüssel `Patch Group` oder `PatchGroup` auf Knoten aus, um zu bestimmen, welche Patch-Baseline für sie gilt. Wenn Ihre Aufgabe das `AWS-RunPatchBaseline`-SSM-Dokument (oder das Legacy-`AWS-ApplyPatchBaseline`-SSM-Dokument) ausführt, können Sie das gleiche `Patch Group`- oder `PatchGroup`-Schlüssel-Wert-Paar angeben, wenn Sie Ziele für ein Wartungsfenster registrieren. Beispiel: `--target "Key=tag:PatchGroup,Values=my-patch-group`. Auf diese Weise können Sie Patches für eine Gruppe von Knoten, die schon der gleichen Patch-Baseline zugeordnet sind, mithilfe eines Wartungsfensters aktualisieren. Weitere Informationen finden Sie unter [Patch-Gruppen](patch-manager-patch-groups.md).
## Beispiel 3: Registrieren von Zielen mithilfe einer Gruppe von Tag-Schlüsseln (ohne Tag-Werte)
Führen Sie den folgenden Befehl auf Ihrer lokalen Maschine aus, um Knoten anzumelden, denen alle ein oder mehrere Tag-Schlüssel zugeordnet wurden, unabhängig von ihren Schlüsselwerten. Ersetzen Sie jeden *example resource placeholder* durch Ihre Informationen.
------
#### [ Linux & macOS ]
```
aws ssm register-target-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--resource-type "INSTANCE" \
--target "Key=tag-key,Values=Name,Instance-Type,CostCenter"
```
------
#### [ Windows ]
```
aws ssm register-target-with-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--resource-type "INSTANCE" ^
--target "Key=tag-key,Values=Name,Instance-Type,CostCenter"
```
------
**Empfohlene Verwendung**: Diese Option ist hilfreich, wenn Sie Knoten als Ziele verwenden möchten, indem Sie mehrere Tag-*Schlüssel* (ohne Werte) angeben und nicht nur einen Tag-Schlüssel oder ein Tag-Schlüssel-Wert-Paar.
**Kontingente:** Sie können insgesamt bis zu fünf Tag-Schlüssel für jedes Ziel festlegen. Wenn Sie mehr als einen Tag-Schlüssel angeben, muss ein Knoten mit *allen* Tag-Schlüsseln und Werten markiert werden, die Sie für die Aufnahme in die Zielgruppe angeben.
## Beispiel 4: Registrieren von Zielen unter Verwendung eines Ressourcengruppennamens
Führen Sie den folgenden Befehl zum Registrieren einer bestimmten Ressourcengruppe auf Ihrem lokalen Computer aus, unabhängig von der Art der Ressourcen, die sie enthält. *mw-0c50858d01EXAMPLE*Ersetzen Sie es durch Ihre eigenen Informationen. Wenn die Aufgaben, die Sie dem Wartungsfenster zuweisen, auf eine Art von Ressource in dieser Ressourcengruppe nicht angewendet werden kann, meldet das System möglicherweise einen Fehler. Auch wenn ein solcher Fehler gemeldet wird, werden Aufgaben, für die ein unterstützter Ressourcentyp gefunden wurde, dennoch ausgeführt.
------
#### [ Linux & macOS ]
```
aws ssm register-target-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--resource-type "RESOURCE_GROUP" \
--target "Key=resource-groups:Name,Values=MyResourceGroup"
```
------
#### [ Windows ]
```
aws ssm register-target-with-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--resource-type "RESOURCE_GROUP" ^
--target "Key=resource-groups:Name,Values=MyResourceGroup"
```
------
**Empfohlene Verwendung**: Diese Vorgehensweise ist hilfreich, wenn Sie schnell eine Ressourcengruppe als Ziel angeben möchten, ohne auszuwerten, ob alle Ressourcentypen Ziel des Wartungsfensters sind, oder wenn Sie wissen, dass die Ressourcengruppe nur solche Ressourcentypen enthält, über denen Ihre Aufgaben Aktionen durchführen können.
**Kontingente:** Sie können nur eine Ressourcengruppe als Ziel angeben.
## Beispiel 5: Registrieren von Zielen durch Filtern von Ressourcentypen in einer Ressourcengruppe
Führen Sie den folgenden Befehl auf Ihrem lokalen Computer aus, um nur bestimmte Ressourcentypen zu registrieren, die einer Ressourcengruppe angehören, die Sie angeben. *mw-0c50858d01EXAMPLE*Ersetzen Sie durch Ihre eigenen Informationen. Bei dieser Vorgehensweise wird eine Aufgabe, selbst wenn Sie sie für einen Ressourcentyp hinzufügen, der der Ressourcengruppe angehört, nicht ausgeführt, wenn Sie den Filter nicht explizit auf den Ressourcentyp setzen
------
#### [ Linux & macOS ]
```
aws ssm register-target-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--resource-type "RESOURCE_GROUP" \
--target "Key=resource-groups:Name,Values=MyResourceGroup" \
"Key=resource-groups:ResourceTypeFilters,Values=AWS::EC2::Instance,AWS::ECS::Cluster"
```
------
#### [ Windows ]
```
aws ssm register-target-with-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--resource-type "RESOURCE_GROUP" ^
--target "Key=resource-groups:Name,Values=MyResourceGroup" ^
"Key=resource-groups:ResourceTypeFilters,Values=AWS::EC2::Instance,AWS::ECS::Cluster"
```
------
**Empfohlene Verwendung**: Nützlich, wenn Sie die strenge Kontrolle über die Arten von AWS Ressourcen behalten möchten, für die im Wartungsfenster Aktionen ausgeführt werden können, oder wenn Ihre Ressourcengruppe eine große Anzahl von Ressourcentypen enthält und Sie unnötige Fehlerberichte in Ihren Wartungsfensterprotokollen vermeiden möchten.
**Kontingente:** Sie können nur eine Ressourcengruppe als Ziel angeben.
# Schritt 3: Registrieren Sie eine Aufgabe im Wartungsfenster mithilfe des AWS CLI
In diesem Schritt des Tutorials registrieren Sie eine AWS Systems Manager Run Command Aufgabe, die den `df` Befehl auf Ihrer Amazon Elastic Compute Cloud (Amazon EC2) -Instance für Linux ausführt. Die Ergebnisse dieses Standard-Linux-Befehls zeigen, wie viel Speicherplatz frei ist und wie viel Speicherplatz auf dem Festplatten-Dateisystem Ihrer Instance belegt wird.
–oder–
Wenn Sie die Anweisungen an eine Amazon-EC2-Instance für Windows Server anstatt für Linux richten, ersetzen Sie **df** im folgenden Befehl durch **ipconfig**. Die Ausgabe dieses Befehls enthält Details über die IP-Adresse, die Subnetzmaske und das Standard-Gateway für Adapter auf der Ziel-Instance.
Wenn Sie zum Registrieren anderer Aufgabentypen oder zur Verwendung weiterer verfügbarer Run Command Systems Manager-Optionen bereit sind, finden Sie unter [Beispiele: Registrieren von Aufgaben für ein Wartungsfenster](mw-cli-register-tasks-examples.md) weitere Informationen. Dort befinden sich weitere Informationen zu allen vier Aufgabentypen und einigen ihrer wichtigsten Optionen, die Sie beim Planen umfassenderer realer Szenarien unterstützen.
**So registrieren Sie eine Aufgabe für ein Wartungsfenster**
1. Führen Sie den folgenden Befehl auf Ihrem lokalen Computer aus. Ersetzen Sie jeden *example resource placeholder* durch Ihre Informationen. Die Version, die von einem lokalen Windows-Computer aus ausgeführt werden soll, enthält die Escape-Zeichen („/“), die Sie zum Ausführen des Befehls über Ihr Befehlszeilen-Tool benötigen.
------
#### [ Linux & macOS ]
```
aws ssm register-task-with-maintenance-window \
--window-id mw-0c50858d01EXAMPLE \
--task-arn "AWS-RunShellScript" \
--max-concurrency 1 --max-errors 1 \
--priority 10 \
--targets "Key=InstanceIds,Values=i-0471e04240EXAMPLE" \
--task-type "RUN_COMMAND" \
--task-invocation-parameters '{"RunCommand":{"Parameters":{"commands":["df"]}}}'
```
------
#### [ Windows ]
```
aws ssm register-task-with-maintenance-window ^
--window-id mw-0c50858d01EXAMPLE ^
--task-arn "AWS-RunShellScript" ^
--max-concurrency 1 --max-errors 1 ^
--priority 10 ^
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE" ^
--task-type "RUN_COMMAND" ^
--task-invocation-parameters={\"RunCommand\":{\"Parameters\":{\"commands\":[\"df\"]}}}
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden:
```
{
"WindowTaskId": "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE"
}
```
1. Führen Sie nun den folgenden Befehl aus, um Details zu der von Ihnen erstellten Wartungsfensteraufgabe anzuzeigen.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-tasks \
--window-id mw-0c50858d01EXAMPLE
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-tasks ^
--window-id mw-0c50858d01EXAMPLE
```
------
1. Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"Tasks": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTaskId": "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"TaskArn": "AWS-RunShellScript",
"Type": "RUN_COMMAND",
"Targets": [
{
"Key": "InstanceIds",
"Values": [
"i-02573cafcfEXAMPLE"
]
}
],
"TaskParameters": {},
"Priority": 10,
"ServiceRoleArn": "arn:aws:iam::123456789012:role/MyMaintenanceWindowServiceRole",
"MaxConcurrency": "1",
"MaxErrors": "1"
}
]
}
```
1. Räumen Sie basierend auf dem von Ihnen in [Schritt 1: Erstellen Sie das Wartungsfenster mit dem AWS CLI](mw-cli-tutorial-create-mw.md) angegebenen Zeitplan genügend Zeit für die Aufgabenausführung ein. Wenn Sie **--schedule "rate(5 minutes)"** angegeben haben, warten Sie beispielsweise fünf Minuten. Führen Sie dann den folgenden Befehl aus, um Informationen über alle Ausführungen anzuzeigen, die für diese Aufgabe aufgetreten sind.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-executions \
--window-id mw-0c50858d01EXAMPLE
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-executions ^
--window-id mw-0c50858d01EXAMPLE
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"WindowExecutions": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowExecutionId": "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE",
"Status": "SUCCESS",
"StartTime": 1557593493.096,
"EndTime": 1557593498.611
}
]
}
```
**Tipp**
Nachdem die Aufgabe erfolgreich durchgeführt wurde, können Sie die Rate verringern, mit der das Wartungsfenster ausgeführt wird. Führen Sie beispielsweise den folgenden Befehl aus, um die Häufigkeit auf einmal pro Woche zu verringern. Ersetzen Sie es *mw-0c50858d01EXAMPLE* durch Ihre eigenen Informationen.
```
aws ssm update-maintenance-window \
--window-id mw-0c50858d01EXAMPLE \
--schedule "rate(7 days)"
```
```
aws ssm update-maintenance-window ^
--window-id mw-0c50858d01EXAMPLE ^
--schedule "rate(7 days)"
```
Weitere Informationen zum Verwalten von Wartungsfenster-Zeitplänen finden Sie unter [Referenz: Cron- und Rate-Ausdrücke für System Manager](reference-cron-and-rate-expressions.md) und [Wartungsfenster-Optionen für Planung und aktive Zeiträume](maintenance-windows-schedule-options.md).
Hinweise zur Verwendung von AWS Command Line Interface (AWS CLI) zum Ändern eines Wartungsfensters finden Sie unter[Tutorial: Aktualisieren Sie ein Wartungsfenster mit dem AWS CLI](maintenance-windows-cli-tutorials-update.md).
Um zu üben, wie Sie AWS CLI Befehle ausführen, um weitere Informationen über Ihre Wartungsfensteraufgabe und deren Ausführung zu [Tutorial: Informationen zu Aufgaben und Aufgabenausführungen anzeigen mit dem AWS CLI](mw-cli-tutorial-task-info.md) erhalten, fahren Sie fort unter.
**Zugreifen auf die Tutorial-Befehlsausgabe**
Es würde den Rahmen dieses Tutorials sprengen, den zu verwenden AWS CLI , um die *Ausgabe* des Run Command Befehls anzuzeigen, der mit der Ausführung Ihrer Wartungsfensteraufgaben verknüpft ist.
Sie könnten diese Daten jedoch mit dem AWS CLI anzeigen. (Sie können die Ausgabe auch in der Systems Manager-Konsole oder in einer in einem Amazon Simple Storage Service (Amazon S3)-Bucket gespeicherten Protokolldatei anzeigen, sofern Sie das Wartungsfenster zur Befehlsausgabe an dieser Stelle konfiguriert haben.) In diesem Fall würden Sie feststellen, dass die Ausgabe des Befehls **df** auf einer EC2-Instance für Linux ähnlich der folgenden ist.
```
Filesystem 1K-blocks Used Available Use% Mounted on
devtmpfs 485716 0 485716 0% /dev
tmpfs 503624 0 503624 0% /dev/shm
tmpfs 503624 328 503296 1% /run
tmpfs 503624 0 503624 0% /sys/fs/cgroup
/dev/xvda1 8376300 1464160 6912140 18% /
```
Die Ausgabe des Befehls **ipconfig** auf einer EC2-Instance für Windows Server sieht in etwa wie folgt aus:
```
Windows IP Configuration
Ethernet adapter Ethernet 2:
Connection-specific DNS Suffix . : example.com
IPv4 Address. . . . . . . . . . . : 10.24.34.0/23
Subnet Mask . . . . . . . . . . . : 255.255.255.255
Default Gateway . . . . . . . . . : 0.0.0.0
Ethernet adapter Ethernet:
Media State . . . . . . . . . . . : Media disconnected
Connection-specific DNS Suffix . : abc1.wa.example.net
Wireless LAN adapter Local Area Connection* 1:
Media State . . . . . . . . . . . : Media disconnected
Connection-specific DNS Suffix . :
Wireless LAN adapter Wi-Fi:
Connection-specific DNS Suffix . :
Link-local IPv6 Address . . . . . : fe80::100b:c234:66d6:d24f%4
IPv4 Address. . . . . . . . . . . : 192.0.2.0
Subnet Mask . . . . . . . . . . . : 255.255.255.0
Default Gateway . . . . . . . . . : 192.0.2.0
Ethernet adapter Bluetooth Network Connection:
Media State . . . . . . . . . . . : Media disconnected
Connection-specific DNS Suffix . :
```
# Beispiele: Registrieren von Aufgaben für ein Wartungsfenster
Sie können eine Aufgabe inRun Command, ein Tool in AWS Systems Manager, mit einem Wartungsfenster registrieren, indem Sie die AWS Command Line Interface (AWS CLI) verwenden, wie unter [Aufgaben im Wartungsfenster registrieren](mw-cli-tutorial-tasks.md) gezeigt. Sie können auch Aufgaben für Workflows, AWS Lambda Funktionen und AWS Step Functions Aufgaben von Systems Manager Automation registrieren, wie weiter unten in diesem Thema gezeigt wird.
**Anmerkung**
Geben Sie ein oder mehrere Ziele für Wartungsfenster Run Command-Typ-Aufgaben an. Je nach Aufgabe sind Ziele für andere Aufgabentypen im Wartungsfenster (Automatisierung AWS Lambda, und AWS Step Functions) optional. Weitere Informationen zur Ausführung von Aufgaben, die keine Ziele angeben, finden Sie unter [Wartungsfenster-Tasks ohne Ziele registrieren](maintenance-windows-targetless-tasks.md).
In diesem Thema finden Sie Beispiele für die Verwendung des Befehls AWS Command Line Interface (AWS CLI)`register-task-with-maintenance-window`, um jeden der vier unterstützten Aufgabentypen in einem Wartungsfenster zu registrieren. Die Beispiele dienen nur zur Veranschaulichung. Sie können sie abwandeln, um funktionsfähige Befehle zur Aufgabenregistrierung zu erstellen.
**Verwenden der cli-input-json Option --**
Zur besseren Verwaltung Ihrer Aufgabenoptionen können Sie die Befehlsoption `--cli-input-json` mit in einer JSON-Datei referenzierten Optionswerten verwenden.
Um den Inhalt der JSON-Beispieldatei zu verwenden, den wir in den folgenden Beispielen bereitgestellt haben, führen Sie auf Ihrem lokalen Computer die die folgenden Schritte aus:
1. Erstellen Sie eine Datei mit einem Namen wie z. B. `MyRunCommandTask.json`, `MyAutomationTask.json` oder einem anderen von Ihnen bevorzugten Namen.
1. Kopieren Sie den Inhalt der JSON-Beispieldatei in die Datei.
1. Ändern Sie den Inhalt der Datei für Ihre Aufgabenregistrierung ab und speichern Sie dann die Datei.
1. Führen Sie in demselben Verzeichnis, in dem Sie die Datei gespeichert haben, den folgenden Befehl aus. Ersetzen Sie Ihren Dateinamen durch*MyFile.json*.
------
#### [ Linux & macOS ]
```
aws ssm register-task-with-maintenance-window \
--cli-input-json file://MyFile.json
```
------
#### [ Windows ]
```
aws ssm register-task-with-maintenance-window ^
--cli-input-json file://MyFile.json
```
------
**Pseudo-Parameter in Wartungsfenster-Aufgaben**
In einigen Beispielen verwenden wir *Pseudoparameter* als Methode zur Übergabe von ID-Informationen an Ihre Aufgaben. Zum Beispiel `{{TARGET_ID}}` und `{{RESOURCE_ID}}` kann verwendet werden, um AWS Ressourcen an Automation-, Lambda- und Step Functions Functions-Aufgaben weiterzugeben IDs . Weitere Informationen zu Pseudoparametern im `--task-invocation-parameters`-Inhalt finden Sie unter [Verwendung von Pseudo-Parametern bei der Registrierung von Aufgaben im Wartungsfenster](maintenance-window-tasks-pseudo-parameters.md).
**Weitere Informationen**
+ [Parameteroptionen für den Befehl register-task-with-maintenance -windows](mw-cli-task-options.md).
+ [https://docs.aws.amazon.com/cli/latest/reference/ssm/register-task-with-maintenance-window.html](https://docs.aws.amazon.com/cli/latest/reference/ssm/register-task-with-maintenance-window.html) in der *AWS CLI Befehlsreferenz*
+ [https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_RegisterTaskWithMaintenanceWindow.html](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_RegisterTaskWithMaintenanceWindow.html) in der *AWS Systems Manager -API-Referenz*
## Beispiele der Aufgabenregistrierung
Die folgenden Abschnitte enthalten einen AWS CLI Beispielbefehl für die Registrierung eines unterstützten Aufgabentyps und ein JSON-Beispiel, das mit der `--cli-input-json` Option verwendet werden kann.
### Registrieren einer Systems Manager Run Command-Aufgabe
Die folgenden Beispiele veranschaulichen, wie Sie Aufgaben von Systems Manager Run Command-Aufgaben mithilfe der AWS CLI bei einem Wartungsfenster registrieren.
------
#### [ Linux & macOS ]
```
aws ssm register-task-with-maintenance-window \
--window-id mw-0c50858d01EXAMPLE \
--task-arn "AWS-RunShellScript" \
--max-concurrency 1 --max-errors 1 --priority 10 \
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE" \
--task-type "RUN_COMMAND" \
--task-invocation-parameters '{"RunCommand":{"Parameters":{"commands":["df"]}}}'
```
------
#### [ Windows ]
```
aws ssm register-task-with-maintenance-window ^
--window-id mw-0c50858d01EXAMPLE ^
--task-arn "AWS-RunShellScript" ^
--max-concurrency 1 --max-errors 1 --priority 10 ^
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE" ^
--task-type "RUN_COMMAND" ^
--task-invocation-parameters "{\"RunCommand\":{\"Parameters\":{\"commands\":[\"df\"]}}}"
```
------
**JSON-Inhalt für die Verwendung mit der Dateioption `--cli-input-json`:**
```
{
"TaskType": "RUN_COMMAND",
"WindowId": "mw-0c50858d01EXAMPLE",
"Description": "My Run Command task to update SSM Agent on an instance",
"MaxConcurrency": "1",
"MaxErrors": "1",
"Name": "My-Run-Command-Task",
"Priority": 10,
"Targets": [
{
"Key": "WindowTargetIds",
"Values": [
"e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
]
}
],
"TaskArn": "AWS-UpdateSSMAgent",
"TaskInvocationParameters": {
"RunCommand": {
"Comment": "A TaskInvocationParameters test comment",
"NotificationConfig": {
"NotificationArn": "arn:aws:sns:region:123456789012:my-sns-topic-name",
"NotificationEvents": [
"All"
],
"NotificationType": "Invocation"
},
"OutputS3BucketName": "amzn-s3-demo-bucket",
"OutputS3KeyPrefix": "S3-PREFIX",
"TimeoutSeconds": 3600
}
}
}
```
### Registrieren einer Systems Manager Automation-Aufgabe
Die folgenden Beispiele veranschaulichen, wie Systems Manager Automation-Aufgaben mithilfe der bei einem Wartungsfenster registriert werden AWS CLI:
**AWS CLI Befehl:**
------
#### [ Linux & macOS ]
```
aws ssm register-task-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--task-arn "AWS-RestartEC2Instance" \
--service-role-arn arn:aws:iam::123456789012:role/MyMaintenanceWindowServiceRole \
--task-type AUTOMATION \
--task-invocation-parameters "Automation={DocumentVersion=5,Parameters={InstanceId='{{RESOURCE_ID}}'}}" \
--priority 0 --name "My-Restart-EC2-Instances-Automation-Task" \
--description "Automation task to restart EC2 instances"
```
------
#### [ Windows ]
```
aws ssm register-task-with-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--task-arn "AWS-RestartEC2Instance" ^
--service-role-arn arn:aws:iam::123456789012:role/MyMaintenanceWindowServiceRole ^
--task-type AUTOMATION ^
--task-invocation-parameters "Automation={DocumentVersion=5,Parameters={InstanceId='{{TARGET_ID}}'}}" ^
--priority 0 --name "My-Restart-EC2-Instances-Automation-Task" ^
--description "Automation task to restart EC2 instances"
```
------
**JSON-Inhalt für die Verwendung mit der Dateioption `--cli-input-json`:**
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"TaskArn": "AWS-PatchInstanceWithRollback",
"TaskType": "AUTOMATION","TaskInvocationParameters": {
"Automation": {
"DocumentVersion": "1",
"Parameters": {
"instanceId": [
"{{RESOURCE_ID}}"
]
}
}
}
}
```
### Eine AWS Lambda Aufgabe registrieren
Die folgenden Beispiele veranschaulichen, wie Lambda-Funktionsaufgaben mithilfe der AWS CLI bei einem Wartungsfenster registriert werden.
Bei diesen Beispielen hat der Benutzer, der die Lambda-Funktion erstellt hat, ihr den Namen `SSMrestart-my-instances` gegeben und zwei Parameter mit dem Namen `instanceId` und `targetType` erstellt.
**Wichtig**
Die IAM-Richtlinie für Maintenance Windows erfordert, dass Sie den Namen von Lambda-Funktionen (oder Aliasen) das Präfix `SSM` hinzufügen. Bevor Sie mit der Registrierung dieser Art von Aufgabe fortfahren, aktualisieren Sie ihren Namen so, dass er AWS Lambda einschließt`SSM`. Beispiel: Wenn Ihr Lambda-Funktionsname `MyLambdaFunction` lautet, ändern Sie ihn in `SSMMyLambdaFunction`.
**AWS CLI Befehl:**
------
#### [ Linux & macOS ]
**Wichtig**
Wenn Sie Version 2 von verwenden AWS CLI, müssen Sie die Option `--cli-binary-format raw-in-base64-out` in den folgenden Befehl aufnehmen, wenn Ihre Lambda-Payload nicht base64-codiert ist. Die Option `cli_binary_format` ist nur in Version 2 verfügbar. *Informationen zu diesen und anderen AWS CLI `config` Dateieinstellungen finden Sie im Benutzerhandbuch unter [Unterstützte `config` Dateieinstellungen](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html#cli-configure-files-settings).AWS Command Line Interface *
```
aws ssm register-task-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" \
--priority 2 --max-concurrency 10 --max-errors 5 --name "My-Lambda-Example" \
--description "A description for my LAMBDA example task" --task-type "LAMBDA" \
--task-arn "arn:aws:lambda:region:123456789012:function:serverlessrepo-SSMrestart-my-instances-C4JF9EXAMPLE" \
--task-invocation-parameters '{"Lambda":{"Payload":"{\"InstanceId\":\"{{RESOURCE_ID}}\",\"targetType\":\"{{TARGET_TYPE}}\"}","Qualifier": "$LATEST"}}'
```
------
#### [ PowerShell ]
**Wichtig**
Wenn Sie Version 2 von verwenden AWS CLI, müssen Sie die Option `--cli-binary-format raw-in-base64-out` in den folgenden Befehl aufnehmen, wenn Ihre Lambda-Payload nicht base64-codiert ist. Die Option `cli_binary_format` ist nur in Version 2 verfügbar. *Informationen zu diesen und anderen AWS CLI `config` Dateieinstellungen finden Sie im Benutzerhandbuch unter [Unterstützte `config` Dateieinstellungen](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html#cli-configure-files-settings).AWS Command Line Interface *
```
aws ssm register-task-with-maintenance-window `
--window-id "mw-0c50858d01EXAMPLE" `
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" `
--priority 2 --max-concurrency 10 --max-errors 5 --name "My-Lambda-Example" `
--description "A description for my LAMBDA example task" --task-type "LAMBDA" `
--task-arn "arn:aws:lambda:region:123456789012:function:serverlessrepo-SSMrestart-my-instances-C4JF9EXAMPLE" `
--task-invocation-parameters '{\"Lambda\":{\"Payload\":\"{\\\"InstanceId\\\":\\\"{{RESOURCE_ID}}\\\",\\\"targetType\\\":\\\"{{TARGET_TYPE}}\\\"}\",\"Qualifier\": \"$LATEST\"}}'
```
------
**JSON-Inhalt für die Verwendung mit der Dateioption `--cli-input-json`:**
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Targets": [
{
"Key": "WindowTargetIds",
"Values": [
"e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
]
}
],
"TaskArn": "SSM_RestartMyInstances",
"TaskType": "LAMBDA",
"MaxConcurrency": "10",
"MaxErrors": "10",
"TaskInvocationParameters": {
"Lambda": {
"ClientContext": "ew0KICAi--truncated--0KIEXAMPLE",
"Payload": "{ \"instanceId\": \"{{RESOURCE_ID}}\", \"targetType\": \"{{TARGET_TYPE}}\" }",
"Qualifier": "$LATEST"
}
},
"Name": "My-Lambda-Task",
"Description": "A description for my LAMBDA task",
"Priority": 5
}
```
### Register a Step Functions task (Eine Step Functions-Aufgabe registrieren)
Die folgenden Beispiele veranschaulichen, wie Sie Aufgaben von Step Functions-Zustandsautomaten mithilfe der AWS CLI bei einem Wartungsfenster registrieren.
**Anmerkung**
Aufgaben im Wartungsfenster unterstützen nur Zustandsmaschinen-Workflows von Step Functions Standard. Sie unterstützen keine Express-Zustandsmaschinen-Workflows. Informationen zu Workflowtypen für Zustandsmaschinen finden Sie unter [Standard- gegenüber Express-Workflows](https://docs.aws.amazon.com/step-functions/latest/dg/concepts-standard-vs-express.html) im *AWS Step Functions -Entwicklerhandbuch*.
In diesen Beispielen erstellte der Benutzer, der den Step Functions-Zustandsautomaten erstellt hatte, einen Zustandsautomaten mit dem Namen „`SSMMyStateMachine`“ und dem Parameter „`instanceId`“.
**Wichtig**
Die AWS Identity and Access Management (IAM-) Richtlinie für Maintenance Windows erfordert, dass Sie Step Functions Functions-Zustandsmaschinen das Präfix voranstellen. `SSM` Bevor Sie mit dem Registrieren dieser Art von Aufgabe fortfahren, müssen Sie ihren Namen in AWS Step Functions so aktualisieren, dass in ihm `SSM` enthalten ist. Beispiel: Wenn der Name des Zustandsautomaten `MyStateMachine` lautet, ändern Sie ihn in `SSMMyStateMachine`.
**AWS CLI Befehl:**
------
#### [ Linux & macOS ]
```
aws ssm register-task-with-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" \
--task-arn arn:aws:states:region:123456789012:stateMachine:SSMMyStateMachine-MggiqEXAMPLE \
--task-type STEP_FUNCTIONS \
--task-invocation-parameters '{"StepFunctions":{"Input":"{\"InstanceId\":\"{{RESOURCE_ID}}\"}", "Name":"{{INVOCATION_ID}}"}}' \
--priority 0 --max-concurrency 10 --max-errors 5 \
--name "My-Step-Functions-Task" --description "A description for my Step Functions task"
```
------
#### [ PowerShell ]
```
aws ssm register-task-with-maintenance-window `
--window-id "mw-0c50858d01EXAMPLE" `
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" `
--task-arn arn:aws:states:region:123456789012:stateMachine:SSMMyStateMachine-MggiqEXAMPLE `
--task-type STEP_FUNCTIONS `
--task-invocation-parameters '{\"StepFunctions\":{\"Input\":\"{\\\"InstanceId\\\":\\\"{{RESOURCE_ID}}\\\"}\", \"Name\":\"{{INVOCATION_ID}}\"}}' `
--priority 0 --max-concurrency 10 --max-errors 5 `
--name "My-Step-Functions-Task" --description "A description for my Step Functions task"
```
------
**JSON-Inhalt für die Verwendung mit der Dateioption `--cli-input-json`:**
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Targets": [
{
"Key": "WindowTargetIds",
"Values": [
"e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
]
}
],
"TaskArn": "SSM_MyStateMachine",
"TaskType": "STEP_FUNCTIONS",
"MaxConcurrency": "10",
"MaxErrors": "10",
"TaskInvocationParameters": {
"StepFunctions": {
"Input": "{ \"instanceId\": \"{{TARGET_ID}}\" }",
"Name": "{{INVOCATION_ID}}"
}
},
"Name": "My-Step-Functions-Task",
"Description": "A description for my Step Functions task",
"Priority": 5
}
```
# Parameteroptionen für den Befehl register-task-with-maintenance -windows
Der Befehl **register-task-with-maintenance-window** bietet mehrere Optionen für die Konfiguration einer Aufgabe entsprechend Ihren Anforderungen. Einige sind erforderlich, einige sind optional und einige gelten nur für einen einzigen Wartungsfenster-Aufgabentyp.
In diesem Thema erhalten Sie Informationen zu einigen dieser Optionen, um Sie bei der Arbeit mit Beispielen in diesem Abschnitt des Tutorials zu unterstützen. Informationen über alle Befehlsoptionen finden Sie unter **[https://docs.aws.amazon.com/cli/latest/reference/ssm/register-task-with-maintenance-window.html](https://docs.aws.amazon.com/cli/latest/reference/ssm/register-task-with-maintenance-window.html)** in der *AWS CLI Command Reference*.
**Befehlsoption: `--task-arn`**
Die Option `--task-arn` wird verwendet, um die Ressource anzugeben, die von der Aufgabe ausgeführt wird. Der von Ihnen angegebene Wert hängt wie in der folgenden Tabelle beschrieben, davon ab, welche Art von Aufgabe Sie registrieren möchten.
**TaskArn Formate für Aufgaben im Wartungsfenster**
| Wartungsfenster-Aufgabentyp | TaskArn Wert |
| --- | --- |
| **`RUN_COMMAND`** und ** `AUTOMATION`** | `TaskArn` ist der SSM-Dokumentname oder der Amazon-Ressourcenname (ARN). Zum Beispiel: `AWS-RunBatchShellScript` –oder– `arn:aws:ssm:region:111122223333:document/My-Document`. |
| **`LAMBDA`** | `TaskArn` ist der Funktionsname oder -ARN. Zum Beispiel: `SSMMy-Lambda-Function` –oder– `arn:aws:lambda:region:111122223333:function:SSMMyLambdaFunction`. Die IAM-Richtlinie für Maintenance Windows erfordert, dass Sie den Namen von Lambda-Funktionen (oder Aliasen) das Präfix `SSM` hinzufügen. Bevor Sie mit der Registrierung dieser Art von Aufgabe fortfahren, aktualisieren Sie ihren Namen so, dass er AWS Lambda einschließt`SSM`. Beispiel: Wenn Ihr Lambda-Funktionsname `MyLambdaFunction` lautet, ändern Sie ihn in `SSMMyLambdaFunction`. |
| **`STEP_FUNCTIONS`** | `TaskArn` ist der ARN des Zustandsautomaten. Zum Beispiel: `arn:aws:states:us-east-2:111122223333:stateMachine:SSMMyStateMachine`. Die IAM-Richtlinie für Wartungsfenster erfordert, dass Sie Step Functions-Zustandsautomaten-Namen das Präfix `SSM` geben. Bevor Sie diese Art der Aufgabe registrieren können, müssen Sie ihren Namen in AWS Step Functions so aktualisieren, dass in ihm `SSM` enthalten ist. Beispiel: Wenn der Name des Zustandsautomaten `MyStateMachine` lautet, ändern Sie ihn in `SSMMyStateMachine`. |
**Befehlsoption: `--service-role-arn`**
Die Rolle AWS Systems Manager , die bei der Ausführung der Wartungsfensteraufgabe übernommen werden soll.
Weitere Informationen finden Sie unter [Einrichten von Maintenance Windows](setting-up-maintenance-windows.md).
**Befehlsoption: `--task-invocation-parameters`**
Die Option `--task-invocation-parameters` wird dazu verwendet, jene Parameter anzugeben, die nur für die vier Aufgabentypen gelten. Die unterstützten Parameter für jede der vier Arten von Aufgaben werden in der folgenden Tabelle beschrieben.
**Anmerkung**
Weitere Informationen über die Verwendung von Pseudoparametern in `--task-invocation-parameters`-Inhalten, z. B. \$1\$1TARGET\$1ID\$1\$1, finden Sie unter [Verwendung von Pseudo-Parametern bei der Registrierung von Aufgaben im Wartungsfenster](maintenance-window-tasks-pseudo-parameters.md).
Aufgabenaufruf-Parameteroptionen für Wartungsfenster-Aufgaben
| Wartungsfenster-Aufgabentyp | Verfügbare Parameter | Beispiel |
| --- | --- | --- |
| **`RUN_COMMAND`** | `Comment` `DocumentHash` `DocumentHashType` `NotificationConfig` `OutputS3BucketName` `OutPutS3KeyPrefix` `Parameters` `ServiceRoleArn` `TimeoutSeconds` | "TaskInvocationParameters": {
"RunCommand": {
"Comment": "My Run Command task comment",
"DocumentHash": "6554ed3d--truncated--5EXAMPLE",
"DocumentHashType": "Sha256",
"NotificationConfig": {
"NotificationArn": "arn:aws:sns:region:123456789012:my-sns-topic-name",
"NotificationEvents": [
"FAILURE"
],
"NotificationType": "Invocation"
},
"OutputS3BucketName": "amzn-s3-demo-bucket",
"OutputS3KeyPrefix": "S3-PREFIX",
"Parameters": {
"commands": [
"Get-ChildItem$env: temp-Recurse|Remove-Item-Recurse-force"
]
},
"ServiceRoleArn": "arn:aws:iam::123456789012:role/MyMaintenanceWindowServiceRole",
"TimeoutSeconds": 3600
}
} |
| **`AUTOMATION`** | `DocumentVersion` `Parameters` | "TaskInvocationParameters": {
"Automation": {
"DocumentVersion": "3",
"Parameters": {
"instanceid": [
"{{TARGET_ID}}"
]
}
}
} |
| **`LAMBDA`** | `ClientContext` `Payload` `Qualifier` | "TaskInvocationParameters": {
"Lambda": {
"ClientContext": "ew0KICAi--truncated--0KIEXAMPLE",
"Payload": "{ \"targetId\": \"{{TARGET_ID}}\", \"targetType\": \"{{TARGET_TYPE}}\" }",
"Qualifier": "$LATEST"
}
} |
| **`STEP_FUNCTIONS`** | `Input` `Name` | "TaskInvocationParameters": {
"StepFunctions": {
"Input": "{ \"targetId\": \"{{TARGET_ID}}\" }",
"Name": "{{INVOCATION_ID}}"
}
} |
# Tutorial: Informationen zu Wartungsfenstern anzeigen mit dem AWS CLI
In diesem Tutorial sind Befehle enthalten, mit denen Sie Ihre Wartungsfenster, Aufgaben, Ausführungen und Aufrufe aktualisieren oder Informationen darüber abrufen können. Die Beispiele sind nach Befehl geordnet, um zu zeigen, wie Befehlsoptionen verwendet werden, um nach der Art von Details zu filtern, die Sie anzeigen möchten.
Wenn Sie die Schritte in diesem Tutorial befolgen, ersetzen Sie die Werte in kursivem *red* Text durch Ihre eigenen Optionen und. IDs Ersetzen Sie beispielsweise die ID des Wartungsfensters *mw-0c50858d01EXAMPLE* und die Instanz-ID durch die IDs von *i-02573cafcfEXAMPLE* Ihnen erstellten Ressourcen.
Informationen zur Einrichtung und Konfiguration von AWS Command Line Interface (AWS CLI) finden Sie unter [Installation, Aktualisierung und Deinstallation von AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) und [Konfiguration von](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html). AWS CLI
**Topics**
+ [Beispiele für '' describe-maintenance-windows](#mw-cli-tutorials-describe-maintenance-windows)
+ [Beispiele für 'describe-maintenance-window-targets'](#mw-cli-tutorials-describe-maintenance-window-targets)
+ [Beispiele für 'describe-maintenance-window-tasks'](#mw-cli-tutorials-describe-maintenance-window-tasks)
+ [Beispiele für 'describe-maintenance-windows-for-target'](#mw-cli-tutorials-describe-maintenance-windows-for-target)
+ [Beispiele für '' describe-maintenance-window-executions](#mw-cli-tutorials-describe-maintenance-window-executions)
+ [Beispiele für 'describe-maintenance-window-schedule'](#mw-cli-tutorials-describe-maintenance-window-schedule)
## Beispiele für '' describe-maintenance-windows
**Listet alle Wartungsfenster in Ihrem auf AWS-Konto**
Führen Sie den folgenden Befehl aus.
```
aws ssm describe-maintenance-windows
```
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"WindowIdentities":[
{
"WindowId":"mw-0c50858d01EXAMPLE",
"Name":"My-First-Maintenance-Window",
"Enabled":true,
"Duration":2,
"Cutoff":0,
"NextExecutionTime": "2019-05-18T17:01:01.137Z"
},
{
"WindowId":"mw-9a8b7c6d5eEXAMPLE",
"Name":"My-Second-Maintenance-Window",
"Enabled":true,
"Duration":4,
"Cutoff":1,
"NextExecutionTime": "2019-05-30T03:30:00.137Z"
},
]
}
```
**Alle aktivierten Wartungsfenster aufführen**
Führen Sie den folgenden Befehl aus.
```
aws ssm describe-maintenance-windows --filters "Key=Enabled,Values=true"
```
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"WindowIdentities":[
{
"WindowId":"mw-0c50858d01EXAMPLE",
"Name":"My-First-Maintenance-Window",
"Enabled":true,
"Duration":2,
"Cutoff":0,
"NextExecutionTime": "2019-05-18T17:01:01.137Z"
},
{
"WindowId":"mw-9a8b7c6d5eEXAMPLE",
"Name":"My-Second-Maintenance-Window",
"Enabled":true,
"Duration":4,
"Cutoff":1,
"NextExecutionTime": "2019-05-30T03:30:00.137Z"
},
]
}
```
**Alle deaktivierten Wartungsfenster aufführen**
Führen Sie den folgenden Befehl aus.
```
aws ssm describe-maintenance-windows --filters "Key=Enabled,Values=false"
```
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"WindowIdentities": [
{
"WindowId": "mw-6e5c9d4b7cEXAMPLE",
"Name": "My-Disabled-Maintenance-Window",
"Enabled": false,
"Duration": 2,
"Cutoff": 1
}
]
}
```
**Alle Wartungsfenster aufführen, deren Name mit einem bestimmten Präfix beginnt**
Führen Sie den folgenden Befehl aus.
```
aws ssm describe-maintenance-windows --filters "Key=Name,Values=My"
```
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"WindowIdentities": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"Enabled": true,
"Duration": 2,
"Cutoff": 0,
"NextExecutionTime": "2019-05-18T17:01:01.137Z"
},
{
"WindowId": "mw-9a8b7c6d5eEXAMPLE",
"Name": "My-Second-Maintenance-Window",
"Enabled": true,
"Duration": 4,
"Cutoff": 1,
"NextExecutionTime": "2019-05-30T03:30:00.137Z"
},
{
"WindowId": "mw-6e5c9d4b7cEXAMPLE",
"Name": "My-Disabled-Maintenance-Window",
"Enabled": false,
"Duration": 2,
"Cutoff": 1
}
]
}
```
## Beispiele für 'describe-maintenance-window-targets'
**Die Ziele für ein Wartungsfenster anzeigen, das einem bestimmten Eigentümer-Informationswert entspricht**
Führen Sie den folgenden Befehl aus.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-targets \
--window-id "mw-6e5c9d4b7cEXAMPLE" \
--filters "Key=OwnerInformation,Values=CostCenter1"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-targets ^
--window-id "mw-6e5c9d4b7cEXAMPLE" ^
--filters "Key=OwnerInformation,Values=CostCenter1"
```
------
**Anmerkung**
Die unterstützten Filterschlüssel sind `Type`, `WindowTargetId` und `OwnerInformation`.
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"Targets": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTargetId": "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE",
"ResourceType": "INSTANCE",
"Targets": [
{
"Key": "tag:Name",
"Values": [
"Production"
]
}
],
"OwnerInformation": "CostCenter1",
"Name": "Target1"
}
]
}
```
## Beispiele für 'describe-maintenance-window-tasks'
**Alle registrierten Aufgaben anzeigen, die das SSM-Befehlsdokument `AWS-RunPowerShellScript` aufrufen**
Führen Sie den folgenden Befehl aus.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-tasks \
--window-id "mw-0c50858d01EXAMPLE" \
--filters "Key=TaskArn,Values=AWS-RunPowerShellScript"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-tasks ^
--window-id "mw-0c50858d01EXAMPLE" ^
--filters "Key=TaskArn,Values=AWS-RunPowerShellScript"
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"Tasks":[
{
"ServiceRoleArn": "arn:aws:iam::111122223333:role/MyMaintenanceWindowServiceRole",
"MaxErrors":"1",
"TaskArn":"AWS-RunPowerShellScript",
"MaxConcurrency":"1",
"WindowTaskId":"4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"TaskParameters":{
"commands":{
"Values":[
"driverquery.exe"
]
}
},
"Priority":3,
"Type":"RUN_COMMAND",
"Targets":[
{
"TaskTargetId":"i-02573cafcfEXAMPLE",
"TaskTargetType":"INSTANCE"
}
]
},
{
"ServiceRoleArn":"arn:aws:iam::111122223333:role/MyMaintenanceWindowServiceRole",
"MaxErrors":"1",
"TaskArn":"AWS-RunPowerShellScript",
"MaxConcurrency":"1",
"WindowTaskId":"4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"TaskParameters":{
"commands":{
"Values":[
"ipconfig"
]
}
},
"Priority":1,
"Type":"RUN_COMMAND",
"Targets":[
{
"TaskTargetId":"i-02573cafcfEXAMPLE",
"TaskTargetType":"WINDOW_TARGET"
}
]
}
]
}
```
**Alle registrierten Aufgaben mit Priorität 3 anzeigen**
Führen Sie den folgenden Befehl aus.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-tasks \
--window-id "mw-9a8b7c6d5eEXAMPLE" \
--filters "Key=Priority,Values=3"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-tasks ^
--window-id "mw-9a8b7c6d5eEXAMPLE" ^
--filters "Key=Priority,Values=3"
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"Tasks":[
{
"ServiceRoleArn":"arn:aws:iam::111122223333:role/MyMaintenanceWindowServiceRole",
"MaxErrors":"1",
"TaskArn":"AWS-RunPowerShellScript",
"MaxConcurrency":"1",
"WindowTaskId":"4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"TaskParameters":{
"commands":{
"Values":[
"driverquery.exe"
]
}
},
"Priority":3,
"Type":"RUN_COMMAND",
"Targets":[
{
"TaskTargetId":"i-02573cafcfEXAMPLE",
"TaskTargetType":"INSTANCE"
}
]
}
]
}
```
**Alle registrierten Aufgaben anzeigen, die Priorität "1" haben und Run Command verwenden**
Führen Sie den folgenden Befehl aus.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-tasks \
--window-id "mw-0c50858d01EXAMPLE" \
--filters "Key=Priority,Values=1" "Key=TaskType,Values=RUN_COMMAND"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-tasks ^
--window-id "mw-0c50858d01EXAMPLE" ^
--filters "Key=Priority,Values=1" "Key=TaskType,Values=RUN_COMMAND"
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"Tasks": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTaskId": "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"TaskArn": "AWS-RunShellScript",
"Type": "RUN_COMMAND",
"Targets": [
{
"Key": "InstanceIds",
"Values": [
"i-02573cafcfEXAMPLE"
]
}
],
"TaskParameters": {},
"Priority": 1,
"ServiceRoleArn": "arn:aws:iam::111122223333:role/MyMaintenanceWindowServiceRole",
"MaxConcurrency": "1",
"MaxErrors": "1"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTaskId": "8a5c4629-31b0-4edd-8aea-33698EXAMPLE",
"TaskArn": "AWS-UpdateSSMAgent",
"Type": "RUN_COMMAND",
"Targets": [
{
"Key": "InstanceIds",
"Values": [
"i-0471e04240EXAMPLE"
]
}
],
"TaskParameters": {},
"Priority": 1,
"ServiceRoleArn": "arn:aws:iam::111122223333:role/MyMaintenanceWindowServiceRole",
"MaxConcurrency": "1",
"MaxErrors": "1",
"Name": "My-Run-Command-Task",
"Description": "My Run Command task to update SSM Agent on an instance"
}
]
}
```
## Beispiele für 'describe-maintenance-windows-for-target'
**Informationen über die Wartungsfensterziele oder -Aufgaben im Zusammenhang mit einem bestimmten Knoten aufführen**
Führen Sie den folgenden Befehl aus.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-windows-for-target \
--resource-type INSTANCE \
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE" \
--max-results 10
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-windows-for-target ^
--resource-type INSTANCE ^
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE" ^
--max-results 10
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"WindowIdentities": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window"
},
{
"WindowId": "mw-9a8b7c6d5eEXAMPLE",
"Name": "My-Second-Maintenance-Window"
}
]
}
```
## Beispiele für '' describe-maintenance-window-executions
**Alle Aufgaben aufführen, die vor einem bestimmten Datum ausgeführt wurden**
Führen Sie den folgenden Befehl aus.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-executions \
--window-id "mw-9a8b7c6d5eEXAMPLE" \
--filters "Key=ExecutedBefore,Values=2019-05-12T05:00:00Z"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-executions ^
--window-id "mw-9a8b7c6d5eEXAMPLE" ^
--filters "Key=ExecutedBefore,Values=2019-05-12T05:00:00Z"
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"WindowExecutions": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowExecutionId": "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE",
"Status": "FAILED",
"StatusDetails": "The following SSM parameters are invalid: LevelUp",
"StartTime": 1557617747.993,
"EndTime": 1557617748.101
},
{
"WindowId": "mw-9a8b7c6d5eEXAMPLE",
"WindowExecutionId": "791b72e0-f0da-4021-8b35-f95dfEXAMPLE",
"Status": "SUCCESS",
"StartTime": 1557594085.428,
"EndTime": 1557594090.978
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowExecutionId": "ecec60fa-6bb0-4d26-98c7-140308EXAMPLE",
"Status": "SUCCESS",
"StartTime": 1557593793.483,
"EndTime": 1557593798.978
}
]
}
```
**Alle Aufgaben aufführen, die nach einem bestimmten Datum ausgeführt wurden**
Führen Sie den folgenden Befehl aus.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-executions \
--window-id "mw-9a8b7c6d5eEXAMPLE" \
--filters "Key=ExecutedAfter,Values=2018-12-31T17:00:00Z"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-executions ^
--window-id "mw-9a8b7c6d5eEXAMPLE" ^
--filters "Key=ExecutedAfter,Values=2018-12-31T17:00:00Z"
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"WindowExecutions": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowExecutionId": "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE",
"Status": "FAILED",
"StatusDetails": "The following SSM parameters are invalid: LevelUp",
"StartTime": 1557617747.993,
"EndTime": 1557617748.101
},
{
"WindowId": "mw-9a8b7c6d5eEXAMPLE",
"WindowExecutionId": "791b72e0-f0da-4021-8b35-f95dfEXAMPLE",
"Status": "SUCCESS",
"StartTime": 1557594085.428,
"EndTime": 1557594090.978
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowExecutionId": "ecec60fa-6bb0-4d26-98c7-140308EXAMPLE",
"Status": "SUCCESS",
"StartTime": 1557593793.483,
"EndTime": 1557593798.978
}
]
}
```
## Beispiele für 'describe-maintenance-window-schedule'
**Die nächsten zehn Wartungsfenster-Ausführungen, die für einen bestimmten Knoten geplant sind, anzeigen**
Führen Sie den folgenden Befehl aus.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-schedule \
--resource-type INSTANCE \
--targets "Key=InstanceIds,Values=i-07782c72faEXAMPLE" \
--max-results 10
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-schedule ^
--resource-type INSTANCE ^
--targets "Key=InstanceIds,Values=i-07782c72faEXAMPLE" ^
--max-results 10
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"ScheduledWindowExecutions": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"ExecutionTime": "2019-05-18T23:35:24.902Z"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"ExecutionTime": "2019-05-25T23:35:24.902Z"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"ExecutionTime": "2019-06-01T23:35:24.902Z"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"ExecutionTime": "2019-06-08T23:35:24.902Z"
},
{
"WindowId": "mw-9a8b7c6d5eEXAMPLE",
"Name": "My-Second-Maintenance-Window",
"ExecutionTime": "2019-06-15T23:35:24.902Z"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"ExecutionTime": "2019-06-22T23:35:24.902Z"
},
{
"WindowId": "mw-9a8b7c6d5eEXAMPLE",
"Name": "My-Second-Maintenance-Window",
"ExecutionTime": "2019-06-29T23:35:24.902Z"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"ExecutionTime": "2019-07-06T23:35:24.902Z"
},
{
"WindowId": "mw-9a8b7c6d5eEXAMPLE",
"Name": "My-Second-Maintenance-Window",
"ExecutionTime": "2019-07-13T23:35:24.902Z"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "My-First-Maintenance-Window",
"ExecutionTime": "2019-07-20T23:35:24.902Z"
}
],
"NextToken": "AAEABUXdceT92FvtKld/dGHELj5Mi+GKW/EXAMPLE"
}
```
**Den Wartungsfenster-Zeitplan für Knoten anzeigen, die mit einem bestimmten Schlüssel-Wert-Paar markiert sind**
Führen Sie den folgenden Befehl aus.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-schedule \
--resource-type INSTANCE \
--targets "Key=tag:prod,Values=rhel7"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-schedule ^
--resource-type INSTANCE ^
--targets "Key=tag:prod,Values=rhel7"
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"ScheduledWindowExecutions": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "DemoRateStartDate",
"ExecutionTime": "2019-10-20T05:34:56-07:00"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "DemoRateStartDate",
"ExecutionTime": "2019-10-21T05:34:56-07:00"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "DemoRateStartDate",
"ExecutionTime": "2019-10-22T05:34:56-07:00"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "DemoRateStartDate",
"ExecutionTime": "2019-10-23T05:34:56-07:00"
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"Name": "DemoRateStartDate",
"ExecutionTime": "2019-10-24T05:34:56-07:00"
}
],
"NextToken": "AAEABccwSXqQRGKiTZ1yzGELR6cxW4W/EXAMPLE"
}
```
**Startzeiten für die nächsten vier Ausführungen eines Wartungsfensters anzeigen**
Führen Sie den folgenden Befehl aus.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-schedule \
--window-id "mw-0c50858d01EXAMPLE" \
--max-results "4"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-schedule ^
--window-id "mw-0c50858d01EXAMPLE" ^
--max-results "4"
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"WindowSchedule": [
{
"ScheduledWindowExecutions": [
{
"ExecutionTime": "2019-10-04T10:10:10Z",
"Name": "My-First-Maintenance-Window",
"WindowId": "mw-0c50858d01EXAMPLE"
},
{
"ExecutionTime": "2019-10-11T10:10:10Z",
"Name": "My-First-Maintenance-Window",
"WindowId": "mw-0c50858d01EXAMPLE"
},
{
"ExecutionTime": "2019-10-18T10:10:10Z",
"Name": "My-First-Maintenance-Window",
"WindowId": "mw-0c50858d01EXAMPLE"
},
{
"ExecutionTime": "2019-10-25T10:10:10Z",
"Name": "My-First-Maintenance-Window",
"WindowId": "mw-0c50858d01EXAMPLE"
}
]
}
]
}
```
# Tutorial: Informationen zu Aufgaben und Aufgabenausführungen anzeigen mit dem AWS CLI
In diesem Tutorial wird gezeigt, wie Sie mit AWS Command Line Interface (AWS CLI) Details zu Ihren abgeschlossenen Aufgaben im Wartungsfenster anzeigen können.
Wenn Sie direkt von [Tutorial: Erstellen und konfigurieren Sie ein Wartungsfenster mit dem AWS CLI](maintenance-windows-cli-tutorials-create.md) fortfahren, überprüfen Sie, dass genügend Zeit verstrichen ist, damit das Wartungsfenster mindestens einmal ausgeführt werden konnte, um die Ausführungsergebnisse anzuzeigen.
Wenn Sie die Schritte in diesem Tutorial befolgen, ersetzen Sie die Werte in kursivem *red* Text durch Ihre eigenen Optionen und. IDs Ersetzen Sie beispielsweise die ID des Wartungsfensters *mw-0c50858d01EXAMPLE* und die Instanz-ID durch die IDs von *i-02573cafcfEXAMPLE* Ihnen erstellten Ressourcen.
**Um Informationen über Aufgaben und Aufgabenausführungen mit dem AWS CLI**
1. Führen Sie den folgenden Befe.l aus, um eine Liste der Aufgabenausführungen für ein bestimmtes Wartungsfenster anzuzeigen:
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-executions \
--window-id "mw-0c50858d01EXAMPLE"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-executions ^
--window-id "mw-0c50858d01EXAMPLE"
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"WindowExecutions": [
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowExecutionId": "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE",
"Status": "SUCCESS",
"StartTime": 1557593793.483,
"EndTime": 1557593798.978
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowExecutionId": "791b72e0-f0da-4021-8b35-f95dfEXAMPLE",
"Status": "SUCCESS",
"StartTime": 1557593493.096,
"EndTime": 1557593498.611
},
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowExecutionId": "ecec60fa-6bb0-4d26-98c7-140308EXAMPLE",
"Status": "SUCCESS",
"StatusDetails": "No tasks to execute.",
"StartTime": 1557593193.309,
"EndTime": 1557593193.334
}
]
}
```
1. Führen Sie den folgenden Befehl aus, um Informationen zu der Aufgabenausführung eines Wartungsfensters abzurufen.
------
#### [ Linux & macOS ]
```
aws ssm get-maintenance-window-execution \
--window-execution-id "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE"
```
------
#### [ Windows ]
```
aws ssm get-maintenance-window-execution ^
--window-execution-id "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE"
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"WindowExecutionId": "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE",
"TaskIds": [
"c9b05aba-197f-4d8d-be34-e73fbEXAMPLE"
],
"Status": "SUCCESS",
"StartTime": 1557593493.096,
"EndTime": 1557593498.611
}
```
1. Führen Sie den folgenden Befehl aus, um eine Liste der Aufgabenausführungen als Teil einer Wartungsfenster-Ausführung anzuzeigen.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-execution-tasks \
--window-execution-id "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-execution-tasks ^
--window-execution-id "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE"
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"WindowExecutionTaskIdentities": [
{
"WindowExecutionId": "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE",
"TaskExecutionId": "c9b05aba-197f-4d8d-be34-e73fbEXAMPLE",
"Status": "SUCCESS",
"StartTime": 1557593493.162,
"EndTime": 1557593498.57,
"TaskArn": "AWS-RunShellScript",
"TaskType": "RUN_COMMAND"
}
]
}
```
1. Führen Sie den folgenden Befehl aus, um Details zu einer Aufgabenausführung abzurufen.
------
#### [ Linux & macOS ]
```
aws ssm get-maintenance-window-execution-task \
--window-execution-id "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE" \
--task-id "c9b05aba-197f-4d8d-be34-e73fbEXAMPLE"
```
------
#### [ Windows ]
```
aws ssm get-maintenance-window-execution-task ^
--window-execution-id "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE" ^
--task-id "c9b05aba-197f-4d8d-be34-e73fbEXAMPLE"
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"WindowExecutionId": "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE",
"TaskExecutionId": "c9b05aba-197f-4d8d-be34-e73fbEXAMPLE",
"TaskArn": "AWS-RunShellScript",
"ServiceRole": "arn:aws:iam::111122223333:role/MyMaintenanceWindowServiceRole",
"Type": "RUN_COMMAND",
"TaskParameters": [
{
"aws:InstanceId": {
"Values": [
"i-02573cafcfEXAMPLE"
]
},
"commands": {
"Values": [
"df"
]
}
}
],
"Priority": 10,
"MaxConcurrency": "1",
"MaxErrors": "1",
"Status": "SUCCESS",
"StartTime": 1557593493.162,
"EndTime": 1557593498.57
}
```
1. Führen Sie den folgenden Befehl aus, um die spezifischen Aufgabenaufrufe abzurufen, die bei einer Aufgabenausführung durchgeführt werden.
------
#### [ Linux & macOS ]
```
aws ssm describe-maintenance-window-execution-task-invocations \
--window-execution-id "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE" \
--task-id "c9b05aba-197f-4d8d-be34-e73fbEXAMPLE"
```
------
#### [ Windows ]
```
aws ssm describe-maintenance-window-execution-task-invocations ^
--window-execution-id "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE" ^
--task-id "c9b05aba-197f-4d8d-be34-e73fbEXAMPLE"
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"WindowExecutionTaskInvocationIdentities": [
{
"WindowExecutionId": "14bea65d-5ccc-462d-a2f3-e99c8EXAMPLE",
"TaskExecutionId": "c9b05aba-197f-4d8d-be34-e73fbEXAMPLE",
"InvocationId": "c336d2ab-09de-44ba-8f6a-6136cEXAMPLE",
"ExecutionId": "76a5a04f-caf6-490c-b448-92c02EXAMPLE",
"TaskType": "RUN_COMMAND",
"Parameters": "{\"documentName\":\"AWS-RunShellScript\",\"instanceIds\":[\"i-02573cafcfEXAMPLE\"],\"maxConcurrency\":\"1\",\"maxErrors\":\"1\",\"parameters\":{\"commands\":[\"df\"]}}",
"Status": "SUCCESS",
"StatusDetails": "Success",
"StartTime": 1557593493.222,
"EndTime": 1557593498.466
}
]
}
```
# Tutorial: Aktualisieren Sie ein Wartungsfenster mit dem AWS CLI
Dieses Tutorial zeigt, wie Sie das AWS Command Line Interface (AWS CLI) verwenden, um ein Wartungsfenster zu aktualisieren. Es zeigt Ihnen auch, wie Sie verschiedene Aufgabentypen aktualisieren, einschließlich der Aufgabentypen für AWS Systems Manager Run Command und Automatisierung AWS Lambda, und AWS Step Functions.
In den Beispielen dieses Abschnitts werden die folgenden Systems Manager-Aktionen zum Aktualisieren eines Wartungsfensters verwendet:
+ [UpdateMaintenanceWindow](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_UpdateMaintenanceWindow.html)
+ [UpdateMaintenanceWindowTarget](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_UpdateMaintenanceWindowTarget.html)
+ [UpdateMaintenanceWindowTask](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_UpdateMaintenanceWindowTask.html)
+ [DeregisterTargetFromMaintenanceWindow](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_DeregisterTargetFromMaintenanceWindow.html)
Weitere Informationen zum Aktualisieren eines Wartungsfensters über die Systems Manager-Konsole finden Sie unter [Ressourcen für das Wartungsfenster mithilfe der Konsole aktualisieren oder löschen](sysman-maintenance-update.md).
Wenn Sie die Schritte in diesem Tutorial befolgen, ersetzen Sie die Werte in kursivem *red* Text durch Ihre eigenen Optionen und. IDs Ersetzen Sie beispielsweise die ID des Wartungsfensters *mw-0c50858d01EXAMPLE* und die Instanz-ID durch die IDs von *i-02573cafcfEXAMPLE* Ihnen erstellten Ressourcen.
**Um ein Wartungsfenster mit dem zu aktualisieren AWS CLI**
1. Öffnen Sie das AWS CLI und führen Sie den folgenden Befehl aus, um ein Ziel so zu aktualisieren, dass es einen Namen und eine Beschreibung enthält.
------
#### [ Linux & macOS ]
```
aws ssm update-maintenance-window-target \
--window-id "mw-0c50858d01EXAMPLE" \
--window-target-id "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" \
--name "My-Maintenance-Window-Target" \
--description "Description for my maintenance window target"
```
------
#### [ Windows ]
```
aws ssm update-maintenance-window-target ^
--window-id "mw-0c50858d01EXAMPLE" ^
--window-target-id "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" ^
--name "My-Maintenance-Window-Target" ^
--description "Description for my maintenance window target"
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTargetId": "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE",
"Targets": [
{
"Key": "InstanceIds",
"Values": [
"i-02573cafcfEXAMPLE"
]
}
],
"Name": "My-Maintenance-Window-Target",
"Description": "Description for my maintenance window target"
}
```
1. Führen Sie den folgenden Befehl aus, um mit der `replace`-Option das Beschreibungsfeld zu entfernen und ein zusätzliches Ziel hinzuzufügen. Das Beschreibungsfeld wird gelöscht, da die Aktualisierung das Feld nicht enthält (NULL-Wert). Stellen Sie sicher, dass Sie einen zusätzlichen Knoten angeben, der für die Verwendung mit Systems Manager konfiguriert wurde.
------
#### [ Linux & macOS ]
```
aws ssm update-maintenance-window-target \
--window-id "mw-0c50858d01EXAMPLE" \
--window-target-id "d208dedf-3f6b-41ff-ace8-8e751EXAMPLE" \
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE,i-0471e04240EXAMPLE" \
--name "My-Maintenance-Window-Target" \
--replace
```
------
#### [ Windows ]
```
aws ssm update-maintenance-window-target ^
--window-id "mw-0c50858d01EXAMPLE" ^
--window-target-id "d208dedf-3f6b-41ff-ace8-8e751EXAMPLE" ^
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE,i-0471e04240EXAMPLE" ^
--name "My-Maintenance-Window-Target" ^
--replace
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTargetId": "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE",
"Targets": [
{
"Key": "InstanceIds",
"Values": [
"i-02573cafcfEXAMPLE",
"i-0471e04240EXAMPLE"
]
}
],
"Name": "My-Maintenance-Window-Target"
}
```
1. Die Option `start-date` erlaubt Ihnen, die Aktivierung eines Wartungsfensters bis zu einem angegebenen künftigen Zeitpunkt zu verzögern. Die Option `end-date` erlaubt Ihnen, ein in der Zukunft liegendes Datum sowie eine Uhrzeit festzulegen, nach dem das Wartungsfenster nicht mehr ausgeführt wird. Geben Sie die Optionen im erweiterten ISO-8601-Format an.
Führen Sie den folgenden Befehl aus, um ein Datum oder eine Zeitspanne für die regelmäßig geplanten Wartungsfenster-Ausführungen anzugeben.
------
#### [ Linux & macOS ]
```
aws ssm update-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--start-date "2020-10-01T10:10:10Z" \
--end-date "2020-11-01T10:10:10Z"
```
------
#### [ Windows ]
```
aws ssm update-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--start-date "2020-10-01T10:10:10Z" ^
--end-date "2020-11-01T10:10:10Z"
```
------
1. Führen Sie den folgenden Befehl aus, um eine Run Command-Aufgabe zu aktualisieren.
**Tipp**
Wenn es sich bei Ihrem Ziel um eine Amazon Elastic Compute Cloud (Amazon EC2)-Instance für Windows Server handelt, ändern Sie `df` auf `ipconfig` und `AWS-RunShellScript` auf `AWS-RunPowerShellScript` im folgenden Befehl.
------
#### [ Linux & macOS ]
```
aws ssm update-maintenance-window-task \
--window-id "mw-0c50858d01EXAMPLE" \
--window-task-id "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE" \
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" \
--task-arn "AWS-RunShellScript" \
--service-role-arn "arn:aws:iam::account-id:role/MaintenanceWindowsRole" \
--task-invocation-parameters "RunCommand={Comment=Revising my Run Command task,Parameters={commands=df}}" \
--priority 1 --max-concurrency 10 --max-errors 4 \
--name "My-Task-Name" --description "A description for my Run Command task"
```
------
#### [ Windows ]
```
aws ssm update-maintenance-window-task ^
--window-id "mw-0c50858d01EXAMPLE" ^
--window-task-id "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE" ^
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" ^
--task-arn "AWS-RunShellScript" ^
--service-role-arn "arn:aws:iam::account-id:role/MaintenanceWindowsRole" ^
--task-invocation-parameters "RunCommand={Comment=Revising my Run Command task,Parameters={commands=df}}" ^
--priority 1 --max-concurrency 10 --max-errors 4 ^
--name "My-Task-Name" --description "A description for my Run Command task"
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTaskId": "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"Targets": [
{
"Key": "WindowTargetIds",
"Values": [
"e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
]
}
],
"TaskArn": "AWS-RunShellScript",
"ServiceRoleArn": "arn:aws:iam::111122223333:role/MaintenanceWindowsRole",
"TaskParameters": {},
"TaskInvocationParameters": {
"RunCommand": {
"Comment": "Revising my Run Command task",
"Parameters": {
"commands": [
"df"
]
}
}
},
"Priority": 1,
"MaxConcurrency": "10",
"MaxErrors": "4",
"Name": "My-Task-Name",
"Description": "A description for my Run Command task"
}
```
1. Passen Sie den folgenden Befehl aus und führen Sie ihn aus, um eine Lambda-Aufgabe zu aktualisieren.
------
#### [ Linux & macOS ]
```
aws ssm update-maintenance-window-task \
--window-id mw-0c50858d01EXAMPLE \
--window-task-id 4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE \
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" \
--task-arn "arn:aws:lambda:region:111122223333:function:SSMTestLambda" \
--service-role-arn "arn:aws:iam:account-id:role/MaintenanceWindowsRole" \
--task-invocation-parameters '{"Lambda":{"Payload":"{\"InstanceId\":\"{{RESOURCE_ID}}\",\"targetType\":\"{{TARGET_TYPE}}\"}"}}' \
--priority 1 --max-concurrency 10 --max-errors 5 \
--name "New-Lambda-Task-Name" \
--description "A description for my Lambda task"
```
------
#### [ Windows ]
```
aws ssm update-maintenance-window-task ^
--window-id mw-0c50858d01EXAMPLE ^
--window-task-id 4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE ^
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" ^
--task-arn --task-arn "arn:aws:lambda:region:111122223333:function:SSMTestLambda" ^
--service-role-arn "arn:aws:iam:account-id:role/MaintenanceWindowsRole" ^
--task-invocation-parameters '{"Lambda":{"Payload":"{\"InstanceId\":\"{{RESOURCE_ID}}\",\"targetType\":\"{{TARGET_TYPE}}\"}"}}' ^
--priority 1 --max-concurrency 10 --max-errors 5 ^
--name "New-Lambda-Task-Name" ^
--description "A description for my Lambda task"
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTaskId": "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"Targets": [
{
"Key": "WindowTargetIds",
"Values": "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
}
],
"TaskArn": "arn:aws:lambda:us-east-2:111122223333:function:SSMTestLambda",
"ServiceRoleArn": "arn:aws:iam::111122223333:role/MaintenanceWindowsRole",
"TaskParameters": {},
"TaskInvocationParameters": {
"Lambda": {
"Payload": "e30="
}
},
"Priority": 1,
"MaxConcurrency": "10",
"MaxErrors": "5",
"Name": "New-Lambda-Task-Name",
"Description": "A description for my Lambda task"
}
```
1. Wenn Sie eine Step Functions Functions-Aufgabe aktualisieren, passen Sie sie an und führen Sie den folgenden Befehl aus, um sie zu aktualisieren task-invocation-parameters.
------
#### [ Linux & macOS ]
```
aws ssm update-maintenance-window-task \
--window-id "mw-0c50858d01EXAMPLE" \
--window-task-id "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE" \
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" \
--task-arn "arn:aws:states:region:execution:SSMStepFunctionTest" \
--service-role-arn "arn:aws:iam:account-id:role/MaintenanceWindowsRole" \
--task-invocation-parameters '{"StepFunctions":{"Input":"{\"InstanceId\":\"{{RESOURCE_ID}}\"}"}}' \
--priority 0 --max-concurrency 10 --max-errors 5 \
--name "My-Step-Functions-Task" \
--description "A description for my Step Functions task"
```
------
#### [ Windows ]
```
aws ssm update-maintenance-window-task ^
--window-id "mw-0c50858d01EXAMPLE" ^
--window-task-id "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE" ^
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" ^
--task-arn "arn:aws:states:region:execution:SSMStepFunctionTest" ^
--service-role-arn "arn:aws:iam:account-id:role/MaintenanceWindowsRole" ^
--task-invocation-parameters '{"StepFunctions":{"Input":"{\"InstanceId\":\"{{RESOURCE_ID}}\"}"}}' ^
--priority 0 --max-concurrency 10 --max-errors 5 ^
--name "My-Step-Functions-Task" ^
--description "A description for my Step Functions task"
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTaskId": "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"Targets": [
{
"Key": "WindowTargetIds",
"Values": [
"e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
]
}
],
"TaskArn": "arn:aws:states:us-east-2:111122223333:execution:SSMStepFunctionTest",
"ServiceRoleArn": "arn:aws:iam::111122223333:role/MaintenanceWindowsRole",
"TaskParameters": {},
"TaskInvocationParameters": {
"StepFunctions": {
"Input": "{\"instanceId\":\"{{RESOURCE_ID}}\"}"
}
},
"Priority": 0,
"MaxConcurrency": "10",
"MaxErrors": "5",
"Name": "My-Step-Functions-Task",
"Description": "A description for my Step Functions task"
}
```
1. Führen Sie den folgenden Befehl aus, um ein Ziel von einem Wartungsfenster abzumelden. In diesem Beispiel wird der `safe`-Parameter verwendet, um zu bestimmen, ob beliebige Aufgaben auf das Ziel verweisen und es sicher abgemeldet werden kann.
------
#### [ Linux & macOS ]
```
aws ssm deregister-target-from-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--window-target-id "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" \
--safe
```
------
#### [ Windows ]
```
aws ssm deregister-target-from-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--window-target-id "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" ^
--safe
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
An error occurred (TargetInUseException) when calling the DeregisterTargetFromMaintenanceWindow operation:
This Target cannot be deregistered because it is still referenced in Task: 4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE
```
1. Führen Sie den folgenden Befehl aus, um ein Ziel auch dann von einem Wartungsfenster abzumelden, wenn eine Aufgabe auf das Ziel verweist. Sie können den Abmeldevorgang mit dem `no-safe`-Parameter erzwingen.
------
#### [ Linux & macOS ]
```
aws ssm deregister-target-from-maintenance-window \
--window-id "mw-0c50858d01EXAMPLE" \
--window-target-id "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" \
--no-safe
```
------
#### [ Windows ]
```
aws ssm deregister-target-from-maintenance-window ^
--window-id "mw-0c50858d01EXAMPLE" ^
--window-target-id "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE" ^
--no-safe
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTargetId": "e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
}
```
1. Führen Sie den folgenden Befehl aus, um eine Run Command-Aufgabe zu aktualisieren. Dieses Beispiel verwendet einen Parameter Store Systems Manager-Parameter mit dem Namen `UpdateLevel` und der folgenden Formatierung: `{{ssm:UpdateLevel}}`'
------
#### [ Linux & macOS ]
```
aws ssm update-maintenance-window-task \
--window-id "mw-0c50858d01EXAMPLE" \
--window-task-id "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE" \
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE" \
--task-invocation-parameters "RunCommand={Comment=A comment for my task update,Parameters={UpdateLevel='{{ssm:UpdateLevel}}'}}"
```
------
#### [ Windows ]
```
aws ssm update-maintenance-window-task ^
--window-id "mw-0c50858d01EXAMPLE" ^
--window-task-id "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE" ^
--targets "Key=InstanceIds,Values=i-02573cafcfEXAMPLE" ^
--task-invocation-parameters "RunCommand={Comment=A comment for my task update,Parameters={UpdateLevel='{{ssm:UpdateLevel}}'}}"
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTaskId": "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"Targets": [
{
"Key": "InstanceIds",
"Values": [
"i-02573cafcfEXAMPLE"
]
}
],
"TaskArn": "AWS-RunShellScript",
"ServiceRoleArn": "arn:aws:iam::111122223333:role/MyMaintenanceWindowServiceRole",
"TaskParameters": {},
"TaskInvocationParameters": {
"RunCommand": {
"Comment": "A comment for my task update",
"Parameters": {
"UpdateLevel": [
"{{ssm:UpdateLevel}}"
]
}
}
},
"Priority": 10,
"MaxConcurrency": "1",
"MaxErrors": "1"
}
```
1. Führen Sie den folgenden Befehl aus, um eine Automatisierungsaufgabe so zu aktualisieren, dass `WINDOW_ID`-Parameter und `WINDOW_TASK_ID`-Parameter als `task-invocation-parameters`-Parameter angegeben werden:
------
#### [ Linux & macOS ]
```
aws ssm update-maintenance-window-task \
--window-id "mw-0c50858d01EXAMPLE" \
--window-task-id "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE" \
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE \
--task-arn "AutoTestDoc" \
--service-role-arn "arn:aws:iam:account-id:role/MyMaintenanceWindowServiceRole \
--task-invocation-parameters "Automation={Parameters={InstanceId='{{RESOURCE_ID}}',initiator='{{WINDOW_ID}}.Task-{{WINDOW_TASK_ID}}'}}" \
--priority 3 --max-concurrency 10 --max-errors 5
```
------
#### [ Windows ]
```
aws ssm update-maintenance-window-task ^
--window-id "mw-0c50858d01EXAMPLE" ^
--window-task-id "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE" ^
--targets "Key=WindowTargetIds,Values=e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE ^
--task-arn "AutoTestDoc" ^
--service-role-arn "arn:aws:iam:account-id:role/MyMaintenanceWindowServiceRole ^
--task-invocation-parameters "Automation={Parameters={InstanceId='{{RESOURCE_ID}}',initiator='{{WINDOW_ID}}.Task-{{WINDOW_TASK_ID}}'}}" ^
--priority 3 --max-concurrency 10 --max-errors 5
```
------
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"WindowId": "mw-0c50858d01EXAMPLE",
"WindowTaskId": "4f7ca192-7e9a-40fe-9192-5cb15EXAMPLE",
"Targets": [
{
"Key": "WindowTargetIds",
"Values": [
"e32eecb2-646c-4f4b-8ed1-205fbEXAMPLE"
]
}
],
"TaskArn": "AutoTestDoc",
"ServiceRoleArn": "arn:aws:iam::111122223333:role/MyMaintenanceWindowServiceRole",
"TaskParameters": {},
"TaskInvocationParameters": {
"Automation": {
"Parameters": {
"multi": [
"{{WINDOW_TASK_ID}}"
],
"single": [
"{{WINDOW_ID}}"
]
}
}
},
"Priority": 0,
"MaxConcurrency": "10",
"MaxErrors": "5",
"Name": "My-Automation-Task",
"Description": "A description for my Automation task"
}
```
# Tutorial: Löschen Sie ein Wartungsfenster mit dem AWS CLI
Um ein in diesen Tutorials erstelltes Wartungsfenster zu löschen, führen Sie den folgenden Befehl aus.
```
aws ssm delete-maintenance-window --window-id "mw-0c50858d01EXAMPLE"
```
Die vom System zurückgegebenen Informationen ähneln den Folgenden.
```
{
"WindowId":"mw-0c50858d01EXAMPLE"
}
```
# Tutorial: Erstellen Sie ein Wartungsfenster zum Patchen über die Konsole
**Wichtig**
Sie können dieses ältere Thema weiterhin zum Erstellen eines Wartungsfensters zum Patchen verwenden. Wir empfehlen jedoch, stattdessen eine Patch-Richtlinie zu verwenden. Weitere Informationen erhalten Sie unter [Patch-Richtlinienkonfigurationen in Quick Setup](patch-manager-policies.md) und [Das Patchen für Instances in einer Organisation mithilfe einer Patch-Richtlinie für Quick Setup konfigurieren](quick-setup-patch-manager.md).
Um die Auswirkungen auf die Verfügbarkeit Ihres Servers zu minimieren, empfehlen wir, ein Wartungsfenster zu konfigurieren, um die Patches dann einzuspielen, wenn der Geschäftsbetrieb dadurch nicht unterbrochen wird.
Sie müssen Rollen und Berechtigungen für Maintenance Windows ein Tool in konfigurieren AWS Systems Manager, bevor Sie mit diesem Verfahren beginnen. Weitere Informationen finden Sie unter [Einrichten von Maintenance Windows](setting-up-maintenance-windows.md).
**So erstellen Sie ein Wartungsfenster für das Einspielen von Patches**
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 **Maintenance Windows** aus.
1. Wählen Sie **Create maintenance window (Wartungsfenster erstellen)** aus.
1. Geben Sie im Feld **Name** einen Namen ein, aus dem hervorgeht, dass das Wartungsfenster für das Einspielen von kritischen und wichtigen Updates verwendet wird.
1. (Optional) Geben Sie unter **Description (Beschreibung)** eine Beschreibung ein.
1. Wählen Sie **Allow unregistered targets** (Nicht registrierte Ziele erlauben), wenn Sie erlauben möchten, dass eine Wartungsfensteraufgabe auf verwalteten Knoten ausgeführt wird, obwohl diese Knoten nicht als Ziele registriert wurden.
Falls Sie diese Option wählen, können Sie die nicht registrierten Knoten (nach Knoten-ID) auswählen, wenn Sie eine Aufgabe für das Wartungsfenster registrieren.
Sollten Sie diese Option nicht wählen, müssen Sie die zuvor registrierten Ziele auswählen, wenn Sie eine Aufgabe für das Wartungsfenster registrieren.
1. Geben Sie oben im Abschnitt **Schedule (Zeitplan)** einen Zeitplan für das Wartungsfenster an, indem Sie eine der drei Planungsoptionen verwenden.
Hinweise zum Erstellen von cron/rate Ausdrücken finden Sie unter[Referenz: Cron- und Rate-Ausdrücke für System Manager](reference-cron-and-rate-expressions.md).
1. Geben Sie unter **Duration (Dauer)** die Anzahl der Stunden ein, die das Wartungsfenster ausgeführt wird. Der Wert, den Sie angeben, bestimmt die spezifische Endzeit für das Wartungsfenster basierend auf dem Zeitpunkt, an dem es beginnt. Nach der resultierenden Endzeit dürfen keine Wartungsfenster-Aufgaben gestartet werden, abzüglich der Anzahl der Stunden, die Sie für **Stop initiating tasks (Initiieren von Aufgaben beenden)** im nächsten Schritt angeben.
Beispiel: Wenn das Wartungsfenster um 15:00 Uhr beginnt, die Dauer drei Stunden beträgt und der Wert **Stop initiating tasks (Initiieren von Aufgaben beenden)** eine Stunde beträgt, können nach 17:00 Uhr keine Wartungsfenster-Aufgaben gestartet werden.
1. Geben Sie unter **Stop initiating tasks (Initiieren von Aufgaben beenden)** die Anzahl der Stunden für den Zeitpunkt vor dem Ende des Wartungsfensters an, ab dem vom System keine neuen auszuführenden Aufgaben mehr geplant werden sollen.
1. (Optional) Geben Sie unter **Window start date** (Startzeit des Fensters) ein Datum und eine Uhrzeit im erweiterten ISO-8601-Format an, zu dem bzw. der das Wartungsfenster aktiviert werden soll. Auf diese Weise können Sie die Aktivierung des Wartungsfensters bis zum angegebenen künftigen Zeitpunkt verzögern.
1. (Optional) Geben Sie unter **Window end date** (Enddatum des Fensters) ein Datum und eine Uhrzeit im erweiterten ISO-8601-Format an, zu dem bzw. der das Wartungsfenster deaktiviert werden soll. Auf diese Weise können Sie ein in der Zukunft liegendes Datum sowie eine Uhrzeit festlegen, nach dem das Wartungsfenster nicht mehr ausgeführt wird.
1. (Optional) Geben Sie unter **Zeitzone planen** die Zeitzone im IANA-Format (Internet Assigned Numbers Authority) an, auf der die Ausführung geplanter Wartungsfenster basieren soll. Zum Beispiel: "America/Los\$1Angeles", "etc/UTC", or "Asia/Seoul“.
Weitere Informationen zu gültigen Formaten finden Sie unter [Time Zone Database (Zeitzonendatenbank)](https://www.iana.org/time-zones) auf der IANA-Website.
1. (Optional) Wenden **Sie im Bereich „Tags verwalten**“ ein oder mehrere name/value Tag-Schlüsselpaare auf das Wartungsfenster an.
Tags sind optionale Metadaten, die Sie einer Ressource zuweisen. Mithilfe von Tags können Sie eine Ressource unterschiedlich kategorisieren, beispielsweise nach Zweck, Besitzer oder Umgebung. Sie können beispielsweise dieses Wartungsfenster mit Tags versehen, um die Aufgabentypen, die darin ausgeführt werden, zu identifizieren. In diesem Fall könnten Sie das folgende name/value Schlüsselpaar angeben:
+ `Key=TaskType,Value=Patching`
1. Wählen Sie **Create maintenance window (Wartungsfenster erstellen)** aus.
1. Wählen Sie in der Liste mit den Wartungsfenstern das gerade erstellte Wartungsfenster aus und klicken Sie anschließend auf **Actions (Aktionen)**, **Register targets (Ziele registrieren)**.
1. (Optional) Geben Sie im Abschnitt **Maintenance window target details** einen Namen, eine Beschreibung und Eigentümerinformationen (Ihren Namen oder Alias) für dieses Ziel an.
1. Wählen Sie für die **Zielauswahl** die Option **Instance-Tags festlegen** aus.
1. Geben Sie im Feld **Instance-Tags angeben** einen Tag-Schlüssel und einen Tag-Wert ein, um die Knoten zu identifizieren, die beim Wartungsfenster angemeldet werden sollen, und wählen Sie dann **Hinzufügen**.
1. Wählen Sie **Register target**. Das System erstellt ein Ziel für das Wartungsfenster.
1. Wählen Sie auf der Detailseite des von Ihnen erstellten Wartungsfensters **Actions (Aktionen)**, **Register Run command task (Ausführungsbefehlaufgabe registrieren)** aus.
1. (Optional) Geben Sie im Abschnitt **Maintenance window task details (Aufgabendetails für Wartungszeitraum)** einen Namen und eine Beschreibung für diese Aufgabe an.
1. Wählen Sie unter **Command document (Befehlsdokument)** die Option `AWS-RunPatchBaseline` aus.
1. Wählen Sie für **Task priority (Aufgabenpriorität)** eine Priorität aus. Null (`0`) ist die höchste Priorität.
1. Wählen Sie für **Targets (Ziele)** unter **Target by (Auswahl nach)** das Wartungsfensterziel aus, das Sie zuvor erstellt haben.
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 angegeben haben, die auf verwaltete Knoten angewendet wurden, oder indem Sie 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 für **IAM-Servicerolle** eine Rolle aus, um Systems Manager Berechtigungen zur Übernahme zum Ausführen von Wartungsfenster-Aufgaben zu erteilen.
Wenn Sie keinen ARN für die Servicerolle angeben, verwendet Systems Manager eine serviceverknüpfte Rolle in Ihrem Konto. Wenn in Ihrem Konto keine geeignete serviceverknüpfte Rolle für Systems Manager vorhanden ist, wird sie erstellt, wenn die Aufgabe erfolgreich registriert wurde.
**Anmerkung**
Um die Sicherheitslage zu verbessern, empfehlen wir dringend, eine benutzerdefinierte Richtlinie und eine benutzerdefinierte Servicerolle für die Ausführung Ihrer Aufgaben im Wartungsfenster zu erstellen. Die Richtlinie kann so gestaltet werden, dass sie nur die Berechtigungen gewährt, die für Ihre speziellen Wartungsfensteraufgaben erforderlich sind. Weitere Informationen finden Sie unter [Einrichten von Maintenance Windows](setting-up-maintenance-windows.md).
1. (Optional) Wenn Sie im Abschnitt **Ausgabeoptionen** die Befehlsausgabe in einer Datei speichern möchten, aktivieren Sie das Kontrollkästchen **Schreiben der Ausgabe in S3 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 die Berechtigungen des dem verwalteten Knoten zugewiesenen Instance-Profils 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.
Um die Ausgabe in eine Amazon CloudWatch Logs-Protokollgruppe zu streamen, wählen Sie das **CloudWatch Ausgabefeld** aus. Geben Sie den Namen der Protokollgruppe in das Feld ein.
1. Aktivieren Sie das Kontrollkästchen **Enable SNS notifications (SNS-Benachrichtigungen aktivieren)** im Abschnitt **SNS notifications (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. Für **Parameters (Parameter)**:
+ Wählen Sie in der Liste **Operation (Vorgang)** die Option **Scan (Scannen)**, um nach fehlenden Patches zu suchen, oder wählen Sie **Install (Installieren)**, um nach fehlenden Patches zu suchen und diese direkt zu installieren.
+ Sie brauchen keine Angaben für das Feld **Snapshot Id (Snapshot-ID)** zu machen. Das System generiert diesen Parameter automatisch und stellt ihn bereit.
+ Sie müssen nichts in das Feld **Install Override List (Überschreibungsliste installieren)** eingeben, es sei denn, Sie möchten, dass Patch Manager einen anderen Patch als für die Patch-Baseline angegeben verwenden soll. Weitere Informationen finden Sie unter [Parametername: `InstallOverrideList`](patch-manager-aws-runpatchbaseline.md#patch-manager-aws-runpatchbaseline-parameters-installoverridelist).
+ Geben Sie für an **RebootOption**, ob Knoten neu gestartet werden sollen, wenn während des `Install` Vorgangs Patches installiert werden, oder ob andere Patches Patch Manager erkannt werden, die seit dem letzten Knotenneustart installiert wurden. Weitere Informationen finden Sie unter [Parametername: `RebootOption`](patch-manager-aws-runpatchbaseline.md#patch-manager-aws-runpatchbaseline-parameters-norebootoption).
+ (Optional) Geben Sie im Feld **Comment (Kommentar)** eine Verfolgungsnotiz oder Erinnerung zu diesem Befehl ein.
+ Geben Sie im Feld **Timeout (seconds) (Timeout (Sekunden))** die Anzahl der Sekunden ein, die das System warten soll, bis der Vorgang beendet ist, bevor er als nicht erfolgreich eingestuft wird.
1. Wählen Sie **Register Run command task**.
Nachdem die Wartungsfensteraufgabe abgeschlossen ist, können Sie Details zur Patch-Compliance in der Systems-Manager-Konsole im Tool [Fleet Manager](fleet-manager.md) anzeigen.
Sie können Konformitätsinformationen auch im Tool [Patch Manager](patch-manager.md) auf der Registerkarte **Konformitätsberichte** einsehen.
Sie können auch das [DescribePatchGroupState](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_DescribePatchGroupState.html)und verwenden [DescribeInstancePatchStatesForPatchGroup](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_DescribeInstancePatchStatesForPatchGroup.html) APIs , um Konformitätsdetails einzusehen. Weitere Informationen zu Patch-Compliance-Daten finden Sie unter [Info zu Patch Compliance](compliance-about.md#compliance-monitor-patch).
# Patching von Zeitplänen mithilfe von Wartungsfenstern
Nach der Konfiguration einer Patch-Baseline (und optional einer Patch-Gruppe), können Sie Patches für Ihren Knoten mithilfe eines Wartungsfensters einspielen. Ein Wartungsfenster kann die Auswirkungen bei der Serververfügbarkeit verringern, da Sie die Möglichkeit haben, eine Uhrzeit für das Einspielen der Patches festzulegen, sodass der Geschäftsbetrieb nicht unterbrochen werden muss. Wartungsfenster funktionieren wie folgt:
1. Sie erstellen ein Wartungsfenster mit einem Zeitplan für Ihre Patching-Operationen.
1. Sie wählen die Ziele für das Wartungsfenster aus, indem Sie das Tag `Patch Group` oder `PatchGroup` für den Tag-Namen angeben und einen beliebigen Wert angeben, für den Sie Amazon Elastic Compute Cloud (Amazon EC2)-Tags definiert haben, z. B. „Produktionsserver“ oder „US-EAST-PROD“. (Sie müssen `PatchGroup` ohne Leerzeichen verwenden, wenn Sie[ Tags in EC2-Instance-Metadaten zugelassen haben](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#allow-access-to-tags-in-IMDS).
1. Sie erstellen eine neue Aufgabe für das Wartungsfenster und geben für diese Aufgabe das Dokument `AWS-RunPatchBaseline` an.
Wenn Sie die Aufgabe konfigurieren, können Sie entweder Knoten scannen oder Patches scannen und auf den Knoten installieren. Wenn Sie die Knoten scannen, scannt Patch Manager, ein Tool in AWS Systems Manager, jeden Knoten und generiert eine Liste der fehlenden Patches für Sie zur Überprüfung.
Wenn Sie Patches scannen und installieren, scannt Patch Manager jeden Knoten und vergleicht die Liste der installierten Patches mit der Liste der genehmigten Patches in der Baseline. Patch Manager identifiziert fehlende Patches und lädt dann alle fehlenden und genehmigten Patches herunter und installiert sie.
Wenn Sie einen einmaligen Scan oder eine einmalige Installation ausführen möchten, um ein Problem zu beheben, können Sie Run Command für den direkten Aufruf des Dokuments `AWS-RunPatchBaseline` verwenden.
**Wichtig**
Nach dem Installieren von Patches führt Systems Manager einen Neustart eines jeden Knotens durch. Der Neustart ist erforderlich, um sicherzustellen, dass die Patches ordnungsgemäß installiert sind, und um sicherzustellen, dass das System den Knoten nach dem Einspielen der Patches nicht in einem potenziell fehlerhaften Zustand zurücklässt. (Ausnahme: Wenn der `RebootOption`-Parameter im `NoReboot`-Dokument auf `AWS-RunPatchBaseline` gesetzt ist, wird der verwaltete Knoten nach der Ausführung von Patch Manager nicht neu gestartet. Weitere Informationen finden Sie unter [Parametername: `RebootOption`](patch-manager-aws-runpatchbaseline.md#patch-manager-aws-runpatchbaseline-parameters-norebootoption).)