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.

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.

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:

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 erstellenVariable: "{{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": "{{ describeInstance.Platform }}" 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. Es verwendet die aws:runCommand Aktion, um eine Anwendung auf einem zu installieren Windows Server sein. 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), um eine AWS Lambda Funktion auszuführen, um eine Aktion auszuführen, 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.

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
...

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 VerifyDependenciesInstallMsiPackageSchritt 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
...