• 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.
# Verwendung bedingter Anweisungen in Runbooks
Standardmäßig werden die Schritte, die Sie im Abschnitt `mainSteps` eines Runbooks definieren, nacheinander ausgeführt. Wenn eine Aktion abgeschlossen ist, beginnt die nächste im Abschnitt `mainSteps` angegebene Aktion. Wenn eine Aktion nicht erfolgreich ausgeführt wird, schlägt (standardmäßig) die gesamte Automatisierung fehl. Sie können die Automation-Aktion `aws:branch` und die in diesem Abschnitt beschriebenen Optionen für das Runbook zum Erstellen von Automatisierungen verwenden, die *bedingte Verzweigungen* durchführen. Dies bedeutet, dass Sie Automatisierungen erstellen können, die zu einem anderen Schritt springen, nachdem verschiedene Optionen bewertet wurden oder dynamisch auf Änderungen beim Abschluss eines Schrittes reagieren. Hier finden Sie eine Liste der Optionen, die Sie verwenden können, um dynamische Automatisierungen zu erstellen.
+ **`aws:branch`**: Diese Automatisierungsaktion erlaubt das Erstellen einer dynamischen Automatisierung, die mehrere Auswahlmöglichkeiten in einem einzigen Schritt evaluiert und dann auf der Grundlage dieser Evaluierung zu einem anderen Schritt in dem Runbook springt.
+ **`nextStep`**: Diese Option gibt an, welcher Schritt in einer Automatisierung nach dem erfolgreichem Abschluss eines Schritts als nächster auszuführen ist.
+ **`isEnd`**: Diese Option stoppt eine Automatisierung am Ende eines bestimmten Schrittes. Der Standardwert für diese Option ist "false".
+ **`isCritical`**: Diese Option bezeichnet einen Schritt als kritisch für den erfolgreichen Abschluss der Automatisierung. Wenn ein Schritt mit dieser Bezeichnung fehlschlägt, meldet Automation den Endstatus der Automatisierung als `Failed`. Der Standardwert für diese Option ist `true`.
+ **`onFailure`**: Diese Option gibt an, ob die Automatisierung bei einem Fehler abgebrochen, fortgesetzt oder bis zu einem bestimmten Schritt übersprungen werden soll. Der Standardwert für diese Option ist "abort".
Der folgende Abschnitt beschreibt die Automation-Aktion `aws:branch`. Weitere Informationen über die Optionen `nextStep`, `isEnd`, `isCritical` und `onFailure` finden Sie unter [Beispiel `aws:branch`-Runbooks](#branch-runbook-examples).
## Arbeiten mit der `aws:branch`-Aktion
Die Aktion `aws:branch` bietet die dynamischsten Optionen für bedingte Verzweigungen für Automatisierungen. Wie bereits erwähnt, erlaubt diese Aktion, dass Ihre Automatisierung mehrere Bedingungen in einem einzigen Schritt evaluiert und dann auf der Grundlage der Ergebnisse dieser Bewertung zu einem neuen Schritt springt. Die Aktion `aws:branch` funktioniert wie eine `IF-ELIF-ELSE`-Anweisung beim Programmieren.
Hier ist ein YAML-Beispiel für einen `aws:branch`-Schritt:
```
- name: ChooseOSforCommands
action: aws:branch
inputs:
Choices:
- NextStep: runPowerShellCommand
Variable: "{{GetInstance.platform}}"
StringEquals: Windows
- NextStep: runShellCommand
Variable: "{{GetInstance.platform}}"
StringEquals: Linux
Default:
PostProcessing
```
Wenn Sie die Aktion `aws:branch` für einen Schritt angeben, geben Sie die `Choices` an, die die Automatisierung evaluieren muss. Die Automatisierung kann `Choices` auf der Grundlage des Parameters evaluieren, den Sie im Abschnitt `Parameters` des Runbooks angegeben haben. Die Automatisierung kann `Choices` auch auf der Grundlage der Ausgabe eines vorherigen Schritts evaluieren.
Die Automatisierung evaluiert jede Auswahl mithilfe eines booleschen Ausdrucks. Wenn die Evaluierung zu dem Schluss kommt, dass die erste Auswahl `true` ist, springt die Automatisierung zum nächsten Schritt für diese Auswahl. Wenn die Auswertung zu dem Schluss kommt, dass die erste Auswahl `false` ist, evaluiert die Automatisierung die nächste Auswahl. Wenn Ihr Schritt drei oder mehr `Choices` beinhaltet, evaluiert die Automatisierung die Auswahlen nacheinander, bis eine Auswahl als `true` evaluiert wird. Die Automatisierung springt dann zu dem für die als `true` evaluierte Auswahl angegebenen Schritt.
Wenn keine `Choices` als `true` evaluiert werden, prüft die Automatisierung, ob der Schritt einen `Default`-Wert enthält. Ein `Default`-Wert definiert einen Schritt, zu dem die Automatisierung springen soll, wenn keine der Auswahlmöglichkeiten als `true` evaluiert wird. Wenn kein `Default`-Wert für den Schritt definiert ist, verarbeitet die Automatisierung den nächsten Schritt in dem Runbook.
Hier ist ein `aws:branch` Schritt in YAML mit dem Namen **Choose OSfrom Parameter**. Der Schritt beinhaltet zwei `Choices`: (`NextStep: runWindowsCommand`) und (`NextStep: runLinuxCommand`). Die Automatisierung evaluiert diese `Choices`, um zu bestimmen, welcher Befehl für das entsprechende Betriebssystem ausgeführt werden soll. Die `Variable` für jede Auswahl verwendet `{{OSName}}`. Dabei handelt es sich um einen Parameter, den der Autor des Runbooks im Abschnitt `Parameters` des Runbooks festgelegt hat.
```
mainSteps:
- name: chooseOSfromParameter
action: aws:branch
inputs:
Choices:
- NextStep: runWindowsCommand
Variable: "{{OSName}}"
StringEquals: Windows
- NextStep: runLinuxCommand
Variable: "{{OSName}}"
StringEquals: Linux
```
Hier ist ein `aws:branch` Schritt in YAML mit dem Namen **OSfromChoose** Output. Der Schritt beinhaltet zwei `Choices`: (`NextStep: runPowerShellCommand`) und (`NextStep: runShellCommand`). Die Automatisierung evaluiert diese `Choices`, um zu bestimmen, welcher Befehl für das entsprechende Betriebssystem ausgeführt werden soll. Die `Variable` für jede Auswahl verwendet `{{GetInstance.platform}}`. Dies ist die Ausgabe aus einem früheren Schritt in dem Runbook. Dieses Beispiel enthält auch eine Option mit dem Namen `Default`. Wenn die Automatisierung beide `Choices` evaluiert und keine davon `true` ist, springt die Automatisierung zu einem Schritt mit dem Namen `PostProcessing`.
```
mainSteps:
- name: chooseOSfromOutput
action: aws:branch
inputs:
Choices:
- NextStep: runPowerShellCommand
Variable: "{{GetInstance.platform}}"
StringEquals: Windows
- NextStep: runShellCommand
Variable: "{{GetInstance.platform}}"
StringEquals: Linux
Default:
PostProcessing
```
### Erstellen eines `aws:branch`-Schritts in einem Runbook
Wenn Sie einen `aws:branch`-Schritt in einem Runbook erstellen, definieren Sie die `Choices`, die die Automatisierung evaluieren soll, um festzustellen, zu welchem Schritt die Automatisierung dann springen soll. Wie bereits erwähnt, werden `Choices` mit einem booleschen Ausdruck evaluiert. Jede Auswahl muss die folgenden Optionen definieren:
+ **NextStep**: Der nächste Schritt im Runbook, der verarbeitet werden muss, falls die angegebene Option ist. `true`
+ **Variable**: Geben Sie entweder den Namen eines Parameters an, der im Abschnitt `Parameters` des Runbooks definiert ist, einer Variable, die im Abschnitt `Variables` definiert ist, oder geben Sie ein Ausgabeobjekt aus einem vorherigen Schritt in dem Runbook an.
Geben Sie Variablenwerte mithilfe des folgenden Formulars an.
`Variable: "{{variable name}}"`
Geben Sie Parameterwerte mithilfe ders folgenden Formulars an.
`Variable: "{{parameter name}}"`
Geben Sie Ausgabeobjektvariablen in der folgenden Form an.
`Variable: "{{previousStepName.outputName}}"`
**Anmerkung**
Das Erstellen der Ausgabevariable wird im nächsten Abschnitt ausführlicher beschrieben: [Informationen zum Erstellen der Ausgabevariable](#branch-action-output).
+ **Operation**: Die Kriterien für die Evaluierung der Auswahl, etwa `StringEquals: Linux`. Die Aktion `aws:branch` unterstützt die folgenden Operationen:
**Zeichenfolgenoperationen**
+ StringEquals
+ EqualsIgnoreCase
+ StartsWith
+ EndsWith
+ Enthält
**Numerische Operationen**
+ NumericEquals
+ NumericGreater
+ NumericLesser
+ NumericGreaterOrEquals
+ NumericLesser
+ NumericLesserOrEquals
**Boolesche Operation**
+ BooleanEquals
**Wichtig**
Wenn Sie ein Runbook erstellen, validiert das System alle Operationen im Runbook. Wenn eine Operation nicht unterstützt wird, gibt das System einen Fehler aus, wenn Sie versuchen, das Runbook zu erstellen.
+ **Default**: Geben Sie einen Rückfallschritt an, zu dem die Automatisierung springen soll, wenn keine der `Choices` `true` ist.
**Anmerkung**
Wenn Sie keinen `Default`-Wert angeben möchten, können Sie die `isEnd`-Option angeben. Wenn keine der `Choices` `true` ist und kein `Default`-Wert angegeben ist, wird die Automatisierung am Ende des Schrittes angehalten.
Verwenden Sie die folgenden Vorlagen für die Konstruktion des Schrittes `aws:branch` in Ihrem Runbook. Ersetzen Sie jeden *example resource placeholder* durch Ihre Informationen.
------
#### [ YAML ]
```
mainSteps:
- name: step name
action: aws:branch
inputs:
Choices:
- NextStep: step to jump to if evaluation for this choice is true
Variable: "{{parameter name or output from previous step}}"
Operation type: Operation value
- NextStep: step to jump to if evaluation for this choice is true
Variable: "{{parameter name or output from previous step}}"
Operation type: Operation value
Default:
step to jump to if all choices are false
```
------
#### [ JSON ]
```
{
"mainSteps":[
{
"name":"a name for the step",
"action":"aws:branch",
"inputs":{
"Choices":[
{
"NextStep":"step to jump to if evaluation for this choice is true",
"Variable":"{{parameter name or output from previous step}}",
"Operation type":"Operation value"
},
{
"NextStep":"step to jump to if evaluation for this choice is true",
"Variable":"{{parameter name or output from previous step}}",
"Operation type":"Operation value"
}
],
"Default":"step to jump to if all choices are false"
}
}
]
}
```
------
#### Informationen zum Erstellen der Ausgabevariable
Um eine `aws:branch`-Auswahl zu erstellen, die auf die Ausgabe eines vorherigen Schrittes verweist, müssen Sie den Namen des vorherigen Schrittes und den des Ausgabefeldes angeben. Anschließend kombinieren Sie die Namen des Schrittes und des Feldes im folgenden Format.
`Variable: "{{previousStepName.outputName}}"`
Beispielsweise hat der erste Schritt im folgenden Beispiel den Namen `GetInstance`. Dann gibt es unter `outputs` ein Feld mit dem Namen `platform`. Im zweiten Schritt (`ChooseOSforCommands`) möchte der Autor auf die Ausgabe des Plattform-Feldes als Variable verweisen. Um die Variable zu erstellen, kombinieren Sie einfach den Schrittnamen (GetInstance) und den Namen des Ausgabefeldes (Plattform), um sie zu erstellen`Variable: "{{GetInstance.platform}}"`.
```
mainSteps:
- Name: GetInstance
action: aws:executeAwsApi
inputs:
Service: ssm
Api: DescribeInstanceInformation
Filters:
- Key: InstanceIds
Values: ["{{ InstanceId }}"]
outputs:
- Name: myInstance
Selector: "$.InstanceInformationList[0].InstanceId"
Type: String
- Name: platform
Selector: "$.InstanceInformationList[0].PlatformType"
Type: String
- name: ChooseOSforCommands
action: aws:branch
inputs:
Choices:
- NextStep: runPowerShellCommand
Variable: "{{GetInstance.platform}}"
StringEquals: Windows
- NextStep: runShellCommand
Variable: "{{GetInstance.platform}}"
StringEquals: Linux
Default:
Sleep
```
Hier ist ein Beispiel, das zeigt, wie *"Variable": "\$1\$1 describeInstance.Platform \$1\$1"* es aus dem vorherigen Schritt und der Ausgabe erstellt wird.
```
- name: describeInstance
action: aws:executeAwsApi
onFailure: Abort
inputs:
Service: ec2
Api: DescribeInstances
InstanceIds:
- "{{ InstanceId }}"
outputs:
- Name: Platform
Selector: "$.Reservations[0].Instances[0].Platform"
Type: String
nextStep: branchOnInstancePlatform
- name: branchOnInstancePlatform
action: aws:branch
inputs:
Choices:
- NextStep: runEC2RescueForWindows
Variable: "{{ describeInstance.Platform }}"
StringEquals: windows
Default: runEC2RescueForLinux
```
### Beispiel `aws:branch`-Runbooks
Hier sind einige Beispiele für Runbooks, die `aws:branch` verwenden.
**Beispiel 1: Verwendung von `aws:branch` mit einer Ausgabevariablen zur Ausführung von Befehlen auf der Grundlage des Betriebssystemtyps**
Im ersten Schritt dieses Beispiels (`GetInstance`) verwendet der Runbook-Autor die `aws:executeAwsApi`-Aktion zum Aufrufen der `ssm` `DescribeInstanceInformation`-API-Operation. Der Autor verwendet diese Aktion, um den Typ des von einer Instance zu verwendenden Betriebssystems zu bestimmen. Die Aktion `aws:executeAwsApi` gibt die Instance-ID und den Plattformtyp aus.
Im zweiten Schritt (`ChooseOSforCommands`) verwendet der Autor die Aktion `aws:branch` mit zwei `Choices` (`NextStep: runPowerShellCommand`) und (`NextStep: runShellCommand`). Die Automatisierung evaluiert das Betriebssystem der Instance anhand der Ausgabe des vorherigen Schritts (`Variable: "{{GetInstance.platform}}"`). Die Automatisierung springt zu einem Schritt für das angegebene Betriebssystem.
```
---
schemaVersion: '0.3'
assumeRole: "{{AutomationAssumeRole}}"
parameters:
AutomationAssumeRole:
default: ""
type: String
mainSteps:
- name: GetInstance
action: aws:executeAwsApi
inputs:
Service: ssm
Api: DescribeInstanceInformation
outputs:
- Name: myInstance
Selector: "$.InstanceInformationList[0].InstanceId"
Type: String
- Name: platform
Selector: "$.InstanceInformationList[0].PlatformType"
Type: String
- name: ChooseOSforCommands
action: aws:branch
inputs:
Choices:
- NextStep: runPowerShellCommand
Variable: "{{GetInstance.platform}}"
StringEquals: Windows
- NextStep: runShellCommand
Variable: "{{GetInstance.platform}}"
StringEquals: Linux
Default:
Sleep
- name: runShellCommand
action: aws:runCommand
inputs:
DocumentName: AWS-RunShellScript
InstanceIds:
- "{{GetInstance.myInstance}}"
Parameters:
commands:
- ls
isEnd: true
- name: runPowerShellCommand
action: aws:runCommand
inputs:
DocumentName: AWS-RunPowerShellScript
InstanceIds:
- "{{GetInstance.myInstance}}"
Parameters:
commands:
- ls
isEnd: true
- name: Sleep
action: aws:sleep
inputs:
Duration: PT3S
```
**Beispiel 2: Verwendung von `aws:branch` mit einer Parametervariablen zur Ausführung von Befehlen auf der Grundlage des Betriebssystemtyps**
Der Autor des Runbooks definiert verschiedene Parameteroptionen am Anfang des Runbooks im Abschnitt `parameters`. Ein Parameter hat den Namen `OperatingSystemName`. Im ersten Schritt (`ChooseOS`) verwendet der Autor die Aktion `aws:branch` mit zwei `Choices` (`NextStep: runWindowsCommand`) und (`NextStep: runLinuxCommand`). Die Variable für diese `Choices` verweist auf die im Parameter-Abschnitt angegebene Parameteroption (`Variable: "{{OperatingSystemName}}"`). Wenn der Benutzer dieses Runbook ausführt, gibt er zur Laufzeit einen Wert für `OperatingSystemName` an. Die Automatisierung verwendet den Laufzeitparameter während der Evaluierung der `Choices`. Die Automatisierung springt zu einem Schritt für das angegebene Betriebssystem auf der Grundlage des für `OperatingSystemName` angegebenen Laufzeitparameters.
```
---
schemaVersion: '0.3'
assumeRole: "{{AutomationAssumeRole}}"
parameters:
AutomationAssumeRole:
default: ""
type: String
OperatingSystemName:
type: String
LinuxInstanceId:
type: String
WindowsInstanceId:
type: String
mainSteps:
- name: ChooseOS
action: aws:branch
inputs:
Choices:
- NextStep: runWindowsCommand
Variable: "{{OperatingSystemName}}"
StringEquals: windows
- NextStep: runLinuxCommand
Variable: "{{OperatingSystemName}}"
StringEquals: linux
Default:
Sleep
- name: runLinuxCommand
action: aws:runCommand
inputs:
DocumentName: "AWS-RunShellScript"
InstanceIds:
- "{{LinuxInstanceId}}"
Parameters:
commands:
- ls
isEnd: true
- name: runWindowsCommand
action: aws:runCommand
inputs:
DocumentName: "AWS-RunPowerShellScript"
InstanceIds:
- "{{WindowsInstanceId}}"
Parameters:
commands:
- date
isEnd: true
- name: Sleep
action: aws:sleep
inputs:
Duration: PT3S
```
### Erstellen komplexer verzweigender Automatisierungen mit Operatoren
Sie können Automatisierungen mit komplexen Verzweigungen erstellen, indem Sie die Operatoren `And`, `Or` und `Not` in Ihren `aws:branch`-Schritten verwenden.
**Der „Und“-Operator**
Verwenden Sie den `And`-Operator, wenn Sie wünschen, dass mehrere Variablen für eine Auswahl `true` sind. Im folgenden Beispiel wird die erste Wahl darauf evaluiert, ob eine Instance `running` ist und das Betriebssystem `Windows` verwendet. Wenn die Evaluierung *beider* dieser Variablen „true“ ergibt, springt die Automatisierung zum Schritt `runPowerShellCommand`. Wenn eine oder mehrere der Variablen `false` ist, evaluiert die Automatisierung die Variablen für die zweite Auswahl.
```
mainSteps:
- name: switch2
action: aws:branch
inputs:
Choices:
- And:
- Variable: "{{GetInstance.pingStatus}}"
StringEquals: running
- Variable: "{{GetInstance.platform}}"
StringEquals: Windows
NextStep: runPowerShellCommand
- And:
- Variable: "{{GetInstance.pingStatus}}"
StringEquals: running
- Variable: "{{GetInstance.platform}}"
StringEquals: Linux
NextStep: runShellCommand
Default:
sleep3
```
**Der „Oder“-Operator**
Verwenden Sie den `Or`-Operator, wenn Sie wünschen, *eine beliebige* von mehreren Variablen für eine Auswahl „true“ ist. Im folgenden Beispiel wird die erste Auswahl darauf evaluiert, ob eine Parameterzeichenfolge `Windows` ist, und ob die Ausgabe eines AWS Lambda -Schrittes „true“ ist. Wenn die Evaluierung feststellt, dass *eine* dieser Variablen „true“ ist, springt die Automatisierung zum Schritt `RunPowerShellCommand`. Wenn beide Variablen „false“ sind, evaluiert die Automatisierung die Variablen für die zweite Auswahl.
```
- Or:
- Variable: "{{parameter1}}"
StringEquals: Windows
- Variable: "{{BooleanParam1}}"
BooleanEquals: true
NextStep: RunPowershellCommand
- Or:
- Variable: "{{parameter2}}"
StringEquals: Linux
- Variable: "{{BooleanParam2}}"
BooleanEquals: true
NextStep: RunShellScript
```
**Der „Nicht“-Operator**
Verwenden Sie den `Not`-Operator, wenn zu einem Schritt gesprungen werden soll, wenn eine Variable *nicht* „true“ ist. Im folgenden Beispiel wird die erste Auswahl danach evaluiert, ob eine Parameterzeichenfolge `Not Linux` ist. Wenn die Evaluierung feststellt, dass die Variable nicht „Linux“ ist, springt die Automatisierung zum Schritt `sleep2`. Wenn die Evaluierung der ersten Auswahl feststellt, dass sie Linux *ist*, evaluiert die Automatisierung die nächste Auswahl.
```
mainSteps:
- name: switch
action: aws:branch
inputs:
Choices:
- NextStep: sleep2
Not:
Variable: "{{testParam}}"
StringEquals: Linux
- NextStep: sleep1
Variable: "{{testParam}}"
StringEquals: Windows
Default:
sleep3
```
## Beispiele für die Verwendung von bedingten Optionen
Dieser Abschnitt enthält verschiedene Beispiele für die Verwendung dynamischer Optionen in einem Runbook. Jedes Beispiel in diesem Abschnitt erweitert das nachfolgende Runbook. Dieses Runbook verfügt über zwei Aktionen. Die erste Aktion hat den Namen `InstallMsiPackage`. Sie verwendet die Aktion `aws:runCommand` zur Installation einer Anwendung auf einer Windows Server-Instance. Die zweite Aktion hat den Namen `TestInstall`. Sie verwendet die Aktion `aws:invokeLambdaFunction` zum Ausführen eines Tests der installierten Anwendung, sofern die Anwendung erfolgreich installiert wurde. Der erste Schritt gibt `onFailure: Abort` an. Dies bedeutet, dass die Ausführung der Automatisierung vor dem zweiten Schritt gestoppt wird, wenn die Anwendung nicht erfolgreich installiert wird.
**Beispiel 1: Runbook mit zwei linearen Aktionen**
```
---
schemaVersion: '0.3'
description: Install MSI package and run validation.
assumeRole: "{{automationAssumeRole}}"
parameters:
automationAssumeRole:
type: String
description: "(Required) Assume role."
packageName:
type: String
description: "(Required) MSI package to be installed."
instanceIds:
type: String
description: "(Required) Comma separated list of instances."
mainSteps:
- name: InstallMsiPackage
action: aws:runCommand
maxAttempts: 2
onFailure: Abort
inputs:
InstanceIds:
- "{{instanceIds}}"
DocumentName: AWS-RunPowerShellScript
Parameters:
commands:
- msiexec /i {{packageName}}
- name: TestInstall
action: aws:invokeLambdaFunction
maxAttempts: 1
timeoutSeconds: 500
inputs:
FunctionName: TestLambdaFunction
...
```
**Erstellen einer dynamischen Automatisierung, die anhand der Option `onFailure` zu verschiedenen Schritten springt**
Im folgenden Beispiel werden die Optionen `onFailure: step:step name`, `nextStep` und `isEnd` zur Erstellung einer dynamischen Automatisierung verwendet. Wenn in diesem Beispiel die `InstallMsiPackage` Aktion fehlschlägt, springt die Automatisierung zu einer Aktion namens *PostFailure*(`onFailure: step:PostFailure`) über, um eine AWS Lambda Funktion auszuführen, die eine Aktion ausführt, falls die Installation fehlschlägt. Wenn die Installation erfolgreich ist, springt die Automatisierung zur TestInstall Aktion () über. `nextStep: TestInstall` Die Schritte `TestInstall` und `PostFailure` verwenden die Option `isEnd` (`isEnd: true`), so dass die Automatisierung abschließt, wenn einer dieser Schritte abgeschlossen ist.
**Anmerkung**
Die Verwendung der Option `isEnd` im letzten Schritt des Abschnitts `mainSteps` ist optional. Wenn der letzte Schritt nicht zu anderen Schritten springt, stoppt die Automatisierung nach der Ausführung der Aktion im letzten Schritt.
**Beispiel 2: Eine dynamische Automatisierung, die zu verschiedenen Schritten springt**
```
mainSteps
- name: InstallMsiPackage
action: aws:runCommand
onFailure: step:PostFailure
maxAttempts: 2
inputs:
InstanceIds:
- "{{instanceIds}}"
DocumentName: AWS-RunPowerShellScript
Parameters:
commands:
- msiexec /i {{packageName}}
nextStep: TestInstall
- name: TestInstall
action: aws:invokeLambdaFunction
maxAttempts: 1
timeoutSeconds: 500
inputs:
FunctionName: TestLambdaFunction
isEnd: true
- name: PostFailure
action: aws:invokeLambdaFunction
maxAttempts: 1
timeoutSeconds: 500
inputs:
FunctionName: PostFailureRecoveryLambdaFunction
isEnd: true
...
```
**Anmerkung**
Vor der Verarbeitung eines Runbooks überprüft das System, dass das Runbook keine Endlosschleife erstellt. Wenn eine Endlosschleife erkannt wird, gibt Automation einen Fehler und einen Kreis-Trace zurück, aus dem hervorgeht, welche Schritte die Schleife erzeugen.
**Erstellen einer dynamischen Automatisierung, die entscheidende Schritte definiert**
Sie können angeben, dass ein Schritt für den Erfolg der Automatisierung entscheidend ist. Wenn ein solcher kritischer Schritt fehlschlägt, meldet Automation den Status der Automatisierung als `Failed`. Dies gilt auch dann, wenn ein oder mehrere Schritte erfolgreich ausgeführt wurden. Im folgenden Beispiel identifiziert der Benutzer den Schritt, falls der *VerifyDependencies*InstallMsiPackage**Schritt fehlschlägt ()`onFailure: step:VerifyDependencies`. Der Benutzer gibt an, dass der Schritt `InstallMsiPackage` nicht kritisch ist (`isCritical: false`). In diesem Beispiel gilt: Wenn die Anwendung nicht installiert werden konnten, verarbeitet Automation den Schritt `VerifyDependencies`, um zu bestimmen, ob eine oder mehrere Abhängigkeiten fehlen, was dazu führte, dass die Anwendung nicht installiert werden konnte.
**Beispiel 3: Definieren von kritischen Schritten für die Automatisierung**
```
---
name: InstallMsiPackage
action: aws:runCommand
onFailure: step:VerifyDependencies
isCritical: false
maxAttempts: 2
inputs:
InstanceIds:
- "{{instanceIds}}"
DocumentName: AWS-RunPowerShellScript
Parameters:
commands:
- msiexec /i {{packageName}}
nextStep: TestPackage
...
```