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

# Systems Manager Automation Aktionen-Referenz
Referenz zu Automation-Aktionen

Diese Referenz beschreibt die Automation-Aktionen, die Sie in einem Runbook angeben können. Automation ist ein Tool in AWS Systems Manager. Diese Aktionen können nicht in anderen Arten von Systems Manager (SSM)-Dokumenten verwendet werden. Weitere Informationen zu Plug-Ins für andere Arten von SSM-Dokumente finden Sie unter [Referenz für Befehlsdokument-Plugins](documents-command-ssm-plugin-reference.md).

Die Systems Manager Automation führt Schritte aus, die in Automation-Runbooks definiert sind. Jeder Schritt ist einer bestimmten Aktion zugeordnet. Die Aktion bestimmt die Eingaben, das Verhalten und die Ausgaben des Schritts. Die Schritte sind im `mainSteps`-Bereich Ihres Runbooks definiert.

Sie müssen die Ausgaben einer Aktivität oder eines Schritts nicht angeben. Die Ausgaben werden im Voraus durch die dem Schritt zugeordnete Aktivität bestimmt. Wenn Sie Schritteingaben in Ihren Runbooks festlegen, können Sie auf mindestens eine Ausgabe aus einem früheren Schritt verweisen. Beispielsweise können Sie die Ausgabe von `aws:runInstances` für eine spätere `aws:runCommand`-Aktion verfügbar machen. Sie können auch auf Ausgaben aus früheren Schritten im Abschnitt `Output` des Runbooks verweisen. 

**Wichtig**  
Wenn Sie einen automatisierten Workflow ausführen, der andere Services mithilfe einer AWS Identity and Access Management -(IAM)-Servicerolle aufruft, muss die Servicerolle mit der Berechtigung zum Aufrufen dieser Services konfiguriert sein. Diese Anforderung gilt für alle AWS Automatisierungs-Runbooks (`AWS-*`Runbooks) wie die`AWS-ConfigureS3BucketLogging`, und `AWS-RestartEC2Instance` Runbooks`AWS-CreateDynamoDBBackup`, um nur einige zu nennen. Diese Anforderung gilt auch für alle benutzerdefinierten Automatisierungs-Runbooks, die Sie erstellen und die andere mithilfe AWS-Services von Aktionen aufrufen, die andere Dienste aufrufen. Wenn Sie unter anderem `aws:executeAwsApi`-, `aws:createStack`- oder `aws:copyImage`-Aktionen verwenden, konfigurieren Sie die Dienstrolle mit der Berechtigung zum Aufrufen solcher Services. Sie können anderen AWS-Services Berechtigungen erteilen, indem Sie der Rolle eine eingebundene IAM-Richtlinie hinzufügen. Weitere Informationen finden Sie unter [(Optional) Fügen Sie eine Inline-Automatisierungsrichtlinie oder eine vom Kunden verwaltete Richtlinie hinzu, um andere aufzurufen AWS-Services](automation-setup-iam.md#add-inline-policy).

**Topics**
+ [

## Von allen Aktionen gemeinsam genutzte Eigenschaften
](#automation-common)
+ [

# `aws:approve` - Unterbrechen einer Automatisierung zur manuellen Genehmigung
](automation-action-approve.md)
+ [

# `aws:assertAwsResourceProperty`— Bestätigt einen AWS Ressourcen- oder Ereignisstatus
](automation-action-assertAwsResourceProperty.md)
+ [

# `aws:branch` - Ausführen bedingter Automatisierungsschritte
](automation-action-branch.md)
+ [

# `aws:changeInstanceState` – Instance-Status ändern oder geltend machen
](automation-action-changestate.md)
+ [

# `aws:copyImage` - Kopieren oder Verschlüsseln eines Amazon Machine Image
](automation-action-copyimage.md)
+ [

# `aws:createImage` - Erstellen eines Amazon Machine Image
](automation-action-create.md)
+ [

# `aws:createStack`— Einen CloudFormation Stapel erstellen
](automation-action-createstack.md)
+ [

# `aws:createTags`— Erstelle Tags für AWS Ressourcen
](automation-action-createtag.md)
+ [

# `aws:deleteImage` - Löschen eines Amazon Machine Image
](automation-action-delete.md)
+ [

# `aws:deleteStack`— Löscht einen CloudFormation Stapel
](automation-action-deletestack.md)
+ [

# `aws:executeAutomation` - Führen Sie eine weitere Automatisierung durch
](automation-action-executeAutomation.md)
+ [

# `aws:executeAwsApi`— AWS API-Operationen aufrufen und ausführen
](automation-action-executeAwsApi.md)
+ [

# `aws:executeScript` - Führen Sie ein Skript aus
](automation-action-executeScript.md)
+ [

# `aws:executeStateMachine`— Führen Sie eine AWS Step Functions Zustandsmaschine aus
](automation-action-executeStateMachine.md)
+ [

# `aws:invokeWebhook` – Automation-Webhook-Integration aufrufen
](invoke-webhook.md)
+ [

# `aws:invokeLambdaFunction`— Ruft eine Funktion auf AWS Lambda
](automation-action-lamb.md)
+ [

# `aws:loop` – Über Schritte in einer Automatisierung iterieren
](automation-action-loop.md)
+ [

# `aws:pause` - Pausieren einer Automatisierung
](automation-action-pause.md)
+ [

# `aws:runCommand` - Führt einen Befehl auf einer verwalteten Instance aus
](automation-action-runcommand.md)
+ [

# `aws:runInstances` - So starten Sie eine Amazon-EC2-Instance
](automation-action-runinstance.md)
+ [

# `aws:sleep` - Verzögerung einer Automatisierung
](automation-action-sleep.md)
+ [

# `aws:updateVariable` – Aktualisiert einen Wert für eine Runbook-Variable
](automation-action-update-variable.md)
+ [

# `aws:waitForAwsResourceProperty`— Warte auf eine AWS Ressourceneigenschaft
](automation-action-waitForAwsResourceProperty.md)
+ [

# Systemvariablen für Automation
](automation-variables.md)

## Von allen Aktionen gemeinsam genutzte Eigenschaften


Allgemeine Eigenschaften sind Parameter oder Optionen, die in allen Aktionen gefunden werden. Einige Optionen definieren das Verhalten für einen Schritt, etwa wie lange auf den Abschluss eines Schritts gewartet werden muss und was zu tun ist, wenn der Schritt fehlschlägt. Die folgenden Eigenschaften sind allen Aktionen gemeinsam.

[description](#descriptProp)  
Informationen, die Sie angeben, um den Zweck eines Runbooks oder eines Schritts zu beschreiben.  
Typ: Zeichenfolge  
Erforderlich: Nein

[name](#nameProp)  
Ein Bezeichner, der für alle Schrittnamen im Runbook eindeutig sein muss.  
Typ: Zeichenfolge  
Zulässiges Muster: [a-zA-Z0-9\$1]\$1\$1  
Erforderlich: Ja

[action](#actProp)  
Der Name der Aktion, die der Schritt ausführt. [`aws:runCommand` - Führt einen Befehl auf einer verwalteten Instance aus](automation-action-runcommand.md) ist ein Beispiel für eine Aktion, die Sie hier angeben können. Dieses Dokument enthält detaillierte Informationen über alle verfügbaren Aktionen.  
Typ: Zeichenfolge  
Erforderlich: Ja

[maxAttempts](#maxProp)  
Die Anzahl der Wiederholungen des Schritt bei einem Fehler. Wenn der Wert größer als 1 ist, wird der Schritt erst als fehlgeschlagen betrachtet, wenn alle Wiederholungsversuche fehlgeschlagen sind. Der Standardwert ist 1.  
Typ: Ganzzahl  
Erforderlich: Nein

[timeoutSeconds](#timeProp)  
Der Wert für das Timeout des Schritts. Wenn das Timeout erreicht ist und der Wert von `maxAttempts` größer als 1 ist, wird der Schritt erst als abgelaufen betrachtet, wenn alle Wiederholungen durchgeführt wurden.  
Typ: Ganzzahl  
Erforderlich: Nein

[onFailure](#failProp)  
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".  
Typ: Zeichenfolge  
Gültige Werte: Abort \$1 Continue \$1 step: *step\$1name*  
Erforderlich: Nein

[onCancel](#canProp)  
Gibt an, zu welchem Schritt die Automatisierung gehen soll, falls ein Benutzer die Automatisierung abbricht. Die Automatisierung führt den Stornierungs-Workflow für maximal zwei Minuten aus.  
Typ: Zeichenfolge  
Gültige Werte: Abort \$1 Schritt: *step\$1name*  
Erforderlich: Nein  
Die `onCancel`-Eigenschaft unterstützt das Verschieben zu den folgenden Aktionen nicht:  
+ `aws:approve`
+ `aws:copyImage`
+ `aws:createImage`
+ `aws:createStack`
+ `aws:createTags`
+ `aws:loop`
+ `aws:pause`
+ `aws:runInstances`
+ `aws:sleep`

[isEnd](#endProp)  
Diese Option stoppt eine Automatisierung am Ende eines bestimmten Schrittes. Die Automatisierung stoppt, egal ob der Schritt erfolgreich oder gar nicht ausgeführt werden konnte. Der Standardwert von "false".  
Typ: Boolesch  
Zulässige Werte: true \$1 false  
Erforderlich: Nein

[nextStep](#nextProp)  
Gibt an, welcher Schritt in einer Automatisierung nach dem erfolgreichem Abschluss eines Schritts als nächster auszuführen ist.  
Typ: Zeichenfolge  
Erforderlich: Nein

[isCritical](#critProp)  
Bezeichnet einen Schritt als kritisch für den erfolgreichen Abschluss der Automation. Wenn ein Schritt mit dieser Bezeichnung fehlschlägt, dann wird der endgültige Status der Automation als fehlgeschlagen gemeldet. Diese Eigenschaft wird nur ausgewertet, wenn Sie diese explizit in Ihrem Schritt definieren. Wenn die `onFailure`-Eigenschaft auf `Continue` in einem Schritt gesetzt ist, lautet der Standardwert „false“. Der Standardwert für diese Option ist sonst „true“.  
Typ: Boolesch  
Zulässige Werte: true \$1 false  
Erforderlich: Nein

[inputs](#inProp)  
Die für die Aktivität spezifischen Eigenschaften.  
Typ: Zuordnung  
Erforderlich: Ja

### Beispiel


```
---
description: "Custom Automation Example"
schemaVersion: '0.3'
assumeRole: "{{ AutomationAssumeRole }}"
parameters:
  AutomationAssumeRole:
    type: String
    description: "(Required) The ARN of the role that allows Automation to perform
      the actions on your behalf. If no role is specified, Systems Manager Automation
      uses your IAM permissions to run this runbook."
    default: ''
  InstanceId:
      type: String
      description: "(Required) The Instance Id whose root EBS volume you want to restore the latest Snapshot."
      default: ''
mainSteps:
- name: getInstanceDetails
  action: aws:executeAwsApi
  onFailure: Abort
  inputs:
    Service: ec2
    Api: DescribeInstances
    InstanceIds:
    - "{{ InstanceId }}"
  outputs:
    - Name: availabilityZone
      Selector: "$.Reservations[0].Instances[0].Placement.AvailabilityZone"
      Type: String
    - Name: rootDeviceName
      Selector: "$.Reservations[0].Instances[0].RootDeviceName"
      Type: String
  nextStep: getRootVolumeId
- name: getRootVolumeId
  action: aws:executeAwsApi
  maxAttempts: 3
  onFailure: Abort
  inputs:
    Service: ec2
    Api: DescribeVolumes
    Filters:
    -  Name: attachment.device
       Values: ["{{ getInstanceDetails.rootDeviceName }}"]
    -  Name: attachment.instance-id
       Values: ["{{ InstanceId }}"]
  outputs:
    - Name: rootVolumeId
      Selector: "$.Volumes[0].VolumeId"
      Type: String
  nextStep: getSnapshotsByStartTime
- name: getSnapshotsByStartTime
  action: aws:executeScript
  timeoutSeconds: 45
  onFailure: Abort
  inputs:
    Runtime: python3.8
    Handler: getSnapshotsByStartTime
    InputPayload:
      rootVolumeId : "{{ getRootVolumeId.rootVolumeId }}"
    Script: |-
      def getSnapshotsByStartTime(events,context):
        import boto3

        #Initialize client
        ec2 = boto3.client('ec2')
        rootVolumeId = events['rootVolumeId']
        snapshotsQuery = ec2.describe_snapshots(
          Filters=[
            {
              "Name": "volume-id",
              "Values": [rootVolumeId]
            }
          ]
        )
        if not snapshotsQuery['Snapshots']:
          noSnapshotFoundString = "NoSnapshotFound"
          return { 'noSnapshotFound' : noSnapshotFoundString }
        else:
          jsonSnapshots = snapshotsQuery['Snapshots']
          sortedSnapshots = sorted(jsonSnapshots, key=lambda k: k['StartTime'], reverse=True)
          latestSortedSnapshotId = sortedSnapshots[0]['SnapshotId']
          return { 'latestSnapshotId' : latestSortedSnapshotId }
  outputs:
  - Name: Payload
    Selector: $.Payload
    Type: StringMap
  - Name: latestSnapshotId
    Selector: $.Payload.latestSnapshotId
    Type: String
  - Name: noSnapshotFound
    Selector: $.Payload.noSnapshotFound
    Type: String 
  nextStep: branchFromResults
- name: branchFromResults
  action: aws:branch
  onFailure: Abort
  onCancel: step:startInstance
  inputs:
    Choices:
    - NextStep: createNewRootVolumeFromSnapshot
      Not:
        Variable: "{{ getSnapshotsByStartTime.noSnapshotFound }}"
        StringEquals: "NoSnapshotFound"
  isEnd: true
- name: createNewRootVolumeFromSnapshot
  action: aws:executeAwsApi
  onFailure: Abort
  inputs:
    Service: ec2
    Api: CreateVolume
    AvailabilityZone: "{{ getInstanceDetails.availabilityZone }}"
    SnapshotId: "{{ getSnapshotsByStartTime.latestSnapshotId }}"
  outputs:
    - Name: newRootVolumeId
      Selector: "$.VolumeId"
      Type: String
  nextStep: stopInstance
- name: stopInstance
  action: aws:executeAwsApi
  onFailure: Abort
  inputs:
    Service: ec2
    Api: StopInstances
    InstanceIds:
    - "{{ InstanceId }}"
  nextStep: verifyVolumeAvailability
- name: verifyVolumeAvailability
  action: aws:waitForAwsResourceProperty
  timeoutSeconds: 120
  inputs:
    Service: ec2
    Api: DescribeVolumes
    VolumeIds:
    - "{{ createNewRootVolumeFromSnapshot.newRootVolumeId }}"
    PropertySelector: "$.Volumes[0].State"
    DesiredValues:
    - "available"
  nextStep: verifyInstanceStopped
- name: verifyInstanceStopped
  action: aws:waitForAwsResourceProperty
  timeoutSeconds: 120
  inputs:
    Service: ec2
    Api: DescribeInstances
    InstanceIds:
    - "{{ InstanceId }}"
    PropertySelector: "$.Reservations[0].Instances[0].State.Name"
    DesiredValues:
    - "stopped"
  nextStep: detachRootVolume
- name: detachRootVolume
  action: aws:executeAwsApi
  onFailure: Abort
  isCritical: true
  inputs:
    Service: ec2
    Api: DetachVolume
    VolumeId: "{{ getRootVolumeId.rootVolumeId }}"
  nextStep: verifyRootVolumeDetached
- name: verifyRootVolumeDetached
  action: aws:waitForAwsResourceProperty
  timeoutSeconds: 30
  inputs:
    Service: ec2
    Api: DescribeVolumes
    VolumeIds:
    - "{{ getRootVolumeId.rootVolumeId }}"
    PropertySelector: "$.Volumes[0].State"
    DesiredValues:
    - "available"
  nextStep: attachNewRootVolume
- name: attachNewRootVolume
  action: aws:executeAwsApi
  onFailure: Abort
  inputs:
    Service: ec2
    Api: AttachVolume
    Device: "{{ getInstanceDetails.rootDeviceName }}"
    InstanceId: "{{ InstanceId }}"
    VolumeId: "{{ createNewRootVolumeFromSnapshot.newRootVolumeId }}"
  nextStep: verifyNewRootVolumeAttached
- name: verifyNewRootVolumeAttached
  action: aws:waitForAwsResourceProperty
  timeoutSeconds: 30
  inputs:
    Service: ec2
    Api: DescribeVolumes
    VolumeIds:
    - "{{ createNewRootVolumeFromSnapshot.newRootVolumeId }}"
    PropertySelector: "$.Volumes[0].Attachments[0].State"
    DesiredValues:
    - "attached"
  nextStep: startInstance
- name: startInstance
  action: aws:executeAwsApi
  onFailure: Abort
  inputs:
    Service: ec2
    Api: StartInstances
    InstanceIds:
    - "{{ InstanceId }}"
```

# `aws:approve` - Unterbrechen einer Automatisierung zur manuellen Genehmigung


Hält eine Automatisierung zeitweise an, bis die Aktion von designierten Prinzipalen genehmigt oder abgelehnt wird. Nach Erreichen der erforderlichen Anzahl an Genehmigungen wird die Automatisierung fortgesetzt. Sie können den Genehmigungsschritt an jeder beliebigen Stelle im `mainSteps`-Bereich Ihres Runbooks ansetzen. 

**Anmerkung**  
Diese Aktion unterstützt keine Automatisierungen für mehrere Konten und Regionen. Das Standard-Timeout für diese Aktion beträgt 7 Tage (604 800 Sekunden) und der Höchstwert ist 30 Tage (2 592 000 Sekunden). Sie können die Zeitüberschreitung über den Parameter `timeoutSeconds` für einen `aws:approve`-Schritt anpassen.

Im folgenden Beispiel hält die Aktion `aws:approve` die Automatisierung vorübergehend an, bis ein Genehmiger die Automatisierung entweder akzeptiert oder ablehnt. Nach der Genehmigung führt die Automatisierung einen einfachen PowerShell Befehl aus. 

------
#### [ YAML ]

```
---
description: RunInstancesDemo1
schemaVersion: '0.3'
assumeRole: "{{ assumeRole }}"
parameters:
  assumeRole:
    type: String
  message:
    type: String
mainSteps:
- name: approve
  action: aws:approve
  timeoutSeconds: 1000
  onFailure: Abort
  inputs:
    NotificationArn: arn:aws:sns:us-east-2:12345678901:AutomationApproval
    Message: "{{ message }}"
    MinRequiredApprovals: 1
    Approvers:
    - arn:aws:iam::12345678901:user/AWS-User-1
- name: run
  action: aws:runCommand
  inputs:
    InstanceIds:
    - i-1a2b3c4d5e6f7g
    DocumentName: AWS-RunPowerShellScript
    Parameters:
      commands:
      - date
```

------
#### [ JSON ]

```
{
   "description":"RunInstancesDemo1",
   "schemaVersion":"0.3",
   "assumeRole":"{{ assumeRole }}",
   "parameters":{
      "assumeRole":{
         "type":"String"
      },
      "message":{
         "type":"String"
      }
   },
   "mainSteps":[
      {
         "name":"approve",
         "action":"aws:approve",
         "timeoutSeconds":1000,
         "onFailure":"Abort",
         "inputs":{
            "NotificationArn":"arn:aws:sns:us-east-2:12345678901:AutomationApproval",
            "Message":"{{ message }}",
            "MinRequiredApprovals":1,
            "Approvers":[
               "arn:aws:iam::12345678901:user/AWS-User-1"
            ]
         }
      },
      {
         "name":"run",
         "action":"aws:runCommand",
         "inputs":{
            "InstanceIds":[
               "i-1a2b3c4d5e6f7g"
            ],
            "DocumentName":"AWS-RunPowerShellScript",
            "Parameters":{
               "commands":[
                  "date"
               ]
            }
         }
      }
   ]
}
```

------

Sie können Automatisierungen, die in der Konsole noch nicht genehmigt wurden, genehmigen oder ablehnen.

**So genehmigen Sie Automatisierungen oder lehnen sie ab**

1. Öffnen Sie die AWS Systems Manager Konsole unter [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/).

1. Klicken Sie im Navigationsbereich auf **Automation**.

1. Wählen Sie die Option neben einer Automation mit dem Status **Waiting (Warten)**.  
![\[Zugriff auf die Approve/Deny Automatisierungsseite\]](http://docs.aws.amazon.com/de_de/systems-manager/latest/userguide/images/automation-approve-action-aws.png)

1. Wählen Sie **Approve/Deny** aus.

1. Überprüfen Sie die Details der Automation.

1. Wählen Sie **Approve** (Genehmigen) oder **Deny** (Verweigern), geben Sie einen optionalen Kommentar ein und wählen Sie dann **Submit** (Absenden) aus.

**Eingabebeispiel**

------
#### [ YAML ]

```
NotificationArn: arn:aws:sns:us-west-1:12345678901:Automation-ApprovalRequest
Message: Please approve this step of the Automation.
MinRequiredApprovals: 3
Approvers:
- IamUser1
- IamUser2
- arn:aws:iam::12345678901:user/IamUser3
- arn:aws:iam::12345678901:role/IamRole
```

------
#### [ JSON ]

```
{
   "NotificationArn":"arn:aws:sns:us-west-1:12345678901:Automation-ApprovalRequest",
   "Message":"Please approve this step of the Automation.",
   "MinRequiredApprovals":3,
   "Approvers":[
      "IamUser1",
      "IamUser2",
      "arn:aws:iam::12345678901:user/IamUser3",
      "arn:aws:iam::12345678901:role/IamRole"
   ]
}
```

------

NotificationArn  
Der Amazon Resource Name (ARN) eines Amazon Simple Notification Service (Amazon SNS) Themas für Automation-Genehmigungen. Wenn Sie einen `aws:approve`-Schritt in einer Automatisierung festlegen, sendet Automation eine Nachricht an dieses Thema und informiert die Prinzipale darüber, dass sie einen Automation-Schritt entweder genehmigen oder zurückweisen müssen. Die Bezeichnung des Amazon-SNS-Themas muss das Präfix „Automatisierung“ aufweisen.  
Typ: Zeichenfolge  
Erforderlich: Nein

Fehlermeldung  
Die Informationen, die Sie in das Amazon-SNS-Thema einbeziehen möchten, wenn die Genehmigungsanforderung gesendet wird. Die maximale Länge der Nachricht beträgt 4096 Zeichen.   
Typ: Zeichenfolge  
Erforderlich: Nein

MinRequiredApprovals  
Die erforderliche Mindestanzahl an Genehmigungen zum Fortsetzen der Automatisierung. Wenn Sie keinen Wert angeben, verwendet das System standardmäßig den Wert 1. Der Wert für diesen Parameter muss eine positive Zahl sein. Der Wert für diesen Parameter darf nicht größer sein als die Anzahl der Genehmiger, die anhand des `Approvers`-Parameters definiert sind.   
Typ: Ganzzahl  
Erforderlich: Nein

Genehmiger  
Eine Liste AWS authentifizierter Principals, die die Aktion entweder genehmigen oder ablehnen können. Die maximale Anzahl an Genehmigern ist 10. Sie können Prinzipale anhand eines der folgenden Formate festlegen:  
+ Ein Benutzername
+ Ein Benutzer-ARN
+ Ein IAM-Rollen-ARN
+ Ein IAM-Rollenübernahme-ARN
Typ: StringList  
Erforderlich: Ja

EnhancedApprovals  
Diese Eingabe wird nur für Change Manager-Vorlagen verwendet. Eine Liste der AWS authentifizierten Prinzipals, die die Aktion entweder genehmigen oder ablehnen können, den Typ des IAM-Prinzipals und die Mindestanzahl von Genehmiger. Im Folgenden wird ein Beispiel gezeigt:  

```
schemaVersion: "0.3"
emergencyChange: false
autoApprovable: false
mainSteps:
    - name: ApproveAction1
    action: aws:approve
    timeoutSeconds: 604800
    inputs:
        Message: Please approve this change request
        MinRequiredApprovals: 3
        EnhancedApprovals:
        Approvers:
            - approver: John Stiles
            type: IamUser
            minRequiredApprovals: 0
            - approver: Ana Carolina Silva
            type: IamUser
            minRequiredApprovals: 0
            - approver: GroupOfThree
            type: IamGroup
            minRequiredApprovals: 0
            - approver: RoleOfTen
            type: IamRole
            minRequiredApprovals: 0
```
Typ: StringList  
Erforderlich: Ja

**Ausgabe**

ApprovalStatus  
Der Genehmigungsstatus des Schritts. Der Status kann einer der folgenden sein: Genehmigt, Abgelehnt oder Warten. Warten bedeutet, dass Automation auf eine Eingabe der Genehmiger wartet.  
Typ: Zeichenfolge

ApproverDecisions  
Eine JSON-Karte, die den Genehmigungsbescheid der einzelnen Genehmiger enthält.  
Typ: MapList

# `aws:assertAwsResourceProperty`— Bestätigt einen AWS Ressourcen- oder Ereignisstatus


Die Aktion `aws:assertAwsResourceProperty` erlaubt Ihnen, einen bestimmten Ressourcen- oder Ereignisstatus für einen bestimmten Automation-Schritt zu prüfen.

**Anmerkung**  
Die Aktion `aws:assertAwsResourceProperty` unterstützt die automatische Drosselungswiederholung. Weitere Informationen finden Sie unter [Konfigurieren der automatischen Wiederholung für gedrosselte Vorgänge](automation-throttling-retry.md).

Weitere Beispiele zur Verwendung dieser Aktion finden Sie unter [Weitere Runbook-Beispiele](automation-document-examples.md).

**Input**  
Eingaben werden von der ausgewählten API-Operation bestimmt. 

------
#### [ YAML ]

```
action: aws:assertAwsResourceProperty
inputs:
  Service: The official namespace of the service
  Api: The API operation or method name
  API operation inputs or parameters: A value
  PropertySelector: Response object
  DesiredValues:
  - Desired property values
```

------
#### [ JSON ]

```
{
  "action": "aws:assertAwsResourceProperty",
  "inputs": {
    "Service":"The official namespace of the service",
    "Api":"The API operation or method name",
    "API operation inputs or parameters":"A value",
    "PropertySelector": "Response object",
    "DesiredValues": [
      "Desired property values"
    ]
  }
}
```

------

Service  
Der AWS-Service Namespace, der die API-Operation enthält, die Sie ausführen möchten. Beispielsweise lautet der Namespace für Systems Manager `ssm`. Der Namespace für Amazon EC2 lautet `ec2`. Sie finden eine Liste der unterstützten AWS-Service -Namespaces im Abschnitt [Verfügbare Services](https://docs.aws.amazon.com/cli/latest/reference/#available-services) der *AWS CLI -Befehlsreferenz*.  
Typ: Zeichenfolge  
Erforderlich: Ja

Api  
Der Name der API-Operation, die Sie ausführen möchten. Sie können die API-Operationen (auch als Methoden bezeichnet) anzeigen, indem Sie einen Service in der linken Navigationsleiste auf der folgenden [Service-Referenzen](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/index.html)-Seite auswählen. Wählen Sie eine Methode im Abschnitt **Client** für den Service, den Sie aufrufen möchten. Beispielsweise werden alle API-Vorgänge (Methoden) für Amazon Relational Database Service (Amazon RDS) auf der folgenden Seite aufgelistet: [Amazon RDS-Methoden](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rds.html).  
Typ: Zeichenfolge  
Erforderlich: Ja

API-Operation-Eingaben  
Eine oder mehrere API-Eingaben. Sie können die verfügbaren Eingaben (auch als Parameter bezeichnet) anzeigen, indem Sie einen Service in der linken Navigationsleiste auf der folgenden [Service-Referenzen](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/index.html)-Seite auswählen. Wählen Sie eine Methode im Abschnitt **Client** für den Service, den Sie aufrufen möchten. Beispielsweise sind alle Methoden für Amazon RDS auf der folgenden Seite aufgeführt: [Amazon RDS-Methoden](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rds.html). ****Wählen Sie die Methode [describe\$1db\$1instances](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rds.html#RDS.Client.describe_db_instances) und scrollen Sie nach unten, um die verfügbaren Parameter wie **DBInstanceIdentifier**, Name und Values zu sehen.**** Verwenden Sie das folgende Format, um mehr als eine Eingabe anzugeben.  

```
inputs:
  Service: The official namespace of the service
  Api: The API operation name
  API input 1: A value
  API Input 2: A value
  API Input 3: A value
```

```
"inputs":{
      "Service":"The official namespace of the service",
      "Api":"The API operation name",
      "API input 1":"A value",
      "API Input 2":"A value",
      "API Input 3":"A value"
}
```
Typ: Abhängig von der gewählten API-Operation  
Erforderlich: Ja

PropertySelector  
Das JSONPath zu einem bestimmten Attribut im Antwortobjekt. Sie können die Antwortobjekte anzeigen indem Sie einen Service in der linken Navigationsleiste auf der folgenden [Service-Referenzen](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/index.html)-Seite auswählen. Wählen Sie eine Methode im Abschnitt **Client** für den Service, den Sie aufrufen möchten. Beispielsweise sind alle Methoden für Amazon RDS auf der folgenden Seite aufgeführt: [Amazon RDS-Methoden](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rds.html). **Wählen Sie die Methode [describe\$1db\$1instances](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rds.html#RDS.Client.describe_db_instances) und scrollen Sie nach unten zum Abschnitt Antwortstruktur.** **DBInstances**ist als Antwortobjekt aufgeführt.  
Typ: Zeichenfolge  
Erforderlich: Ja

DesiredValues  
Die erwartete Status oder Zustand, bei dem die Automatisierung fortgesetzt werden soll. Wenn Sie einen booleschen Wert angeben, müssen Sie einen Großbuchstaben verwenden, wie z. B. True oder False.  
Typ: StringList  
Erforderlich: Ja

# `aws:branch` - Ausführen bedingter Automatisierungsschritte


Die Aktion `aws:branch` erlaubt das Erstellen einer dynamischen Automatisierung, der verschiedene Auswahlmöglichkeiten in einem einzigen Schritt evaluiert und dann auf der Grundlage dieser Evaluierung zu einem anderen Schritt in dem Runbook springt. 

Wenn Sie die Aktion `aws:branch` für einen Schritt angeben, geben Sie die `Choices` an, die die Automatisierung evaluieren muss. Die `Choices` können auf einem Wert basieren, den Sie im Abschnitt `Parameters` des Runbooks angegeben haben, oder auf einem als Ausgabe von dem vorherigen Schritt generierten dynamischen Wert basieren. Die Automatisierung evaluiert jede Auswahl mithilfe eines booleschen Ausdrucks. Wenn die erste Auswahl „wahr“ ist, springt die Automatisierung zu dem für diese Auswahl vorgesehenen Schritt. Wenn die erste Auswahl „false“ ist, evaluiert die Automatisierung die nächste Auswahl. Die Automatisierung evaluiert weiterhin jede Auswahl, bis eine Auswahl als „true“ verarbeitet wird. Die Automatisierung springt dann zu dem für die als „true“ evaluierte Auswahl angegebenen Schritt.

Wenn keine Auswahl als „true“ evaluiert wird, 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.

Die Aktion `aws:branch` unterstützt komplexe Auswahlevaluierungen durch Verwendung einer Kombination der Operatoren `And`, `Not` und `Or`. Weitere Informationen über die Verwendung von `aws:branch`, mit Beispielrunbooks und Beispielen, die unterschiedliche Operatoren verwenden, finden Sie unter [Verwendung bedingter Anweisungen in Runbooks](automation-branch-condition.md).

**Input**  
Geben Sie eine oder mehrere `Choices` in einem Schritt an. Die `Choices` können auf einem Wert basieren, den Sie im Abschnitt `Parameters` des Runbooks angegeben haben, oder auf einem als Ausgabe von dem vorherigen Schritt generierten dynamischen Wert basieren. Hier ist ein YAML-Beispiel, das einen Parameter evaluiert.

```
mainSteps:
- name: chooseOS
  action: aws:branch
  inputs:
    Choices:
    - NextStep: runWindowsCommand
      Variable: "{{Name of a parameter defined in the Parameters section. For example: OS_name}}"
      StringEquals: windows
    - NextStep: runLinuxCommand
      Variable: "{{Name of a parameter defined in the Parameters section. For example: OS_name}}"
      StringEquals: linux
    Default:
      sleep3
```

Hier ist ein YAML-Beispiel, das die Ausgabe von einem vorherigen Schritt evaluiert.

```
mainSteps:
- name: chooseOS
  action: aws:branch
  inputs:
    Choices:
    - NextStep: runPowerShellCommand
      Variable: "{{Name of a response object. For example: GetInstance.platform}}"
      StringEquals: Windows
    - NextStep: runShellCommand
      Variable: "{{Name of a response object. For example: GetInstance.platform}}"
      StringEquals: Linux
    Default:
      sleep3
```

Auswahlen  
Ein oder mehrere Ausdrücke, die die Automatisierung evaluieren soll, wenn der nächste zu verarbeitende Schritt bestimmt wird. Auswahlen werden mit einem booleschen Ausdruck evaluiert. Jede Auswahl muss die folgenden Optionen definieren:  
+ **NextStep**: Der nächste Schritt im Runbook, der verarbeitet werden soll, wenn die angegebene Auswahl wahr ist.
+ **Variable**: Geben Sie entweder den Namen eines Parameters an, der im Abschnitt `Parameters` des Runbooks definiert ist, Oder geben Sie ein Ausgabeobjekt von einem vorherigen Schritt im Runbook an. Weitere Informationen zum Erstellen von Variablen für `aws:branch` finden Sie unter [Informationen zum Erstellen der Ausgabevariable](automation-branch-condition.md#branch-action-output).
+ **Operation**: Die Kriterien für die Evaluierung der Auswahl. 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.

Standard  
Der Name eines Schritts, zu dem die Automatisierung springen soll, wenn keine der `Choices` „true“ ist.  
Typ: Zeichenfolge  
Erforderlich: Nein

**Anmerkung**  
Die Aktion `aws:branch` unterstützt die Operatoren `And`, `Or` und `Not`. Beispiele für `aws:branch` unter Verwendung von Operatoren finden Sie unter [Verwendung bedingter Anweisungen in Runbooks](automation-branch-condition.md).

# `aws:changeInstanceState` – Instance-Status ändern oder geltend machen


Ändert oder klärt den Status der Instance.

Diese Aktivität kann im Assert-Modus verwendet werden (führt jedoch die API nicht aus, um den Status zu ändern, sondern prüft, ob die Instance den gewünschten Status aufweist.) Um den Assert-Modus zu verwenden, setzen Sie den Parameter `CheckStateOnly` auf "true". Dieser Modus ist nützlich, wenn der Sysprep-Befehl unter Windows Server ausgeführt wird. Bei diesem Befehl handelt es sich um einen asynchronen Befehl, der lange Zeit im Hintergrund ausgeführt werden kann. Sie können sicherstellen, dass die Instance angehalten wird, bevor Sie ein Amazon Machine Image (AMI) erstellen.

**Anmerkung**  
Der Standardwert für die Zeitüberschreitung für diese Aktion beträgt 3 600 Sekunden (eine Stunde). Sie können die Zeitüberschreitung über den Parameter `timeoutSeconds` für einen `aws:changeInstanceState`-Schritt anpassen.

**Anmerkung**  
Die Aktion `aws:changeInstanceState` unterstützt die automatische Drosselungswiederholung. Weitere Informationen finden Sie unter [Konfigurieren der automatischen Wiederholung für gedrosselte Vorgänge](automation-throttling-retry.md).

**Eingabe**

------
#### [ YAML ]

```
name: stopMyInstance
action: aws:changeInstanceState
maxAttempts: 3
timeoutSeconds: 3600
onFailure: Abort
inputs:
  InstanceIds:
  - i-1234567890abcdef0
  CheckStateOnly: true
  DesiredState: stopped
```

------
#### [ JSON ]

```
{
    "name":"stopMyInstance",
    "action": "aws:changeInstanceState",
    "maxAttempts": 3,
    "timeoutSeconds": 3600,
    "onFailure": "Abort",
    "inputs": {
        "InstanceIds": ["i-1234567890abcdef0"],
        "CheckStateOnly": true,
        "DesiredState": "stopped"
    }
}
```

------

InstanceIds  
Die IDs der Instanzen.  
Typ: StringList  
Erforderlich: Ja

CheckStateOnly  
Wenn „false“, wird der Instance-Status auf den gewünschten Status festgelegt. Wenn „true“, wird der gewünschte Status anhand einer Abfrage überprüft.  
Standard: `false`  
Typ: Boolesch  
Erforderlich: Nein

DesiredState  
Der gewünschte Status. Bei der Einstellung `running` wartet diese Aktion auf den Amazon EC2 Status `Running`, den Instance-Status `OK` und den Systemstatus `OK` vor dem Abschluss.  
Typ: Zeichenfolge  
Zulässige Werte: `running` \$1 `stopped` \$1 `terminated`  
Erforderlich: Ja

Force  
Wenn festgelegt, wird das Anhalten der Instances erzwungen. Die Instances haben keine Gelegenheit, die Caches oder Metadaten des Dateisystems zu leeren. Wenn Sie diese Option verwenden, müssen Sie eine Überprüfung und Reparatur des Dateisystems durchführen. Diese Option wird für EC2-Instances für Windows Server nicht empfohlen.  
Typ: Boolesch  
Erforderlich: Nein

AdditionalInfo  
Reserved Instances.  
Typ: Zeichenfolge  
Erforderlich: Nein

**Ausgabe**  
Keine

# `aws:copyImage` - Kopieren oder Verschlüsseln eines Amazon Machine Image


Kopiert ein Amazon Machine Image (AMI) aus einer beliebigen Region AWS-Region in die aktuelle Region. Diese Aktion kann auch das neue AMI verschlüsseln.

**Anmerkung**  
Die Aktion `aws:copyImage` unterstützt die automatische Drosselungswiederholung. Weitere Informationen finden Sie unter [Konfigurieren der automatischen Wiederholung für gedrosselte Vorgänge](automation-throttling-retry.md).

**Input**  
Diese Aktion unterstützt die meisten `CopyImage`-Parameter. Weitere Informationen finden Sie unter [CopyImage](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CopyImage.html).

Das folgende Beispiel erstellt eine Kopie eines AMI in der Region Seoul (`SourceImageID`: ami-0fe10819. `SourceRegion`: ap-northeast-2). Das neue AMI wird in die Region kopiert, in der Sie die Automation-Aktivität gestartet haben. Das kopierte AMI wird verschlüsselt, da das optionale `Encrypted`-Flag auf `true` gesetzt ist.

------
#### [ YAML ]

```
name: createEncryptedCopy
action: aws:copyImage
maxAttempts: 3
onFailure: Abort
inputs:
  SourceImageId: ami-0fe10819
  SourceRegion: ap-northeast-2
  ImageName: Encrypted Copy of LAMP base AMI in ap-northeast-2
  Encrypted: true
```

------
#### [ JSON ]

```
{   
    "name": "createEncryptedCopy",
    "action": "aws:copyImage",
    "maxAttempts": 3,
    "onFailure": "Abort",
    "inputs": {
        "SourceImageId": "ami-0fe10819",
        "SourceRegion": "ap-northeast-2",
        "ImageName": "Encrypted Copy of LAMP base AMI in ap-northeast-2",
        "Encrypted": true
    }   
}
```

------

SourceRegion  
Die Region, in der Quell-AMI derzeit vorhanden ist.  
Typ: Zeichenfolge  
Erforderlich: Ja

SourceImageId  
Die AMI-ID, die aus der Quellregion kopiert werden soll.  
Typ: Zeichenfolge  
Erforderlich: Ja

ImageName  
Der Name für das neue Image.  
Typ: Zeichenfolge  
Erforderlich: Ja

ImageDescription  
Eine Beschreibung des Ziel-Image.  
Typ: Zeichenfolge  
Erforderlich: Nein

Verschlüsselt  
Verschlüsseln Sie das AMI.  
Typ: Boolesch  
Erforderlich: Nein

KmsKeyId  
Der vollständige Amazon-Ressourcenname (ARN), der beim Verschlüsseln der Snapshots eines Images während eines Kopiervorgangs verwendet werden AWS KMS key soll. Weitere Informationen finden Sie unter [CopyImage](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/api_copyimage.html).  
Typ: Zeichenfolge  
Erforderlich: Nein

ClientToken  
Ein eindeutiger Bezeichner, bei dem die Groß- und Kleinschreibung beachtet werden muss, um die Idempotenz der Anforderung sicherzustellen. Weitere Informationen finden Sie unter [CopyImage](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/api_copyimage.html).  
Typ: Zeichenfolge  
Erforderlich: NeinAusgabe

ImageId  
Die ID des kopierten Image.

ImageState  
Der Status des kopierten Image.  
Zulässige Werte: `available` \$1 `pending` \$1 `failed`

# `aws:createImage` - Erstellen eines Amazon Machine Image


Erstellt ein Amazon Machine Image (AMI) aus einer Instance, die entweder ausgeführt wird, angehalten wird oder angehalten ist, und fragt ab, ob `ImageState` gleich `available` ist.

**Anmerkung**  
Die Aktion `aws:createImage` unterstützt die automatische Drosselungswiederholung. Weitere Informationen finden Sie unter [Konfigurieren der automatischen Wiederholung für gedrosselte Vorgänge](automation-throttling-retry.md).

**Input**  
Diese Aktion unterstützt die folgenden `CreateImage`-Parameter. Weitere Informationen finden Sie unter [CreateImage](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateImage.html).

------
#### [ YAML ]

```
name: createMyImage
action: aws:createImage
maxAttempts: 3
onFailure: Abort
inputs:
  InstanceId: i-1234567890abcdef0
  ImageName: AMI Created on{{global:DATE_TIME}}
  NoReboot: true
  ImageDescription: My newly created AMI
```

------
#### [ JSON ]

```
{
    "name": "createMyImage",
    "action": "aws:createImage",
    "maxAttempts": 3,
    "onFailure": "Abort",
    "inputs": {
        "InstanceId": "i-1234567890abcdef0",
        "ImageName": "AMI Created on{{global:DATE_TIME}}",
        "NoReboot": true,
        "ImageDescription": "My newly created AMI"
    }
}
```

------

InstanceId  
Die ID der Instance.  
Typ: Zeichenfolge  
Erforderlich: Ja

ImageName  
Der Name für das Image.  
Typ: Zeichenfolge  
Erforderlich: Ja

ImageDescription  
Eine Beschreibung des Image.  
Typ: Zeichenfolge  
Erforderlich: Nein

NoReboot  
Ein boolesches Literal.  
Standardmäßig versucht Amazon Elastic Compute Cloud (Amazon EC2) vor dem Erstellen des Images, die Instance herunterzufahren und neu zu starten. Wenn die Option **No Reboot (Kein Neustart)** auf `true` eingestellt ist, fährt Amazon EC2 die Instance vor dem Erstellen des Images nicht herunter. Wenn diese Option verwendet wird, kann die Integrität des Dateisystems auf dem erstellten Image nicht garantiert werden.   
Wenn Sie nicht möchten, dass die Instanz ausgeführt wird, nachdem Sie eine AMI aus ihr erstellt haben, verwenden Sie zuerst die [`aws:changeInstanceState` – Instance-Status ändern oder geltend machen](automation-action-changestate.md) Aktion, um die Instanz zu beenden, und verwenden Sie dann diese `aws:createImage` Aktion mit der **NoReboot**Option, die auf gesetzt ist`true`.  
Typ: Boolesch  
Erforderlich: Nein

BlockDeviceMappings  
Die Blockgeräte für die Instance.  
Typ: Zuordnung  
Erforderlich: NeinAusgabe

ImageId  
Die ID des neu erstellten Image.  
Typ: Zeichenfolge

ImageState  
Der aktuelle Status des Image. Wenn der Status verfügbar ist, wird das Image erfolgreich registriert und kann zum Starten einer Instance verwendet werden.  
Typ: Zeichenfolge

# `aws:createStack`— Einen CloudFormation Stapel erstellen


Erzeugt einen AWS CloudFormation Stapel aus einer Vorlage.

**Anmerkung**  
Die Aktion `aws:createStack` unterstützt die automatische Drosselungswiederholung. Weitere Informationen finden Sie unter [Konfigurieren der automatischen Wiederholung für gedrosselte Vorgänge](automation-throttling-retry.md).

Zusätzliche Informationen zum Erstellen von CloudFormation Stacks finden Sie [CreateStack](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html)in der *AWS CloudFormation API-Referenz*. 

**Eingabe**

------
#### [ YAML ]

```
name: makeStack
action: aws:createStack
maxAttempts: 1
onFailure: Abort
inputs:
  Capabilities:
  - CAPABILITY_IAM
  StackName: myStack
  TemplateURL: http://s3.amazonaws.com/amzn-s3-demo-bucket/myStackTemplate
  TimeoutInMinutes: 5
  Parameters:
    - ParameterKey: LambdaRoleArn
      ParameterValue: "{{LambdaAssumeRole}}"
    - ParameterKey: createdResource
      ParameterValue: createdResource-{{automation:EXECUTION_ID}}
```

------
#### [ JSON ]

```
{
    "name": "makeStack",
    "action": "aws:createStack",
    "maxAttempts": 1,
    "onFailure": "Abort",
    "inputs": {
        "Capabilities": [
            "CAPABILITY_IAM"
        ],
        "StackName": "myStack",
        "TemplateURL": "http://s3.amazonaws.com/amzn-s3-demo-bucket/myStackTemplate",
        "TimeoutInMinutes": 5,
        "Parameters": [
          {
            "ParameterKey": "LambdaRoleArn",
            "ParameterValue": "{{LambdaAssumeRole}}"
          },
          {
            "ParameterKey": "createdResource",
            "ParameterValue": "createdResource-{{automation:EXECUTION_ID}}"
          }
    }
}
```

------

Capabilities  
Mit einer Liste von Werten, die Sie zuvor angegeben haben, CloudFormation können Sie bestimmte Stacks erstellen. Einige Stack-Vorlagen enthalten Ressourcen, die sich auf Ihre AWS-Konto Berechtigungen auswirken können. Für einige Stacks müssen Sie deren Fähigkeiten mithilfe dieses Parameters explizit bestätigen.   
Gültige Werte sind: `CAPABILITY_IAM`, `CAPABILITY_NAMED_IAM` und `CAPABILITY_AUTO_EXPAND`.   
**CAPABILITY\$1IAM und CAPABILITY\$1NAMED\$1IAM**  
Wenn Sie &IAM;-Ressourcen besitzen, können Sie jede Fähigkeit angeben. Wenn Sie IAM-Ressourcen mit benutzerdefinierten Namen besitzen, müssen Sie `CAPABILITY_NAMED_IAM` angeben. Wenn Sie diesen Parameter angeben, gibt die Aktivität einen `InsufficientCapabilities`-Fehler zurück. Für die folgenden Ressourcen müssen Sie entweder `CAPABILITY_IAM` oder `CAPABILITY_NAMED_IAM` angeben.
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-accesskey.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-accesskey.html)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-group.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-group.html)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-instanceprofile.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-instanceprofile.html)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-policy.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-policy.html)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-user.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-user.html)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-addusertogroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-iam-addusertogroup.html)
Wenn Ihre Stack-Vorlage diese Ressourcen enthält, empfehlen wir, dass Sie alle ihnen zugeordneten Berechtigungen überprüfen und ihre Berechtigungen bei Bedarf bearbeiten.   
Weitere Informationen finden Sie unter [Bestätigung von IAM-Ressourcen in CloudFormation Vorlagen](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html#capabilities).   
**CAPABILITY\$1AUTO\$1EXPAND**  
Einige Vorlagen enthalten Makros. Makros führen eine benutzerdefinierte Verarbeitung von Vorlagen durch. Dies kann einfache Aktionen wie find-and-replace Operationen bis hin zu umfangreichen Transformationen ganzer Vorlagen umfassen. Aus diesem Grund erstellt der Benutzer normalerweise einen Änderungssatz aus der verarbeiteten Vorlage, sodass er die aus den Makros resultierenden Änderungen überprüfen kann, bevor er den Stack tatsächlich erstellt. Wenn Ihre Stack-Vorlage ein oder mehrere Makros enthält und Sie sich dafür entscheiden, einen Stack direkt aus der verarbeiteten Vorlage zu erstellen, ohne vorher die resultierenden Änderungen in einem Änderungssatz zu überprüfen, müssen Sie diese Funktion berücksichtigen. 
*Weitere Informationen finden Sie im [Benutzerhandbuch unter Verwenden von AWS CloudFormation Makros zur benutzerdefinierten Verarbeitung von Vorlagen](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-macros.html).AWS CloudFormation *  
Typ: Zeichenfolge-Array  
Zulässige Werte: `CAPABILITY_IAM | CAPABILITY_NAMED_IAM | CAPABILITY_AUTO_EXPAND`  
Erforderlich: Nein

ClientRequestToken  
Eine eindeutige Kennung für diese CreateStack Anfrage. Geben Sie dieses Token an, wenn Sie maxAttempts in diesem Schritt auf einen Wert größer als 1 festlegen. Durch die Angabe dieses Tokens CloudFormation weiß, dass Sie nicht versuchen, einen neuen Stack mit demselben Namen zu erstellen.  
Typ: Zeichenfolge  
Erforderlich: Nein  
Längenbeschränkungen: Minimale Länge beträgt 1 Zeichen. Maximale Länge beträgt 128 Zeichen.  
Muster: [a-zA-Z0-9][-a-zA-Z0-9]\$1

DisableRollback  
Legen Sie den Parameter auf `true` fest, um ein Rollback des Stacks zu deaktivieren, wenn ein Fehler bei der Erstellung des Stacks aufgetreten ist.  
Bedingt: Sie können entweder den `DisableRollback`-Parameter oder den `OnFailure`-Parameter festlegen, aber nicht beide.   
Standard: `false`  
Typ: Boolesch  
Erforderlich: Nein

Benachrichtigung ARNs  
Das Thema Amazon Simple Notification Service (Amazon SNS) ARNs zur Veröffentlichung von Ereignissen im Zusammenhang mit Stacks. [Sie finden das SNS-Thema ARNs in der Amazon SNS SNS-Konsole, https://console.aws.amazon.com/sns/ v3/home.](https://console.aws.amazon.com/sns/v3/home)   
Typ: Zeichenfolge-Array  
Array-Mitglieder: Maximale Anzahl von 5 Elementen.  
Erforderlich: Nein

OnFailure  
Bestimmt die Aktion, die ergriffen werden muss, wenn ein Fehler am Stack auftritt. Sie müssen `DO_NOTHING`, `ROLLBACK` oder `DELETE` angeben.  
Bedingt: Sie können entweder den `OnFailure`-Parameter oder den `DisableRollback`-Parameter festlegen, aber nicht beide.   
Standard: `ROLLBACK`  
Typ: Zeichenfolge  
Zulässige Werte:` DO_NOTHING | ROLLBACK | DELETE`  
Erforderlich: Nein

Parameters  
Eine Liste der `Parameter`-Strukturen, die Eingabeparameter für den Stack angeben. Weitere Informationen finden Sie im Datentyp [Parameter](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_Parameter.html).   
Typ: Array von [Parameter](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_Parameter.html)-Objekten   
Erforderlich: Nein

ResourceTypes  
Die Vorlagenressourcentypen für diese Aktion zum Erstellen von Stacks, für die Sie über Berechtigungen verfügen. Beispiel: `AWS::EC2::Instance`, `AWS::EC2::*` oder `Custom::MyCustomInstance`. Verwenden Sie die folgende Syntax zum Beschreiben von Vorlagenressourcentypen.  
+ Für alle Ressourcen: AWS 

  ```
  AWS::*
  ```
+ Für alle benutzerdefinierten Ressourcen:

  ```
  Custom::*
  ```
+ Für eine bestimmte benutzerdefinierte Ressource:

  ```
  Custom::logical_ID
  ```
+ Für alle Ressourcen eines bestimmten AWS-Service:

  ```
  AWS::service_name::*
  ```
+ Für eine bestimmte AWS Ressource:

  ```
  AWS::service_name::resource_logical_ID
  ```
Wenn die Liste der Ressourcentypen keine Ressource enthält, die Sie erstellen, schlägt die Erstellung des Stacks fehl. CloudFormation Gewährt standardmäßig Berechtigungen für alle Ressourcentypen. IAM verwendet diesen Parameter für CloudFormation -spezifische Bedingungsschlüssel in IAM-Richtlinien. Weitere Informationen finden Sie unter [Zugriffskontrolle](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html) mit. AWS Identity and Access Management  
Typ: Zeichenfolge-Array  
Längenbeschränkungen: Minimale Länge beträgt 1 Zeichen. Maximale Länge beträgt 256 Zeichen.  
Erforderlich: Nein

RoleARN  
Der Amazon-Ressourcenname (ARN) einer IAM-Rolle, die CloudFormation davon ausgeht, den Stack zu erstellen. CloudFormation verwendet die Anmeldeinformationen der Rolle, um in Ihrem Namen Anrufe zu tätigen. CloudFormation verwendet diese Rolle immer für alle future Operationen auf dem Stack. Wenn Benutzer die Berechtigung für Vorgänge am Stack besitzen, verwendet CloudFormation diese Rolle auch dann, wenn die Benutzer nicht über die Berechtigung zur Weitergabe verfügen. Stellen Sie sicher, dass die Rolle die geringstmögliche Menge an Berechtigungen gewährt.   
Wenn Sie keinen Wert angeben, CloudFormation verwendet die Rolle, die zuvor dem Stack zugeordnet war. Wenn keine Rolle verfügbar ist, CloudFormation verwendet eine temporäre Sitzung, die anhand Ihrer Benutzeranmeldedaten generiert wird.   
Typ: Zeichenfolge  
Längenbeschränkungen: Minimale Länge von 20. Maximale Länge beträgt 2048 Zeichen.  
Erforderlich: Nein

StackName  
Der dem Stack zugeordnete Name. Der Name muss in der Region eindeutig sein, in der Sie den Stack erstellen.  
Ein Stack-Name darf nur alphanumerische Zeichen (wobei die Groß- und Kleinschreibung beachtet werden muss) und Bindestriche enthalten. Er muss mit einem alphabetischen Zeichen beginnen und darf nicht mehr als 128 Zeichen umfassen. 
Typ: Zeichenfolge  
Erforderlich: Ja

StackPolicyBody  
Struktur, die die Stack-Richtlinie enthält. Weitere Informationen finden Sie unter [Verhindern von Aktualisierungen der Stack-Ressourcen](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/protect-stack-resources.html).  
Bedingt: Sie können entweder den `StackPolicyBody`-Parameter oder den `StackPolicyURL`-Parameter festlegen, aber nicht beide.   
Typ: Zeichenfolge  
Längenbeschränkungen: Minimale Länge beträgt 1 Zeichen. Maximale Länge beträgt 16384 Zeichen.  
Erforderlich: Nein

StackPolicyURL  
Speicherort einer Datei, die die Stack-Richtlinie enthält. Die URL muss auf eine Richtlinie in einem S3-Bucket in derselben Region wie der Stack verweisen. Die maximal zulässige Dateigröße für die Stack-Richtlinie ist 16 KB.  
Bedingt: Sie können entweder den `StackPolicyBody`-Parameter oder den `StackPolicyURL`-Parameter festlegen, aber nicht beide.   
Typ: Zeichenfolge  
Längenbeschränkungen: Minimale Länge beträgt 1 Zeichen. Maximale Länge beträgt 1350 Zeichen.  
Erforderlich: Nein

Tags (Markierungen)  
Schlüssel-Wert-Paare, die diesem Stack zugeordnet werden sollen. CloudFormation überträgt diese Tags auch auf die im Stack erstellten Ressourcen. Sie können höchstens 10 Tags angeben.   
Typ: Array von [Tag](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_Tag.html)-Objekten   
Erforderlich: Nein

TemplateBody  
Struktur, die den Vorlagetext mit einer Mindestlänge von 1 Byte und einer Höchstlänge von 51.200 Byte enthält. Weitere Informationen finden Sie unter [Aufbau einer Vorlage](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html).   
Bedingt: Sie können entweder den `TemplateBody`-Parameter oder den `TemplateURL`-Parameter festlegen, aber nicht beide.   
Typ: Zeichenfolge  
Längenbeschränkungen: Minimale Länge beträgt 1 Zeichen.  
Erforderlich: Nein

TemplateURL  
Speicherort einer Datei, die den Vorlagentext enthält. Die URL muss auf eine Vorlage verweisen, die sich in einem S3-Bucket befindet. Die maximal zulässige Größe für die Vorlage ist 460.800 Byte. Weitere Informationen finden Sie unter [Aufbau einer Vorlage](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html).   
Bedingt: Sie können entweder den `TemplateBody`-Parameter oder den `TemplateURL`-Parameter festlegen, aber nicht beide.   
Typ: Zeichenfolge  
Längenbeschränkungen: Minimale Länge von 1. Maximale Länge beträgt 1024 Zeichen.  
Erforderlich: Nein

TimeoutInMinutes  
Die Zeit, die verstreichen kann, bevor der Stack-Status zu `CREATE_FAILED` wird. Falls `DisableRollback` nicht festgelegt ist oder auf `false` festgelegt ist, wird für den Stack ein Rollback ausgeführt.   
Typ: Ganzzahl  
Gültiger Bereich: Mindestwert 1.  
Erforderlich: Nein

## Outputs


StackId  
Eindeutiger Bezeichner des Stacks.  
Typ: Zeichenfolge

StackStatus  
Aktueller Status des Stacks.  
Typ: Zeichenfolge  
Zulässige Werte: `CREATE_IN_PROGRESS | CREATE_FAILED | CREATE_COMPLETE | ROLLBACK_IN_PROGRESS | ROLLBACK_FAILED | ROLLBACK_COMPLETE | DELETE_IN_PROGRESS | DELETE_FAILED | DELETE_COMPLETE | UPDATE_IN_PROGRESS | UPDATE_COMPLETE_CLEANUP_IN_PROGRESS | UPDATE_COMPLETE | UPDATE_ROLLBACK_IN_PROGRESS | UPDATE_ROLLBACK_FAILED | UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS | UPDATE_ROLLBACK_COMPLETE | REVIEW_IN_PROGRESS`  
Erforderlich: Ja

StackStatusReason  
Erfolgs- oder Fehlermeldung im Zusammenhang mit dem Stack-Status.  
Typ: Zeichenfolge  
Erforderlich: Nein  
Weitere Informationen finden Sie unter [CreateStack](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html).

## Sicherheitsüberlegungen


Bevor Sie die Aktion `aws:createStack` verwenden können, müssen Sie folgende Richtlinie der IAM-Automation-Assume-Role zuweisen. Weitere Informationen über die Übernahmerolle finden Sie unter [Aufgabe 1: Erstellen einer Servicerolle für Automation](automation-setup-iam.md#create-service-role). 

------
#### [ JSON ]

****  

```
{
   "Version":"2012-10-17",		 	 	 
   "Statement":[
      {
         "Effect":"Allow",
         "Action":[
            "sqs:*",
            "cloudformation:CreateStack",
            "cloudformation:DescribeStacks"
         ],
         "Resource":"*"
      }
   ]
}
```

------

# `aws:createTags`— Erstelle Tags für AWS Ressourcen


Erstellt neue Tags für Amazon Elastic Compute Cloud (Amazon EC2) -Instances oder AWS Systems Manager verwaltete Instances.

**Anmerkung**  
Die Aktion `aws:createTags` unterstützt die automatische Drosselungswiederholung. Weitere Informationen finden Sie unter [Konfigurieren der automatischen Wiederholung für gedrosselte Vorgänge](automation-throttling-retry.md).

**Input**  
Diese Aktion unterstützt die meisten Amazon EC2-`CreateTags` und Systems Manager `AddTagsToResource`-Parameter. Weitere Informationen erhalten Sie unter [CreateTags](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/api_createtags.html) und [AddTagsToResource](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/api_addtagstoresource.html).

Das folgende Beispiel zeigt, wie Sie ein Amazon Machine Image (AMI) und eine Instance als Produktionsressourcen für eine bestimmte Abteilung taggen.

------
#### [ YAML ]

```
name: createTags
action: aws:createTags
maxAttempts: 3
onFailure: Abort
inputs:
  ResourceType: EC2
  ResourceIds:
  - ami-9a3768fa
  - i-02951acd5111a8169
  Tags:
  - Key: production
    Value: ''
  - Key: department
    Value: devops
```

------
#### [ JSON ]

```
{
    "name": "createTags",
    "action": "aws:createTags",
    "maxAttempts": 3,
    "onFailure": "Abort",
    "inputs": {
        "ResourceType": "EC2",
        "ResourceIds": [
            "ami-9a3768fa",
            "i-02951acd5111a8169"
        ],
        "Tags": [
            {
                "Key": "production",
                "Value": ""
            },
            {
                "Key": "department",
                "Value": "devops"
            }
        ]
    }
}
```

------

ResourceIds  
Die IDs der Ressource(n), die getaggt werden soll(en). Wenn der Ressourcentyp nicht „EC2“ lautet, kann dieses Feld nur ein einzelnes Element enthalten.  
Typ: StringList  
Erforderlich: Ja

Tags (Markierungen)  
Die Tags, die der/den Ressource(n) zugeordnet werden sollen.  
Typ: Liste von Karten  
Erforderlich: Ja

ResourceType  
Der Typ der Ressource(n), die getaggt werden soll(en). Wenn nichts angegeben ist, wird der Standardwert „EC2“ verwendet.  
Typ: Zeichenfolge  
Erforderlich: Nein  
Zulässige Werte: `EC2` \$1 `ManagedInstance` \$1 `MaintenanceWindow` \$1 `Parameter`

**Ausgabe**  
Keine

# `aws:deleteImage` - Löschen eines Amazon Machine Image


Löschen Sie das angegebene Amazon Machine Image (AMI) und alle dazugehörigen Snapshots.

**Anmerkung**  
Die Aktion `aws:deleteImage` unterstützt die automatische Drosselungswiederholung. Weitere Informationen finden Sie unter [Konfigurieren der automatischen Wiederholung für gedrosselte Vorgänge](automation-throttling-retry.md).

**Input**  
Diese Aktion unterstützt nur einen Parameter. Weitere Informationen finden Sie in der Dokumentation zu [DeregisterImage](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeregisterImage.html)und [DeleteSnapshot](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_DeleteSnapshot.html).

------
#### [ YAML ]

```
name: deleteMyImage
action: aws:deleteImage
maxAttempts: 3
timeoutSeconds: 180
onFailure: Abort
inputs:
  ImageId: ami-12345678
```

------
#### [ JSON ]

```
{
    "name": "deleteMyImage",
    "action": "aws:deleteImage",
    "maxAttempts": 3,
    "timeoutSeconds": 180,
    "onFailure": "Abort",
    "inputs": {
        "ImageId": "ami-12345678"
    }
}
```

------

ImageId  
Die ID des Image, das zerstört werden soll.  
Typ: Zeichenfolge  
Erforderlich: Ja

**Ausgabe**  
Keine

# `aws:deleteStack`— Löscht einen CloudFormation Stapel


Löscht einen AWS CloudFormation Stapel.

**Anmerkung**  
Die Aktion `aws:deleteStack` unterstützt die automatische Drosselungswiederholung. Weitere Informationen finden Sie unter [Konfigurieren der automatischen Wiederholung für gedrosselte Vorgänge](automation-throttling-retry.md).

**Eingabe**

------
#### [ YAML ]

```
name: deleteStack
action: aws:deleteStack
maxAttempts: 1
onFailure: Abort
inputs:
  StackName: "{{stackName}}"
```

------
#### [ JSON ]

```
{
   "name":"deleteStack",
   "action":"aws:deleteStack",
   "maxAttempts":1,
   "onFailure":"Abort",
   "inputs":{
      "StackName":"{{stackName}}"
   }
}
```

------

ClientRequestToken  
Ein eindeutiger Bezeichner für diese `DeleteStack`-Anfrage. Geben Sie dieses Token an, wenn Sie beabsichtigen, Anfragen erneut zu versuchen, damit das System CloudFormation weiß, dass Sie nicht versuchen, einen Stack mit demselben Namen zu löschen. Sie können `DeleteStack`-Anfragen wiederholen, um zu verifizieren, ob CloudFormation sie empfangen hat.  
Typ: Zeichenfolge  
Längenbeschränkungen: Minimale Länge beträgt 1 Zeichen. Maximale Länge beträgt 128 Zeichen.  
Muster: [a-zA-Z][-a-zA-Z0-9]\$1  
Erforderlich: Nein

RetainResources.Mitglied.N  
Diese Eingabe gilt nur für Stacks im Status `DELETE_FAILED`. Eine Liste logischer Ressourcen IDs für die Ressourcen, die Sie behalten möchten. CloudFormation Löscht beim Löschen den Stapel, löscht jedoch nicht die zurückbehaltenen Ressourcen.  
Das Aufbewahren der Ressourcen ist nützlich, wenn Sie eine Ressource nicht löschen können, wie etwa einen nicht leeren S3-Bucket, Sie aber den Stack löschen möchten.  
Typ: Zeichenfolge-Array  
Erforderlich: Nein

RoleARN  
Der Amazon-Ressourcenname (ARN) einer AWS Identity and Access Management (IAM) -Rolle, die die Erstellung des Stacks CloudFormation übernimmt. CloudFormation verwendet die Anmeldeinformationen der Rolle, um in Ihrem Namen Anrufe zu tätigen. CloudFormation verwendet diese Rolle immer für alle future Operationen auf dem Stack. Solange Benutzer berechtigt sind, auf dem Stack zu arbeiten, CloudFormation verwendet diese Rolle auch dann, wenn die Benutzer nicht berechtigt sind, sie weiterzugeben. Stellen Sie sicher, dass die Rolle die geringstmögliche Menge an Berechtigungen gewährt.   
Wenn Sie keinen Wert angeben, CloudFormation verwendet die Rolle, die zuvor dem Stack zugeordnet war. Wenn keine Rolle verfügbar ist, CloudFormation verwendet eine temporäre Sitzung, die anhand Ihrer Benutzeranmeldedaten generiert wird.   
Typ: Zeichenfolge  
Längenbeschränkungen: Minimale Länge von 20. Maximale Länge beträgt 2048 Zeichen.  
Erforderlich: Nein

StackName  
Der Name oder die eindeutige Stack-ID, die dem Stack zugeordnet ist.  
Typ: Zeichenfolge  
Erforderlich: Ja

## Sicherheitsüberlegungen


Bevor Sie die Aktion `aws:deleteStack` verwenden können, müssen Sie folgende Richtlinie der IAM-Automation-Assume-Role zuweisen. Weitere Informationen über die Übernahmerolle finden Sie unter [Aufgabe 1: Erstellen einer Servicerolle für Automation](automation-setup-iam.md#create-service-role). 

------
#### [ JSON ]

****  

```
{
   "Version":"2012-10-17",		 	 	 
   "Statement":[
      {
         "Effect":"Allow",
         "Action":[
            "sqs:*",
            "cloudformation:DeleteStack",
            "cloudformation:DescribeStacks"
         ],
         "Resource":"*"
      }
   ]
}
```

------

# `aws:executeAutomation` - Führen Sie eine weitere Automatisierung durch


Führt eine sekundäre Automatisierung durch Aufrufen eines sekundären Runbooks aus. Mit dieser Aktion können Sie Runbooks für die gängigsten Vorgänge erstellen und während einer Automatisierung auf diese Runbooks verweisen. Mit dieser Aktion können Sie Ihre Runbooks vereinfachen, indem Sie die Notwendigkeit für wiederholte Schritte bei ähnlichen Runboks entfernen.

Die sekundäre Automatisierung wird im Kontext des Benutzers ausgeführt, der die primäre Automatisierung gestartet hat. Das bedeutet, dass die sekundäre Automatisierung dieselbe AWS Identity and Access Management (IAM) Rolle oder denselben Benutzer verwendet wie der Benutzer, der die erste Automatisierung gestartet hat.

**Wichtig**  
Wenn Sie Parameter in einer sekundären Automatisierung festlegen, die eine Übernahmerolle verwenden (eine Rolle, die die iam:passRole-Richtlinie verwendet), muss der Benutzer oder die Rolle, der/die die primäre Automatisierung gestartet hat, über die Berechtigung zur Weitergabe der Übernahmerolle an die sekundäre Automatisierung verfügen. Weitere Informationen zum Einrichten einer Übernahmerolle für Automation finden Sie unter [Erstellen Sie die Servicerollen für Automation mithilfe der Konsole](automation-setup-iam.md).

**Eingabe**

------
#### [ YAML ]

```
name: Secondary_Automation
action: aws:executeAutomation
maxAttempts: 3
timeoutSeconds: 3600
onFailure: Abort
inputs:
  DocumentName: secondaryAutomation
  RuntimeParameters:
    instanceIds:
    - i-1234567890abcdef0
```

------
#### [ JSON ]

```
{
   "name":"Secondary_Automation",
   "action":"aws:executeAutomation",
   "maxAttempts":3,
   "timeoutSeconds":3600,
   "onFailure":"Abort",
   "inputs":{
      "DocumentName":"secondaryAutomation",
      "RuntimeParameters":{
         "instanceIds":[
            "i-1234567890abcdef0"
         ]
      }
   }
}
```

------

DocumentName  
Der Name des sekundären Runbooks, das während des Schritts ausgeführt werden soll. Geben Sie für Runbooks derselben AWS-Konto Kategorie den Runbook-Namen an. Geben Sie für Runbooks, die von einem anderen aus gemeinsam genutzt wurden AWS-Konto, den Amazon-Ressourcennamen (ARN) des Runbooks an. Weitere Informationen zur Verwendung von freigegebenen Runbooks finden Sie unter [Verwenden von freigegebenen SSM-Dokumenten](documents-ssm-sharing.md#using-shared-documents).  
Typ: Zeichenfolge  
Erforderlich: Ja

DocumentVersion  
Die Version des sekundären Runbooks, das ausgeführt werden soll. Falls nicht festgelegt, führt Automation die Standardrunbookversion aus.  
Typ: Zeichenfolge  
Erforderlich: Nein

MaxConcurrency  
Die maximale Anzahl von Zielen, für die diese Aufgabe parallel ausgeführt werden dürfen. Sie können eine Zahl, z. B. 10, oder einen Prozentsatz, z. B. 10 %, angeben.  
Typ: Zeichenfolge  
Erforderlich: Nein

MaxErrors  
Die Anzahl der Fehler, die zulässig sind, bevor das System die Automatisierung auf zusätzlichen Zielen stoppt. Sie können entweder eine absolute Anzahl an Fehlern, z. B. 10, oder einen Prozentsatz des festgelegten Ziels, beispielsweise 10 % festlegen. Wenn Sie z. B. 3 angeben, führt das System keine Automatisierung mehr aus, wenn der vierte Fehler empfangen wird. Wenn Sie 0 angeben, führt das System keine weitere Automatisierung auf zusätzlichen Zielen aus, nachdem das erste Fehlerergebnis zurückgegeben wird. Wenn Sie eine Automatisierung auf 50 Ressourcen ausführen und `MaxErrors` auf 10 % setzen, hört das System auf, dass die Automatisierung auf zusätzlichen Zielen auszuführen, sobald der sechste Fehler empfangen wurde.  
Automatisierung, die bereits eine ausgeführt werden, wenn der `MaxErrors`-Fehlerschwellenwert erreicht wird, können abgeschlossen werden, einige dieser Automatisierungen können jedoch dennoch fehlschlagen. Wenn Sie sicherstellen müssen, dass es nicht mehr fehlgeschlagene Automatisierungen als die angegebenen `MaxErrors` geben wird, setzen Sie `MaxConcurrency` auf 1, sodass die Automatisierungen nacheinander ausgeführt werden.  
Typ: Zeichenfolge  
Erforderlich: Nein

RuntimeParameters  
Erforderliche Parameter für das sekundäre Runbook. Das Mapping verwendet das folgende Format: \$1"parameter1" : "value1", "parameter2" : "value2" \$1  
Typ: Zuordnung  
Erforderlich: Nein

Tags (Markierungen)  
Optionale Metadaten, die Sie einer Ressource zuweisen. Sie können maximal fünf Tags für eine Automatisierung festlegen.  
Typ: MapList  
Erforderlich: Nein

TargetLocations  
Ein Standort ist eine Kombination aus AWS-Regionen und/oder AWS-Konten dem Ort, an dem Sie die Automatisierung ausführen möchten. Es muss eine Mindestanzahl von 1 Element angegeben werden und eine maximale Anzahl von 100 Elementen kann angegeben werden. Wenn Sie einen Wert für diesen Parameter angeben, werden die Ausgaben nicht an die übergeordnete Automatisierung zurückgegeben. Falls erforderlich, müssen Sie nachfolgende API-Vorgänge aufrufen, um die Ausgabe von untergeordneten Automatisierungen abzurufen.  
Typ: MapList  
Erforderlich: Nein

TargetMaps  
Eine Liste von Schlüssel-Wert-Zuweisungen von Dokumentparametern zu Zielressourcen. Sowohl `Targets` als auch `TargetMaps` kann nicht zusammen angegeben werden.   
Typ: MapList  
Erforderlich: Nein

TargetParameterName  
Der Name des Parameters, der als Zielressource für die ratengesteuerte Automatisierung verwendet wird. Erforderlich, wenn Sie `Targets` angeben.  
Typ: Zeichenfolge  
Erforderlich: Nein

Ziele  
Eine Liste von Schlüssel-Wert-Zuordnungen zu Zielressourcen. Erforderlich, wenn Sie `TargetParameterName` angeben.  
Typ: MapList  
Erforderlich: NeinAusgabe

Ausgabe  
Die von der sekundären Automatisierung generierte Ausgabe. Sie können auf die Ausgabe verweisen, indem Sie das folgende Format verwenden: *Secondary\$1Automation\$1Step\$1Name* .Output  
Typ: StringList  
Ein Beispiel:  

```
- name: launchNewWindowsInstance
  action: 'aws:executeAutomation'
  onFailure: Abort
  inputs:
    DocumentName: launchWindowsInstance
  nextStep: getNewInstanceRootVolume
- name: getNewInstanceRootVolume
  action: 'aws:executeAwsApi'
  onFailure: Abort
  inputs:
    Service: ec2
    Api: DescribeVolumes
    Filters:
    - Name: attachment.device
      Values:
      - /dev/sda1
    - Name: attachment.instance-id
      Values:
      - '{{launchNewWindowsInstance.Output}}'
  outputs:
  - Name: rootVolumeId
    Selector: '$.Volumes[0].VolumeId'
    Type: String
  nextStep: snapshotRootVolume
- name: snapshotRootVolume
  action: 'aws:executeAutomation'
  onFailure: Abort
  inputs:
    DocumentName: AWS-CreateSnapshot
    RuntimeParameters:
    VolumeId:
    - '{{getNewInstanceRootVolume.rootVolumeId}}'
    Description:
    - 'Initial root snapshot for {{launchNewWindowsInstance.Output}}'
```

ExecutionId  
Die ID der sekundären Automatisierung.  
Typ: Zeichenfolge

Status  
Der Status der sekundären Automatisierung.  
Typ: Zeichenfolge

# `aws:executeAwsApi`— AWS API-Operationen aufrufen und ausführen


Ruft AWS API-Operationen auf und führt sie aus. Die meisten API-Operationen werden unterstützt, es wurden jedoch nicht alle API-Operationen getestet. Streaming-API-Operationen, wie der [GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/RESTObjectGET.html)Vorgang, werden nicht unterstützt. Wenn Sie sich nicht sicher sind, ob einen API-Vorgang, den Sie verwenden möchten, eine Streaming-Operation ist, lesen Sie die [Boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/index.html)-Dokumentation für den Service, um festzustellen, ob eine API-Streaming-Eingaben oder -Ausgaben erfordert. Wir aktualisieren regelmäßig die von dieser Aktion verwendete Boto3-Version. Nach der Veröffentlichung einer neuen Boto3-Version kann es jedoch bis zu mehreren Wochen dauern, bis sich die Änderungen in dieser Aktion niederschlagen. Jede `aws:executeAwsApi`-Aktion kann bis zu einer maximalen Dauer von 25 Sekunden dauern. Weitere Beispiele zur Verwendung dieser Aktion finden Sie unter [Weitere Runbook-Beispiele](automation-document-examples.md).

**Anmerkung**  
Die Aktion `aws:executeAwsApi` unterstützt die automatische Drosselungswiederholung. Weitere Informationen finden Sie unter [Konfigurieren der automatischen Wiederholung für gedrosselte Vorgänge](automation-throttling-retry.md).

**Eingaben**  
Eingaben werden von der ausgewählten API-Operation bestimmt. 

------
#### [ YAML ]

```
action: aws:executeAwsApi
inputs:
  Service: The official namespace of the service
  Api: The API operation or method name
  API operation inputs or parameters: A value
outputs: # These are user-specified outputs
- Name: The name for a user-specified output key
  Selector: A response object specified by using jsonpath format
  Type: The data type
```

------
#### [ JSON ]

```
{
   "action":"aws:executeAwsApi",
   "inputs":{
      "Service":"The official namespace of the service",
      "Api":"The API operation or method name",
      "API operation inputs or parameters":"A value"
   },
   "outputs":[ These are user-specified outputs
      {
         "Name":"The name for a user-specified output key",
         "Selector":"A response object specified by using JSONPath format",
         "Type":"The data type"
      }
   ]
}
```

------

Service  
Der AWS-Service Namespace, der den API-Vorgang enthält, den Sie ausführen möchten. Eine Liste der unterstützten AWS-Service Namespaces finden Sie unter [Verfügbare](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/index.html) Dienste von. AWS SDK für Python (Boto3) Der Namespace befindet sich im Abschnitt **Client** . Beispielsweise lautet der Namespace für Systems Manager `ssm`. Der Namespace für Amazon Elastic Compute Cloud (Amazon EC2) ist `ec2`.  
Typ: Zeichenfolge  
Erforderlich: Ja

Api  
Der Name der API-Operation, die Sie ausführen möchten. Sie können die API-Operationen (auch als Methoden bezeichnet) anzeigen, indem Sie einen Service in der linken Navigationsleiste auf der folgenden [Service-Referenzen](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/index.html)-Seite auswählen. Wählen Sie eine Methode im Abschnitt **Client** für den Service, den Sie aufrufen möchten. Beispielsweise werden alle API-Vorgänge (Methoden) für Amazon Relational Database Service (Amazon RDS) auf der folgenden Seite aufgelistet: [Amazon RDS-Methoden](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rds.html).  
Typ: Zeichenfolge  
Erforderlich: Ja

API-Operation-Eingaben  
Eine oder mehrere API-Eingaben. Sie können die verfügbaren Eingaben (auch als Parameter bezeichnet) anzeigen, indem Sie einen Service in der linken Navigationsleiste auf der folgenden [Service-Referenzen](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/index.html)-Seite auswählen. Wählen Sie eine Methode im Abschnitt **Client** für den Service, den Sie aufrufen möchten. Beispielsweise sind alle Methoden für Amazon RDS auf der folgenden Seite aufgeführt: [Amazon RDS-Methoden](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rds.html). ******Wählen Sie die Methode [describe\$1db\$1instances](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rds.html#RDS.Client.describe_db_instances) und scrollen Sie nach unten, um die verfügbaren Parameter wie Identifier, Name und Values zu sehen. DBInstance******  

```
inputs:
  Service: The official namespace of the service
  Api: The API operation name
  API input 1: A value
  API Input 2: A value
  API Input 3: A value
```

```
"inputs":{
      "Service":"The official namespace of the service",
      "Api":"The API operation name",
      "API input 1":"A value",
      "API Input 2":"A value",
      "API Input 3":"A value"
}
```
Typ: Abhängig von der gewählten API-Operation  
Erforderlich: Ja

**Outputs**  
Die Ausgaben werden vom Benutzer basierend auf der Antwort des ausgewählten API-Vorgangs angegeben.

Name  
Ein Name für die Ausgabe.  
Typ: Zeichenfolge  
Erforderlich: Ja

Selector  
Das JSONPath zu einem bestimmten Attribut im Antwortobjekt. Sie können die Antwortobjekte anzeigen indem Sie einen Service in der linken Navigationsleiste auf der folgenden [Service-Referenzen](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/index.html)-Seite auswählen. Wählen Sie eine Methode im Abschnitt **Client** für den Service, den Sie aufrufen möchten. Beispielsweise sind alle Methoden für Amazon RDS auf der folgenden Seite aufgeführt: [Amazon RDS-Methoden](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rds.html). **Wählen Sie die Methode [describe\$1db\$1instances](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rds.html#RDS.Client.describe_db_instances) und scrollen Sie nach unten zum Abschnitt Antwortstruktur.** **DBInstances**ist als Antwortobjekt aufgeführt.  
Typ: Integer, Boolean, String, StringList, oder StringMap MapList  
Erforderlich: Ja

Typ  
Der Datentyp für das Antwortelement.  
Typ: Unterschiedlich  
Erforderlich: Ja

# `aws:executeScript` - Führen Sie ein Skript aus


Führt das bereitgestellte Python- oder PowerShell Skript mit der angegebenen Laufzeit und dem angegebenen Handler aus. Jede `aws:executeScript`-Aktion kann bis zu einer maximalen Dauer von 600 Sekunden (10 Minuten) laufen. Sie können die Zeitüberschreitung über den Parameter `timeoutSeconds` für einen `aws:executeScript`-Schritt limitieren.

Verwenden Sie Rückgabe-Anweisungen in Ihrer Funktion, um Ihrer Ausgabenutzlast Ausgaben hinzuzufügen. Für Beispiele zum Definieren von Ausgaben für Ihre `aws:executeScript`-Aktion, siehe [Beispiel 2: Skriptbasiertes Runbook](automation-authoring-runbooks-scripted-example.md). Sie können auch die Ausgabe von `aws:executeScript` Aktionen in Ihren Runbooks an die von Ihnen angegebene Amazon CloudWatch Logs-Protokollgruppe senden. Weitere Informationen finden Sie unter [Ausgabe von Automatisierungsaktionen mit CloudWatch Protokollen protokollieren](automation-action-logging.md).

Wenn Sie die Ausgabe von `aws:executeScript` Aktionen an CloudWatch Logs senden möchten oder wenn die Skripts, die Sie für `aws:executeScript` Aktionen angeben, AWS API-Operationen aufrufen, ist für die Ausführung des Runbooks immer eine AWS Identity and Access Management (IAM-) Service-Rolle (oder Übernahme einer Rolle) erforderlich.

**Anmerkung**  
Die Aktion `aws:executeScript` unterstützt die automatische Drosselungswiederholung nicht. Wenn Ihr Skript AWS API-Aufrufe durchführt, die möglicherweise gedrosselt werden, müssen Sie Ihre eigene Wiederholungslogik in Ihren Skriptcode implementieren.

Die `aws:executeScript` Aktion enthält die folgenden PowerShell vorinstallierten Core-Module:
+ Microsoft. PowerShell. Gastgeber
+ Microsoft. PowerShell. Verwaltung
+ Microsoft. PowerShell. Sicherheit
+ Microsoft. PowerShell. Hilfsprogramm
+ PackageManagement
+ PowerShellGet

Um PowerShell Core-Module zu verwenden, die nicht vorinstalliert sind, muss Ihr Skript das Modul mit der `-Force` Markierung installieren, wie im folgenden Befehl gezeigt. Das `AWSPowerShell.NetCore`-Modul wird nicht unterstützt. *ModuleName*Ersetzen Sie es durch das Modul, das Sie installieren möchten.

```
Install-Module ModuleName -Force
```

Um PowerShell Core-Cmdlets in Ihrem Skript zu verwenden, empfehlen wir die Verwendung der `AWS.Tools` Module, wie in den folgenden Befehlen gezeigt. Ersetzen Sie jeden *example resource placeholder* durch Ihre Informationen.
+ Amazon S3 Cmdlets.

  ```
  Install-Module AWS.Tools.S3 -Force
  Get-S3Bucket -BucketName amzn-s3-demo-bucket
  ```
+ Amazon EC2 Cmdlets.

  ```
  Install-Module AWS.Tools.EC2 -Force
  Get-EC2InstanceStatus -InstanceId instance-id
  ```
+ Allgemeine oder dienstunabhängige AWS Tools for Windows PowerShell Cmdlets.

  ```
  Install-Module AWS.Tools.Common -Force
  Get-AWSRegion
  ```

Wenn Ihr Skript zusätzlich zur Verwendung von PowerShell Core-Cmdlets neue Objekte initialisiert, müssen Sie das Modul auch importieren, wie im folgenden Befehl gezeigt.

```
Install-Module AWS.Tools.EC2 -Force
Import-Module AWS.Tools.EC2

$tag = New-Object Amazon.EC2.Model.Tag
$tag.Key = "Tag"
$tag.Value = "TagValue"

New-EC2Tag -Resource i-02573cafcfEXAMPLE -Tag $tag
```

Beispiele für die Installation und den Import von `AWS.Tools` Modulen und die Verwendung von PowerShell Core-Cmdlets in Runbooks finden Sie unter. [Visuelle Designerfahrung für Automation-Runbooks](automation-visual-designer.md)

**Input**  
Geben Sie die zum Ausführen Ihres Skripts erforderlichen Informationen an. Ersetzen Sie jeden *example resource placeholder* durch Ihre Informationen.

**Anmerkung**  
Der Anhang für ein Python-Skript kann eine .py-Datei oder eine .zip-Datei sein, die das Skript enthält. PowerShell Skripten müssen in ZIP-Dateien gespeichert werden.

------
#### [ YAML ]

```
action: "aws:executeScript"
inputs: 
 Runtime: runtime
 Handler: "functionName"
 InputPayload: 
  scriptInput: '{{parameterValue}}'
 Script: |-
   def functionName(events, context):
   ...
 Attachment: "scriptAttachment.zip"
```

------
#### [ JSON ]

```
{
    "action": "aws:executeScript",
    "inputs": {
        "Runtime": "runtime",
        "Handler": "functionName",
        "InputPayload": {
            "scriptInput": "{{parameterValue}}"
        },
        "Attachment": "scriptAttachment.zip"
    }
}
```

------

Laufzeit  
Die Laufzeitsprache, die für die Ausführung des bereitgestellten Skripts verwendet werden soll. `aws:executeScript`unterstützt die Laufzeiten in der folgenden Tabelle.      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/systems-manager/latest/userguide/automation-action-executeScript.html)
Typ: Zeichenfolge  
Erforderlich: Ja  
Für Python-Laufzeiten bietet die Umgebung 512 MB Arbeitsspeicher und 512 MB Speicherplatz. Für PowerShell Laufzeiten stellt die Umgebung 1024 MB Arbeitsspeicher und 512 MB Festplattenspeicher zur Verfügung.

Handler  
Der Name Ihrer Funktion. Sie müssen sicherstellen, dass die im Handler definierte Funktion über zwei Parameter verfügt: `events` und `context`. Die PowerShell Laufzeit unterstützt diesen Parameter nicht.  
Typ: Zeichenfolge  
Erforderlich: Ja (Python) \$1 Nicht unterstützt (PowerShell)

InputPayload  
Ein JSON- oder YAML-Objekt, das an den ersten Parameter des Handlers übergeben wird. Dies kann verwendet werden, um Eingabedaten an das Skript zu übergeben.  
Typ: Zeichenfolge  
Erforderlich: Nein  

```
description: Tag an instance
schemaVersion: '0.3'
assumeRole: '{{AutomationAssumeRole}}'
parameters:
    AutomationAssumeRole:
        type: String
        description: '(Required) The Amazon Resource Name (ARN) of the IAM role that allows Automation to perform the actions on your behalf. If no role is specified, Systems Manager Automation uses your IAM permissions to operate this runbook.'
    InstanceId:
        type: String
        description: (Required) The ID of the EC2 instance you want to tag.
mainSteps:
  - name: tagInstance
    action: 'aws:executeScript'
    inputs:
        Runtime: "python3.11"
        Handler: tagInstance
        InputPayload:
            instanceId: '{{InstanceId}}'
        Script: |-
          def tagInstance(events,context):
            import boto3

            #Initialize client
            ec2 = boto3.client('ec2')
            instanceId = events['instanceId']
            tag = {
                "Key": "Env",
                "Value": "ExamplePython"
            }
            print(f"Adding tag {tag} to instance id {instanceId}")
            ec2.create_tags(
                Resources=[instanceId],
                Tags=[tag]
            )
            return tag
    outputs:
      - Type: String
        Name: TagKey
        Selector: $.Payload.Key
outputs:
  - tagInstance.TagKey
```

```
description: Tag an instance
schemaVersion: '0.3'
assumeRole: '{{AutomationAssumeRole}}'
parameters:
  AutomationAssumeRole:
    type: String
    description: (Required) The Amazon Resource Name (ARN) of the IAM role that allows Automation to perform the actions on your behalf. If no role is specified, Systems Manager Automation uses your IAM permissions to operate this runbook.
  InstanceId:
    type: String
    description: (Required) The ID of the EC2 instance you want to tag.
mainSteps:
  - name: tagInstance
    action: aws:executeScript
    isEnd: true
    inputs:
      Runtime: PowerShell 7.4
      InputPayload:
        instanceId: '{{InstanceId}}'
      Script: |-
        Install-Module AWS.Tools.EC2 -Force
        Import-Module AWS.Tools.EC2

        $input = $env:InputPayload | ConvertFrom-Json

        $tag = New-Object Amazon.EC2.Model.Tag
        $tag.Key = "Env"
        $tag.Value = "ExamplePowerShell"

        Write-Information "Adding tag key: $($tag.Key) and value: $($tag.Value) to instance id $($input.instanceId)"
        New-EC2Tag -Resource $input.instanceId -Tag $tag

        return $tag
    outputs:
      - Type: String
        Name: TagKey
        Selector: $.Payload.Key
outputs:
  - tagInstance.TagKey
```

Script  
Ein eingebettetes Skript, das während der Automatisierung ausgeführt werden soll.  
Typ: Zeichenfolge  
Erforderlich: Nein (Python) \$1 Ja (PowerShell)

Attachment  
Der Name einer eigenständigen Skriptdatei oder einer ZIP-Datei, die von der Aktion aufgerufen werden kann. Geben Sie denselben Wert wie den `Name` der Dokument-Anhangsdatei an, den Sie im Anforderungsparameter `Attachments` angeben. Weitere Informationen finden Sie unter [Anhänge](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_CreateDocument.html#systemsmanager-CreateDocument-request-Attachments) in der *API-Referenz für AWS Systems Manager *. Wenn Sie ein Skript mithilfe einer Anlage bereitstellen, müssen Sie auch einen `files`-Abschnitt in den Elementen der obersten Ebene Ihres Runbooks definieren. Weitere Informationen finden Sie unter [Schema der Version 0.3](documents-schemas-features.md#automation-doc-syntax-examples).  
Um eine Datei für Python aufzurufen, verwenden Sie das `filename.method_name`-Format in `Handler`.   
Der Anhang für ein Python-Skript kann eine .py-Datei oder eine .zip-Datei sein, die das Skript enthält. PowerShell Skripten müssen in ZIP-Dateien gespeichert werden.
Wenn Sie Python-Bibliotheken in Ihren Anhang einfügen, empfehlen wir, eine leere `__init__.py`-Datei in jedem Modulverzeichnis hinzuzufügen. Auf diese Weise können Sie die Module aus der Bibliothek in Ihrem Anhang innerhalb Ihres Skriptinhalts importieren. Beispiel: `from library import module`  
Typ: Zeichenfolge  
Erforderlich: NeinAusgabe

Nutzlast  
Die JSON-Darstellung des Objekts, das von Ihrer Funktion zurückgegeben wird. Bis zu 100 KB werden zurückgegeben. Wenn Sie eine Liste ausgeben, werden maximal 100 Elemente zurückgegeben.

## Verwenden von Anhängen mit aws:executeScript


Anhänge bieten eine leistungsstarke Möglichkeit, komplexe Skripts, mehrere Module und externe Abhängigkeiten zu verpacken und für `aws:executeScript`-Aktionen wiederzuverwenden. Sie können Anhänge in folgenden Fällen verwenden:
+ Packen Sie mehrere Python-Module oder PowerShell -Skripte zusammen.
+ Wiederverwenden derselben Skriptlogik in mehreren Runbooks
+ Einfügen externer Bibliotheken oder Abhängigkeiten in Skripts
+ Runbook-Definition übersichtlich halten, indem Sie Elemente komplexer Skriptlogik trennen
+ Freigeben von Skriptpaketen für Teams oder Automatisierungs-Workflows

### Struktur und Verpackung von Anhängen


Sie können einzelne Dateien oder ZIP-Pakete mit mehreren Dateien anhängen. Die Struktur hängt von Ihrem Anwendungsfall ab:

**Einzelne Dateianhänge**  
Bei einfachen Skripten können Sie eine einzelne `.py` Datei (Python) oder eine `.zip` Datei, die ein einzelnes PowerShell Skript enthält, anhängen.

**Pakete mit mehreren Modulen**  
Für komplexe Automatisierungen, die mehrere Module erfordern, erstellen Sie ein ZIP-Paket mit der folgenden empfohlenen Struktur:

```
my-automation-package.zip
├── main.py                    # Entry point script
├── utils/
│   ├── __init__.py           # Required for Python module imports
│   ├── helper_functions.py   # Utility functions
│   └── aws_operations.py     # AWS-specific operations
├── config/
│   ├── __init__.py
│   └── settings.py           # Configuration settings
└── requirements.txt          # Optional: document dependencies
```

**Wichtig**  
Für Python-Pakete müssen Sie in jedes Verzeichnis, das Python-Module enthält, eine leere `__init__.py`-Datei einfügen. Dadurch können Sie Module mit einer standardmäßigen Python-Importsyntax importieren, z. B. `from utils import helper_functions`.

**PowerShell Struktur des Pakets**  
PowerShell Anlagen müssen in ZIP-Dateien mit der folgenden Struktur gepackt werden:

```
my-powershell-package.zip
├── Main.ps1                  # Entry point script
├── Modules/
│   ├── HelperFunctions.ps1   # Utility functions
│   └── AWSOperations.ps1     # AWS-specific operations
└── Config/
    └── Settings.ps1          # Configuration settings
```

### Erstellen von Runbooks mit Anhängen


Gehen Sie wie folgt vor, um Runbooks zu erstellen, die Anhänge verwenden:

1. **Anhang in Amazon S3 hochladen**

   Laden Sie Ihre Skriptdatei oder Ihr ZIP-Paket in einen S3-Bucket hoch, auf den Ihre Automatisierungsrolle Zugriff hat. Notieren Sie den S3-URI für den nächsten Schritt.

   ```
   aws s3 cp my-automation-package.zip s3://my-automation-bucket/scripts/
   ```

1. **Prüfsumme des Anhangs berechnen**

   Berechnen Sie die SHA-256-Prüfsumme Ihrer Anhangsdatei zur Sicherheitsüberprüfung:

   ```
   # Linux/macOS
   shasum -a 256 my-automation-package.zip
   
   # Windows PowerShell
   Get-FileHash -Algorithm SHA256 my-automation-package.zip
   ```

1. **Dateibereich im Runbook definieren**

   Fügen Sie auf der obersten Ebene Ihres Runbooks einen `files`-Abschnitt hinzu, der auf Ihren Anhang verweist:

   ```
   files:
     my-automation-package.zip:
       checksums:
         sha256: "your-calculated-checksum-here"
   ```

1. **Im executeScript-Schritt auf den Anhang verweisen**

   Verwenden Sie den Parameter `Attachment`, um auf die hochgeladene Datei zu verweisen:

   ```
   - name: runMyScript
     action: aws:executeScript
     inputs:
       Runtime: python3.11
       Handler: main.process_data
       Attachment: my-automation-package.zip
       InputPayload:
         inputData: "{{InputParameter}}"
   ```

## Beispiele für aws:executeScript-Anhänge


Die folgenden Beispiele zeigen verschiedene Möglichkeiten, Anhänge mit der Aktion `aws:executeScript` zu verwenden.

### Beispiel 1: einzelner Dateianhang


In diesem Beispiel wird eine einzelne Python-Datei als Anhang verwendet, um EC2-Instance-Daten zu verarbeiten.

**Anhangsdatei: process\$1instance.py**  
Erstellen Sie eine Python-Datei mit folgendem Inhalt:

```
import boto3
import json

def process_instance_data(events, context):
    """Process EC2 instance data and return formatted results."""
    try:
        instance_id = events.get('instanceId')
        if not instance_id:
            raise ValueError("instanceId is required")
        
        ec2 = boto3.client('ec2')
        
        # Get instance details
        response = ec2.describe_instances(InstanceIds=[instance_id])
        instance = response['Reservations'][0]['Instances'][0]
        
        # Format the response
        result = {
            'instanceId': instance_id,
            'instanceType': instance['InstanceType'],
            'state': instance['State']['Name'],
            'availabilityZone': instance['Placement']['AvailabilityZone'],
            'tags': {tag['Key']: tag['Value'] for tag in instance.get('Tags', [])}
        }
        
        print(f"Successfully processed instance {instance_id}")
        return result
        
    except Exception as e:
        print(f"Error processing instance: {str(e)}")
        raise
```

**Vollständiges Runbook**  
Hier ist das vollständige Runbook, das den einzelnen Dateianhang verwendet:

```
description: Process EC2 instance data using single file attachment
schemaVersion: '0.3'
assumeRole: '{{AutomationAssumeRole}}'
parameters:
  AutomationAssumeRole:
    type: String
    description: (Required) IAM role for automation execution
  InstanceId:
    type: String
    description: (Required) EC2 instance ID to process

files:
  process_instance.py:
    checksums:
      sha256: "abc123def456..."

mainSteps:
  - name: processInstance
    action: aws:executeScript
    inputs:
      Runtime: python3.11
      Handler: process_instance.process_instance_data
      Attachment: process_instance.py
      InputPayload:
        instanceId: '{{InstanceId}}'
    outputs:
      - Type: StringMap
        Name: InstanceData
        Selector: $.Payload

outputs:
  - processInstance.InstanceData
```

### Beispiel 2: Paket mit mehreren Modulen


In diesem Beispiel wird ein ZIP-Paket, das mehrere Python-Module enthält, für komplexe S3-Bucket-Vorgänge verwendet.

**Paketstruktur**  
Erstellen Sie ein ZIP-Paket mit der folgenden Struktur:

```
s3-operations.zip
├── main.py
├── utils/
│   ├── __init__.py
│   ├── s3_helper.py
│   └── validation.py
└── config/
    ├── __init__.py
    └── settings.py
```

**main.py (Eintrittspunkt)**  
Das Hauptskript, das die Vorgänge orchestriert:

```
from utils.s3_helper import S3Operations
from utils.validation import validate_bucket_name
from config.settings import get_default_settings

def cleanup_s3_bucket(events, context):
    """Clean up S3 bucket based on specified criteria."""
    try:
        bucket_name = events.get('bucketName')
        max_age_days = events.get('maxAgeDays', 30)
        
        # Validate inputs
        if not validate_bucket_name(bucket_name):
            raise ValueError(f"Invalid bucket name: {bucket_name}")
        
        # Initialize S3 operations
        s3_ops = S3Operations()
        settings = get_default_settings()
        
        # Perform cleanup
        deleted_objects = s3_ops.delete_old_objects(
            bucket_name, 
            max_age_days,
            settings['dry_run']
        )
        
        result = {
            'bucketName': bucket_name,
            'deletedCount': len(deleted_objects),
            'deletedObjects': deleted_objects[:10],  # Return first 10 for brevity
            'dryRun': settings['dry_run']
        }
        
        print(f"Cleanup completed for bucket {bucket_name}")
        return result
        
    except Exception as e:
        print(f"Error during S3 cleanup: {str(e)}")
        raise
```

## Fehlerbehebung bei aws:executeScript-Anhängen


Beachten Sie die folgenden Informationen, um häufig auftretende Probleme mit `aws:executeScript`-Anhängen zu lösen:

**Modulimportfehler**  
Wenn Sie bei Paketen mit mehreren Modulen Importfehler erhalten:
+ Stellen Sie sicher, dass jedes Verzeichnis mit Python-Modulen eine leere `__init__.py`-Datei enthält.
+ Prüfen Sie, ob Ihre Importanweisungen der tatsächlichen Datei- und Verzeichnisstruktur im ZIP-Paket entsprechen.
+ Verwenden Sie konsistent relative Importe (z. B. `from .utils import helper`) oder absolute Importe (z. B. `from utils import helper`).

**Anhang kann nicht gefunden werden**  
Wenn Ihre Automatisierung den Anhang nicht finden kann:
+ Stellen Sie sicher, dass der `Attachment`-Parameterwert dem Schlüssel in Ihrem `files`-Abschnitt entspricht.
+ Vergewissern Sie sich, dass Ihr S3-Bucket-Pfad und Ihr Dateiname im `files`-Abschnitt korrekt sind.
+ Prüfen Sie, ob Ihre Automatisierungsrolle die Berechtigung `s3:GetObject` für den S3-Speicherort des Anhangs hat.
+ Stellen Sie sicher, dass die Prüfsumme in Ihrem Runbook mit der tatsächlichen Dateiprüfsumme übereinstimmt.

**Handler-Funktionsfehler**  
Wenn Fehler im Zusammenhang mit dem Handler auftreten:
+ Für Python: Verwenden Sie das Format `filename.function_name` im `Handler`-Parameter (z. B. `main.process_data`).
+ Sorgen Sie dafür, dass Ihre Handler-Funktion genau zwei Parameter akzeptiert: `events` und `context`.
+ Für PowerShell: Geben Sie keinen `Handler` Parameter an; das Skript wird direkt ausgeführt.

**Fehler bei der Skriptausführung**  
Wenn Ihr Skript während der Ausführung fehlschlägt:
+ Im Ausführungsverlauf der Automatisierung finden Sie detaillierte Fehlermeldungen und Stack-Traces.
+ Verwenden Sie `print()` Anweisungen (Python) oder `Write-Information` (PowerShell), um Debugging-Ausgaben hinzuzufügen.
+ Stellen Sie sicher, dass Ihrer Automatisierungsrolle alle erforderlichen AWS Berechtigungen erteilt wurden.
+ Testen Sie Ihre Skriptlogik lokal, bevor Sie sie als Anlage verpacken.

**Beendigungscodes und Fehlerbehandlung**  
Gehen Sie wie folgt vor, um Fehler zu bearbeiten und Beendigungscodes zurückzugeben:
+ In Python: Verwenden Sie `raise Exception("error message")`, um auf einen Skriptfehler hinzuweisen.
+ In PowerShell: Verwenden Sie `throw "error message"` oder`Write-Error`, um auf einen Fehler hinzuweisen.
+ Geben Sie strukturierte Daten aus Ihren Funktionen zurück, um detaillierte success/failure Informationen bereitzustellen.
+ Verwenden Sie try-catch-Blöcke, um Ausnahmen ordnungsgemäß zu bearbeiten und aussagekräftige Fehlermeldungen bereitzustellen.

# `aws:executeStateMachine`— Führen Sie eine AWS Step Functions Zustandsmaschine aus


Führt eine AWS Step Functions Zustandsmaschine aus.

**Anmerkung**  
Die Aktion `aws:executeStateMachine` unterstützt die automatische Drosselungswiederholung. Weitere Informationen finden Sie unter [Konfigurieren der automatischen Wiederholung für gedrosselte Vorgänge](automation-throttling-retry.md).

**Eingabe**

Diese Aktion unterstützt die meisten Parameter für den Step Functions [StartExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html)Functions-API-Vorgang.

**Erforderliche AWS Identity and Access Management (IAM-) Berechtigungen**
+ `states:DescribeExecution`
+ `states:StartExecution`
+ `states:StopExecution`

------
#### [ YAML ]

```
name: executeTheStateMachine
action: aws:executeStateMachine
inputs:
  stateMachineArn: StateMachine_ARN
  input: '{"parameters":"values"}'
  name: name
```

------
#### [ JSON ]

```
{
    "name": "executeTheStateMachine",
    "action": "aws:executeStateMachine",
    "inputs": {
        "stateMachineArn": "StateMachine_ARN",
        "input": "{\"parameters\":\"values\"}",
        "name": "name"
    }
}
```

------

stateMachineArn  
Der Amazon-Ressourcenname (ARN) der Step Functions State-Machine.  
Typ: Zeichenfolge  
Erforderlich: Ja

Name  
Der Name der Ausführung.  
Typ: Zeichenfolge  
Erforderlich: Nein

input  
Eine Zeichenfolge, die die JSON-Eingabedaten für die Ausführung enthält.  
Typ: Zeichenfolge  
Erforderlich: Nein

**Outputs**  
Die folgenden Ausgaben sind für diese Aktion vordefiniert.

executionArn  
Der ARN der Ausführung.  
Typ: Zeichenfolge

input  
Die Zeichenfolge, die die JSON-Eingabedaten der Ausführung enthält. Längenbeschränkungen gelten für die Nutzlastgröße und werden als Bytes in UTF-8-Codierung ausgedrückt.  
Typ: Zeichenfolge

Name  
Der Name der Ausführung.  
Typ: Zeichenfolge

output  
Die JSON-Ausgabedaten der Ausführung. Längenbeschränkungen gelten für die Nutzlastgröße und werden als Bytes in UTF-8-Codierung ausgedrückt.  
Typ: Zeichenfolge

startDate  
Das Datum, an dem die Ausführung gestartet wird.  
Typ: Zeichenfolge

stateMachineArn  
Der ARN des ausgeführten angegebenen Computers.  
Typ: Zeichenfolge

Status  
Der aktuelle Status der Ausführung.  
Typ: Zeichenfolge

stopDate  
Wenn die Ausführung bereits beendet wurde, das Datum, an dem die Ausführung beendet wurde.  
Typ: Zeichenfolge

# `aws:invokeWebhook` – Automation-Webhook-Integration aufrufen


Ruft die angegebene Automation-Webhook-Integration auf. Weitere Informationen zum Erstellen von Automation-Integrationen finden Sie unter [Erstellen von Webhook-Integrationen für Automation](creating-webhook-integrations.md).

**Anmerkung**  
Die Aktion `aws:invokeWebhook` unterstützt die automatische Drosselungswiederholung. Weitere Informationen finden Sie unter [Konfigurieren der automatischen Wiederholung für gedrosselte Vorgänge](automation-throttling-retry.md).

**Anmerkung**  
Um die `aws:invokeWebhook`-Aktion zu verwenden, muss Ihre Benutzer- oder Servicerolle die folgenden Aktionen zulassen:  
ssm: GetParameter
kms:Decrypt
Die Genehmigung für den `Decrypt` Vorgang AWS Key Management Service (AWS KMS) ist nur erforderlich, wenn Sie einen vom Kunden verwalteten Schlüssel verwenden, um den Parameter für Ihre Integration zu verschlüsseln.

**Input**  
Geben Sie die Informationen für die aufzurufende Automation-Integration an.

------
#### [ YAML ]

```
action: "aws:invokeWebhook"
inputs: 
 IntegrationName: "exampleIntegration"
 Body: "Request body"
```

------
#### [ JSON ]

```
{
    "action": "aws:invokeWebhook",
    "inputs": {
        "IntegrationName": "exampleIntegration",
        "Body": "Request body"
    }
}
```

------

IntegrationName  
Der Name der Automation-Integration. Beispiel, `exampleIntegration`. Die von Ihnen angegebene Integration muss bereits vorhanden sein.  
Typ: Zeichenfolge  
Erforderlich: Ja

Fließtext  
Die Nutzlast, die Sie beim Aufrufen der Webhook-Integration senden möchten.  
Typ: Zeichenfolge  
Erforderlich: NeinAusgabe

Antwort  
Der Text aus der Antwort des Webhook-Anbieters.

ResponseCode  
Der HTTP-Statuscode aus der Antwort des Webhook-Anbieters.

# `aws:invokeLambdaFunction`— Ruft eine Funktion auf AWS Lambda


Ruft die angegebene AWS Lambda Funktion auf.

**Anmerkung**  
Jede `aws:invokeLambdaFunction`-Aktion kann bis zu einer maximalen Dauer von 300 Sekunden (5 Minuten) laufen. Sie können die Zeitüberschreitung über den Parameter `timeoutSeconds` für einen `aws:invokeLambdaFunction`-Schritt limitieren.

**Anmerkung**  
Die Aktion `aws:invokeLambdaFunction` unterstützt die automatische Drosselungswiederholung. Weitere Informationen finden Sie unter [Konfigurieren der automatischen Wiederholung für gedrosselte Vorgänge](automation-throttling-retry.md).

**Input**  
Diese Aktion unterstützt die meisten aufgerufenen Parameter für den Lambda-Service. Weitere Informationen finden Sie unter [Aufrufen](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html).

------
#### [ YAML ]

```
name: invokeMyLambdaFunction
action: aws:invokeLambdaFunction
maxAttempts: 3
timeoutSeconds: 120
onFailure: Abort
inputs:
  FunctionName: MyLambdaFunction
```

------
#### [ JSON ]

```
{
    "name": "invokeMyLambdaFunction",
    "action": "aws:invokeLambdaFunction",
    "maxAttempts": 3,
    "timeoutSeconds": 120,
    "onFailure": "Abort",
    "inputs": {
        "FunctionName": "MyLambdaFunction"
    }
}
```

------

FunctionName  
Der Name der Lambda-Funktion. Diese Funktion muss vorhanden sein.  
Typ: Zeichenfolge  
Erforderlich: Ja

Qualifier  
Die Version oder der Aliasname der Funktion.  
Typ: Zeichenfolge  
Erforderlich: Nein

InvocationType  
Der Aufruftyp. Der Standardwert ist `RequestResponse`.  
Typ: Zeichenfolge  
Zulässige Werte: `Event` \$1 `RequestResponse` \$1 `DryRun`  
Erforderlich: Nein

LogType  
Wenn der Standardwert `Tail` ist, muss der Aufruftyp `RequestResponse` sein. Lambda gibt die letzten 4 KB von Protokolldaten mit base64 verschlüsselt zurück, die von Ihrer Lambda-Funktion vorliegen.  
Typ: Zeichenfolge  
Zulässige Werte: `None` \$1 `Tail`  
Erforderlich: Nein

ClientContext  
Die Client-spezifischen Informationen.  
Erforderlich: Nein

InputPayload  
Ein YAML- oder JSON-Objekt, das an den ersten Parameter des Handlers übergeben wird. Sie können diese Eingabe verwenden, um Daten an die Funktion zu übergeben. Diese Eingabe bietet mehr Flexibilität und Unterstützung als die Legacy-`Payload`-Eingabe. Wenn Sie sowohl `InputPayload` als auch `Payload` für die Aktion definieren, hat `InputPayload` Vorrang, und der `Payload`-Wert wird nicht verwendet.  
Typ: StringMap  
Erforderlich: Nein

Nutzlast  
Eine JSON-Zeichenfolge, die an den ersten Parameter des Handlers übergeben wird. Dies kann verwendet werden, um Eingabedaten an die Funktion zu übergeben. Wir empfehlen die Verwendung der `InputPayload`-Eingabe für zusätzliche Funktionen.  
Typ: Zeichenfolge  
Erforderlich: NeinAusgabe

StatusCode  
Den HTTP-Statuscode .

FunctionError  
Falls vorhanden, weist es darauf hin, dass währen der Ausführung der Funktion ein Fehler aufgetreten ist. Fehlerdetails sind in der Antwortnutzlast enthalten.

LogResult  
Die mit base64 verschlüsselten Protokolle zum Aufrufen der Lambda-Funktion. Protokolle sind nur dann vorhanden, wenn der Aufrufen-Typ `RequestResponse` ist und die Protokolle angefragt wurden.

Nutzlast  
Die JSON-Darstellung des Objekts, das von der Lambda-Funktion zurückgegeben wird. Die Nutzlast ist nur vorhanden, wenn der Aufrufen-Typ `RequestResponse` ist.

Das Folgende ist ein Teil des `AWS-PatchInstanceWithRollback`-Runbooks, der zeigt, wie auf Ausgaben der `aws:invokeLambdaFunction`-Aktion verwiesen wird.

------
#### [ YAML ]

```
- name: IdentifyRootVolume
  action: aws:invokeLambdaFunction
  inputs:
    FunctionName: "IdentifyRootVolumeLambda-{{automation:EXECUTION_ID}}"
    Payload: '{"InstanceId": "{{InstanceId}}"}'
- name: PrePatchSnapshot
  action: aws:executeAutomation
  inputs:
    DocumentName: "AWS-CreateSnapshot"
    RuntimeParameters:
      VolumeId: "{{IdentifyRootVolume.Payload}}"
      Description: "ApplyPatchBaseline restoration case contingency"
```

------
#### [ JSON ]

```
{
    "name": "IdentifyRootVolume",
    "action": "aws:invokeLambdaFunction",
    "inputs": {
      "FunctionName": "IdentifyRootVolumeLambda-{{automation:EXECUTION_ID}}",
      "Payload": "{\"InstanceId\": \"{{InstanceId}}\"}"
    }
  },
  {
    "name": "PrePatchSnapshot",
    "action": "aws:executeAutomation",
    "inputs": {
      "DocumentName": "AWS-CreateSnapshot",
      "RuntimeParameters": {
        "VolumeId": "{{IdentifyRootVolume.Payload}}",
        "Description": "ApplyPatchBaseline restoration case contingency"
      }
    }
  }
```

------

# `aws:loop` – Über Schritte in einer Automatisierung iterieren


Diese Aktion wiederholt sich über eine Teilmenge von Schritten in einem Automation-Runbook. Sie können einen Schleifenstil `do while` oder `for each` eine Schleife wählen. Verwenden Sie den `LoopCondition`-Eingabeparameter, um eine `do while`-Schleife zu erstellen. Verwenden Sie die Eingabeparameter `Iterators` und `IteratorDataType`, um eine `for each`-Schleife zu erstellen. Wenn Sie eine `aws:loop`-Aktion verwenden, geben Sie nur entweder den Eingabeparameter `Iterators` oder `LoopCondition` an. Die maximale Anzahl von Iterationen beträgt 100.

Die `onCancel`-Eigenschaft kann nur für Schritte definiert werden, die innerhalb einer Schleife genutzt sind. Die `onCancel`-Eigenschaft wird für die `aws:loop`-Aktion nicht unterstützt. Die `onFailure`-Eigenschaft kann für eine `aws:loop`-Aktion verwendet werden, sie wird jedoch nur verwendet, wenn ein unerwarteter Fehler auftritt, der dazu führt, dass der Schritt fehlschlägt. Wenn Sie `onFailure`-Eigenschaften für die Schritte innerhalb einer Schleife definieren, erbt die `aws:loop`-Aktion diese Eigenschaften und reagiert entsprechend, wenn ein Fehler auftritt.

**Beispiele**  
Im Folgenden finden Sie Beispiele für die Erstellung der verschiedenen Typen von Loop-Aktionen.

------
#### [ do while ]

```
name: RepeatMyLambdaFunctionUntilOutputIsReturned
action: aws:loop
inputs:
    Steps:
    - name: invokeMyLambda
        action: aws:invokeLambdaFunction
        inputs:
        FunctionName: LambdaFunctionName
        outputs:
        - Name: ShouldRetry
            Selector: $.Retry
            Type: Boolean
    LoopCondition:
        Variable: "{{ invokeMyLambda.ShouldRetry }}"
        BooleanEquals: true
    MaxIterations: 3
```

------
#### [ for each ]

```
name: stopAllInstancesWithWaitTime
action: aws:loop
inputs:
    Iterators: "{{ DescribeInstancesStep.InstanceIds }}"
    IteratorDataType: "String"
    Steps:
    - name: stopOneInstance
        action: aws:changeInstanceState
        inputs:
        InstanceIds:
            - "{{stopAllInstancesWithWaitTime.CurrentIteratorValue}}"
        CheckStateOnly: false
        DesiredState: stopped
    - name: wait10Seconds
        action: aws:sleep
        inputs:
        Duration: PT10S
```

------

**Input**  
Die Eingabe ist wie folgt.

Iteratoren  
Die Liste der Elemente, über die die Schritte iteriert werden sollen. Die maximale Anzahl von Iteratoren beträgt 100.  
Typ: StringList  
Erforderlich: Nein

IteratorDataType  
Ein optionaler Parameter zur Angabe des Datentyps von `Iterators`. Ein Wert für diesen Parameter kann zusammen mit dem `Iterators`-Eingabeparameter angegeben werden. Wenn Sie keinen Wert für diesen Parameter und `Iterators` angeben, müssen Sie einen Wert für den `LoopCondition`-Parameter angeben.  
Typ: Zeichenfolge  
Gültige Werte: Boolean \$1 Integer \$1 String \$1 StringMap  
Standard: Zeichenfolge  
Erforderlich: Nein

LoopCondition  
Besteht aus `Variable` und einer auszuwertenden Operatorbedingung. Wenn Sie keinen Wert für diesen Parameter angeben, müssen Sie einen Wert für die `Iterators`- und `IteratorDataType`-Parameter angeben. Sie können komplexe Operatorauswertungen verwenden, indem Sie eine Kombination aus Operatoren `And`, `Not` und `Or` verwenden. Die Bedingung wird bewertet, nachdem die Schritte in der Schleife abgeschlossen sind. Wenn die Bedingung `true` ist und der `MaxIterations`-Wert nicht erreicht wurde, werden die Schritte in der Schleife erneut ausgeführt. Die Bedingungen für den Operator lauten wie folgt:  

**Zeichenfolgenoperationen**
+ StringEquals
+ EqualsIgnoreCase
+ StartsWith
+ EndsWith
+ Enthält

**Numerische Operationen**
+ NumericEquals
+ NumericGreater
+ NumericLesser
+ NumericGreaterOrEquals
+ NumericLesser
+ NumericLesserOrEquals

**Boolesche Operation**
+ BooleanEquals
Typ: StringMap  
Erforderlich: Nein

MaxIterations  
Gibt an, wie oft die Schritte in der Schleife maximal ausgeführt werden. Sobald der für diese Eingabe angegebene Wert erreicht ist, stoppt die Schleife, auch wenn `LoopCondition` immer noch `true` ist oder im `Iterators`-Parameter verbleibende Objekte vorhanden sind.  
Typ: Ganzzahl  
Zulässige Werte: 1–100  
Erforderlich: Nein

Schritte  
Die Liste der auszuführenden Schritte. Diese funktionieren wie ein verschachteltes Runbook. In diesen Schritten können Sie mithilfe der `{{loopStepName.CurrentIteratorValue}}`-Syntax auf den aktuellen Iteratorwert für eine `for each`-Schleife zugreifen. Sie können mithilfe der `{{loopStepName.CurrentIteration}}`-Syntax auch auf einen Integer-Wert der aktuellen Iteration für beide Schleifentypen zugreifen.  
Typ: Liste der Schritte  
Erforderlich: JaAusgabe

CurrentIteration  
Die aktuelle Schleifeniteration als Ganzzahl. Iterationswerte beginnen bei 1.  
Typ: Ganzzahl

CurrentIteratorValue  
Der Wert des aktuellen Iterators als Zeichenfolge. Diese Ausgabe ist nur in `for each`-Schleifen vorhanden.  
Typ: Zeichenfolge

# `aws:pause` - Pausieren einer Automatisierung


Mit dieser Aktion wird die Ausführung der Automatisierung unterbrochen. Nach der Unterbrechung lautet der Automation-Status *Waiting*. Um die Automatisierung fortzusetzen, verwenden Sie den [SendAutomationSignal](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_SendAutomationSignal.html)API-Vorgang mit dem `Resume` Signaltyp. Wir empfehlen die Verwendung von der `aws:sleep`- oder `aws:approve`-Aktion zur genaueren Kontrolle Ihrer Workflows.

**Anmerkung**  
Das Standard-Timeout für diese Aktion beträgt 7 Tage (604 800 Sekunden) und der Höchstwert ist 30 Tage (2 592 000 Sekunden). Sie können die Zeitüberschreitung über den Parameter `timeoutSeconds` für einen `aws:pause`-Schritt anpassen.

**Input**  
Die Eingabe ist wie folgt.

------
#### [ YAML ]

```
name: pauseThis
action: aws:pause
timeoutSeconds: 1209600
inputs: {}
```

------
#### [ JSON ]

```
{
    "name": "pauseThis",
    "action": "aws:pause",
    "timeoutSeconds": "1209600",
    "inputs": {}
}
```

------Ausgabe

Keine  


# `aws:runCommand` - Führt einen Befehl auf einer verwalteten Instance aus


Führt die angegebenen Befehle aus.

**Anmerkung**  
Automation unterstützt nur die *Ausgabe* einer AWS Systems Manager Run Command-Aktion. Ein Runbook kann mehrere Run Command-Aktionen und enthalten, die Ausgabe wird allerdings nur für je eine Aktion unterstützt.

**Input**  
Diese Aktion unterstützt die meisten Befehlsendeparameter. Weitere Informationen finden Sie unter [SendCommand](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_SendCommand.html).

------
#### [ YAML ]

```
- name: checkMembership
  action: 'aws:runCommand'
  inputs:
    DocumentName: AWS-RunPowerShellScript
    InstanceIds:
      - '{{InstanceIds}}'
    Parameters:
      commands:
        - (Get-WmiObject -Class Win32_ComputerSystem).PartOfDomain
```

------
#### [ JSON ]

```
{
    "name": "checkMembership",
    "action": "aws:runCommand",
    "inputs": {
        "DocumentName": "AWS-RunPowerShellScript",
        "InstanceIds": [
            "{{InstanceIds}}"
        ],
        "Parameters": {
            "commands": [
                "(Get-WmiObject -Class Win32_ComputerSystem).PartOfDomain"
            ]
        }
    }
}
```

------

DocumentName  
Wenn das Dokument vom Typ Command Ihnen gehört oder AWS, geben Sie den Namen des Dokuments an. Geben Sie den Amazon-Ressourcennamen (ARN) des Dokuments an, wenn Sie ein Dokument verwenden, das von einem anderen AWS-Konto mit Ihnen geteilt wird. Weitere Informationen zur Verwendung von geteilten Dokumenten finden Sie unter [Verwenden von freigegebenen SSM-Dokumenten](documents-ssm-sharing.md#using-shared-documents).  
Typ: Zeichenfolge  
Erforderlich: Ja

InstanceIds  
Die Instanz IDs , in der der Befehl ausgeführt werden soll. Sie können ein Maximum von 50 angeben IDs.   
Sie können den Pseudo-Parameter auch anstelle `{{RESOURCE_ID}}` der Instanz verwenden IDs , um den Befehl auf allen Instanzen in der Zielgruppe auszuführen. Weitere Informationen zu Pseudoparametern finden Sie unter [Verwendung von Pseudo-Parametern bei der Registrierung von Aufgaben im Wartungsfenster](maintenance-window-tasks-pseudo-parameters.md).  
Alternativ können Sie Befehle mit dem Parameter `Targets` an eine Instance-Flotte senden. Die `Targets`-Parameter akzeptiert Amazon Elastic Compute Cloud (Amazon EC2)-Tags. Weitere Informationen zur Verwendung des Parameters `Targets` finden Sie unter [Ausführen von Befehlen in großem Maßstab](send-commands-multiple.md).  
Typ: StringList  
Erforderlich: Nein (Wenn Sie den `{{RESOURCE_ID}}` Pseudo-Parameter nicht angeben InstanceIds oder verwenden, müssen Sie den `Targets` Parameter angeben.)

Targets  
Ein Array von Suchkriterien, das mithilfe einer von Ihnen angegebenen Kombination aus Schlüssel und Wert auf Instances abzielt. `Targets`ist erforderlich, wenn Sie IDs im Call keine oder mehrere Instanzen angeben. Weitere Informationen zur Verwendung des Parameters `Targets` finden Sie unter [Ausführen von Befehlen in großem Maßstab](send-commands-multiple.md).  
Typ: MapList (Das Schema der Map in der Liste muss mit dem Objekt übereinstimmen.) Informationen finden Sie unter [Target](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_Target.html) in der *AWS Systems Manager -API-Referenz*.  
Erforderlich: Nein (Wenn Sie nichts angeben`Targets`, müssen Sie den `{{RESOURCE_ID}}` Pseudo-Parameter angeben InstanceIds oder verwenden.)  
Im Folgenden sehen Sie ein Beispiel.  

```
- name: checkMembership
  action: aws:runCommand
  inputs:
    DocumentName: AWS-RunPowerShellScript
    Targets:
      - Key: tag:Stage
        Values:
          - Gamma
          - Beta
      - Key: tag-key
        Values:
          - Suite
    Parameters:
      commands:
        - (Get-WmiObject -Class Win32_ComputerSystem).PartOfDomain
```

```
{
    "name": "checkMembership",
    "action": "aws:runCommand",
    "inputs": {
        "DocumentName": "AWS-RunPowerShellScript",
        "Targets": [                   
            {
                "Key": "tag:Stage",
                "Values": [
                    "Gamma", "Beta"
                ]
            },
            {
                "Key": "tag:Application",
                "Values": [
                    "Suite"
                ]
            }
        ],
        "Parameters": {
            "commands": [
                "(Get-WmiObject -Class Win32_ComputerSystem).PartOfDomain"
            ]
        }
    }
}
```

Parameters  
Die erforderlichen und optionalen Parameter, die im Dokument angegeben sind.  
Typ: Zuordnung  
Erforderlich: Nein

CloudWatchOutputConfig  
Konfigurationsoptionen für das Senden von Befehlsausgaben an Amazon CloudWatch Logs. Weitere Informationen zum Senden von Befehlsausgaben an CloudWatch Logs finden Sie unter[Konfiguration von Amazon CloudWatch Logs für Run Command](sysman-rc-setting-up-cwlogs.md).  
Typ: StringMap (Das Schema der Map muss mit dem Objekt übereinstimmen. Weitere Informationen finden Sie [CloudWatchOutputConfig](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_CloudWatchOutputConfig.html)in der *AWS Systems Manager API-Referenz*).  
Erforderlich: Nein  
Im Folgenden sehen Sie ein Beispiel.  

```
- name: checkMembership
  action: aws:runCommand
  inputs:
    DocumentName: AWS-RunPowerShellScript
    InstanceIds:
      - "{{InstanceIds}}"
    Parameters:
      commands:
        - "(Get-WmiObject -Class Win32_ComputerSystem).PartOfDomain"
    CloudWatchOutputConfig:
      CloudWatchLogGroupName: CloudWatchGroupForSSMAutomationService
      CloudWatchOutputEnabled: true
```

```
{
    "name": "checkMembership",
    "action": "aws:runCommand",
    "inputs": {
        "DocumentName": "AWS-RunPowerShellScript",
        "InstanceIds": [
            "{{InstanceIds}}"
        ],
        "Parameters": {
            "commands": [
                "(Get-WmiObject -Class Win32_ComputerSystem).PartOfDomain"
            ]
        },
        "CloudWatchOutputConfig" : { 
                "CloudWatchLogGroupName": "CloudWatchGroupForSSMAutomationService",
                "CloudWatchOutputEnabled": true
        }
    }
}
```

Comment  
Benutzerdefinierte Informationen über den Befehl.  
Typ: Zeichenfolge  
Erforderlich: Nein

DocumentHash  
Der Hash für das Dokument.  
Typ: Zeichenfolge  
Erforderlich: Nein

DocumentHashType  
Der Typ des Hash.  
Typ: Zeichenfolge  
Zulässige Werte: `Sha256` \$1 `Sha1`  
Erforderlich: Nein

NotificationConfig  
Die Konfigurationen für das Senden von Benachrichtigungen.  
Erforderlich: Nein

OutputS3 BucketName  
Der Name des S3-Buckets für Befehlsausgabeantworten. Ihr verwalteter Knoten muss Berechtigungen haben, damit der S3-Bucket die Ausgabe erfolgreich protokollieren kann.  
Typ: Zeichenfolge  
Erforderlich: Nein

OutputS3 KeyPrefix  
Das Präfix.  
Typ: Zeichenfolge  
Erforderlich: Nein

ServiceRoleArn  
Der ARN der AWS Identity and Access Management (IAM-) Rolle.  
Typ: Zeichenfolge  
Erforderlich: Nein

TimeoutSeconds  
Die Wartezeit in Sekunden, bis ein Befehl AWS Systems Manager SSM Agent an die Instance übermittelt wird. Wenn der Befehl vom SSM Agent auf der Instance vor dem Erreichen des angegebenen Werts nicht empfangen wurde, ändert sich der Status des Befehls in `Delivery Timed Out`.  
Typ: Ganzzahl  
Erforderlich: Nein  
Zulässige Werte: 30 bis 2 592 000Ausgabe

CommandId  
Die ID des Befehls.

Status  
Der Status des Befehls.

ResponseCode  
Der Antwortcode des Befehls. Wenn das Dokument, das Sie ausführen, mehr als einen Schritt umfasst, wird für diese Ausgabe kein Wert zurückgegeben.

Ausgabe  
Die Ausgabe des Befehls. Wenn Sie mit Ihrem Befehl auf ein Tag oder mehrere Instances abzielen, wird kein Ausgabewert zurückgegeben. Sie können die API-Vorgänge `GetCommandInvocation` und `ListCommandInvocations` verwenden, um Ausgaben für einzelne Instances abzurufen.

# `aws:runInstances` - So starten Sie eine Amazon-EC2-Instance


Startet eine neue Amazon Elastic Compute Cloud (Amazon EC2)-Instance.

**Anmerkung**  
Die Aktion `aws:runInstances` unterstützt die automatische Drosselungswiederholung. Weitere Informationen finden Sie unter [Konfigurieren der automatischen Wiederholung für gedrosselte Vorgänge](automation-throttling-retry.md).

**Input**  
Die Aktion unterstützt die meisten API-Parameter. Weitere Informationen finden Sie in der [RunInstances](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html)API-Dokumentation.

------
#### [ YAML ]

```
name: launchInstance
action: aws:runInstances
maxAttempts: 3
timeoutSeconds: 1200
onFailure: Abort
inputs:
  ImageId: ami-12345678
  InstanceType: t2.micro
  MinInstanceCount: 1
  MaxInstanceCount: 1
  IamInstanceProfileName: myRunCmdRole
  TagSpecifications:
  - ResourceType: instance
    Tags:
    - Key: LaunchedBy
      Value: SSMAutomation
    - Key: Category
      Value: HighAvailabilityFleetHost
```

------
#### [ JSON ]

```
{
   "name":"launchInstance",
   "action":"aws:runInstances",
   "maxAttempts":3,
   "timeoutSeconds":1200,
   "onFailure":"Abort",
   "inputs":{
      "ImageId":"ami-12345678",
      "InstanceType":"t2.micro",
      "MinInstanceCount":1,
      "MaxInstanceCount":1,
      "IamInstanceProfileName":"myRunCmdRole",
      "TagSpecifications":[
         {
            "ResourceType":"instance",
            "Tags":[
               {
                  "Key":"LaunchedBy",
                  "Value":"SSMAutomation"
               },
               {
                  "Key":"Category",
                  "Value":"HighAvailabilityFleetHost"
               }
            ]
         }
      ]
   }
}
```

------

AdditionalInfo  
Reserved Instances.  
Typ: Zeichenfolge  
Erforderlich: Nein

BlockDeviceMappings  
Die Blockgeräte für die Instance.  
Typ: MapList  
Erforderlich: Nein

ClientToken  
Der Bezeichner, um die Idempotenz der Anfrage sicherzustellen.  
Typ: Zeichenfolge  
Erforderlich: Nein

DisableApiTermination  
Aktiviert oder deaktiviert die Instance-API-Beendigung.  
Typ: Boolesch  
Erforderlich: Nein

EbsOptimized  
Aktiviert oder deaktiviert die Amazon Elastic Block Store (Amazon EBS)-Optimierung.  
Typ: Boolesch  
Erforderlich: Nein

IamInstanceProfileArn  
Der Amazon-Ressourcenname (ARN) des AWS Identity and Access Management (IAM) -Instance-Profils für die Instance.  
Typ: Zeichenfolge  
Erforderlich: Nein

IamInstanceProfileName  
Der Name des IAM-Instance-Profils für die Instance.  
Typ: Zeichenfolge  
Erforderlich: Nein

ImageId  
Die ID des Amazon Machine Image (AMI).  
Typ: Zeichenfolge  
Erforderlich: Ja

InstanceInitiatedShutdownBehavior  
Gibt an, ob die Instance beim Herunterfahren des Systems angehalten oder beendet wird.  
Typ: Zeichenfolge  
Erforderlich: Nein

InstanceType  
Der Instance-Typ.  
Wenn kein Wert für den Instance-Typ angegeben wird, wird der Instance-Typ m1.small verwendet.
Typ: Zeichenfolge  
Erforderlich: Nein

KernelId  
Die ID des Kernels.  
Typ: Zeichenfolge  
Erforderlich: Nein

KeyName  
Der Name des Schlüsselpaars.  
Typ: Zeichenfolge  
Erforderlich: Nein

MaxInstanceCount  
Die Höchstanzahl zu startender Instances.  
Typ: Zeichenfolge  
Erforderlich: Nein

MetadataOptions  
Die Metadatenoptionen für die Instance. Weitere Informationen finden Sie unter [InstanceMetadataOptionsRequest](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_InstanceMetadataOptionsRequest.html).  
Typ: StringMap  
Erforderlich: Nein

MinInstanceCount  
Die Mindestanzahl zu startender Instances.  
Typ: Zeichenfolge  
Erforderlich: Nein

Überwachen  
Aktiviert oder deaktiviert die detaillierte Überwachung.g  
Typ: Boolesch  
Erforderlich: Nein

NetworkInterfaces  
Die Netzwerkschnittstellen.  
Typ: MapList  
Erforderlich: Nein

Placement  
Die Platzierung für die Instance.  
Typ: StringMap  
Erforderlich: Nein

PrivateIpAddress  
Die primäre IPv4 Adresse.  
Typ: Zeichenfolge  
Erforderlich: Nein

RamdiskId  
Die ID des RAM-Datenträgers.  
Typ: Zeichenfolge  
Erforderlich: Nein

SecurityGroupIds  
Die IDs der Sicherheitsgruppen für die Instance.  
Typ: StringList  
Erforderlich: Nein

SecurityGroups  
Die Namen der Sicherheitsgruppen für die Instance.  
Typ: StringList  
Erforderlich: Nein

SubnetId  
Die Subnetz-ID.  
Typ: Zeichenfolge  
Erforderlich: Nein

TagSpecifications  
Die Tags, die beim Start auf die Ressourcen angewendet werden. Instances und Volumes können nur beim Start mit Tags versehen werden. Die angegebenen Tags werden auf alle Instances bzw. Volumes angewendet, die beim Start erstellt werden. Um eine Instance nach dem Start mit Tags zu versehen, verwenden Sie die Aktion [`aws:createTags`— Erstelle Tags für AWS Ressourcen](automation-action-createtag.md).  
Typ: MapList (Weitere Informationen finden Sie unter [TagSpecification](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_TagSpecification.html).)  
Erforderlich: Nein

UserData  
Ein Skript, das als Zeichenfolgenliteralwert bereitgestellt wird. Wenn ein Literalwert eingegeben wird, muss er Base64-kodiert sein.  
Typ: Zeichenfolge  
Erforderlich: NeinAusgabe

InstanceIds  
Die IDs der Instanzen.

InstanceStates  
Der Status der Instance.

# `aws:sleep` - Verzögerung einer Automatisierung


Verzögert eine Automatisierung um eine bestimmte Zeit. Diese Aktion verwendet das Datums- und Uhrzeitformat der International Organization for Standardization (ISO) 8601. Weitere Informationen zu diesem Datums- und Uhrzeitformat finden Sie unter [ISO 8601](https://www.iso.org/iso-8601-date-and-time-format.html).

**Input**  
Sie können eine Automatisierung um eine festgelegte Dauer verzögern. 

------
#### [ YAML ]

```
name: sleep
action: aws:sleep
inputs:
  Duration: PT10M
```

------
#### [ JSON ]

```
{
   "name":"sleep",
   "action":"aws:sleep",
   "inputs":{
      "Duration":"PT10M"
   }
}
```

------

Sie können eine Automatisierung auch bis zu einem festgelegten Zeitpunkt verzögern. Wenn das Datum und die Uhrzeit verstrichen sind, erfolgt die Aktion unmittelbar. 

------
#### [ YAML ]

```
name: sleep
action: aws:sleep
inputs:
  Timestamp: '2020-01-01T01:00:00Z'
```

------
#### [ JSON ]

```
{
    "name": "sleep",
    "action": "aws:sleep",
    "inputs": {
        "Timestamp": "2020-01-01T01:00:00Z"
    }
}
```

------

**Anmerkung**  
Automation unterstützt eine maximale Verzögerung von 604799 Sekunden (7 Tage).

Dauer  
Ein ISO 8601-Dauer. Sie können keine negative Dauer angeben.   
Typ: Zeichenfolge  
Erforderlich: Nein

Zeitstempel  
Ein ISO 8601-Zeitstempel. Wenn Sie keinen Wert für diesen Parameter angeben, müssen Sie einen Wert für den `Duration`-Parameter angeben.   
Typ: Zeichenfolge  
Erforderlich: NeinAusgabe

Keine  


# `aws:updateVariable` – Aktualisiert einen Wert für eine Runbook-Variable


Diese Aktion aktualisiert einen Wert für eine Runbook-Variable. Der Datentyp des Werts muss dem Datentyp der Variable entsprechen, die Sie aktualisieren möchten. Datentypkonvertierungen werden nicht unterstützt. Die `onCancel`-Eigenschaft wird für die `aws:updateVariable`-Aktion nicht unterstützt.

**Input**  
Die Eingabe ist wie folgt.

------
#### [ YAML ]

```
name: updateStringList
action: aws:updateVariable
inputs:
    Name: variable:variable name
    Value:
    - "1"
    - "2"
```

------
#### [ JSON ]

```
{
    "name": "updateStringList",
    "action": "aws:updateVariable",
    "inputs": {
        "Name": "variable:variable name",
        "Value": ["1","2"]
    }
}
```

------

Name  
Der Name der Variable, deren Wert Sie aktualisieren möchten. Sie müssen das Format `variable:variable name` verwenden  
Typ: Zeichenfolge  
Erforderlich: Ja

Wert  
Der neue Wert, der der Variable zugewiesen werden soll. Der Wert muss mit dem Datentyp der Variable übereinstimmen. Datentypkonvertierungen werden nicht unterstützt.  
Typ: Boolean \$1 Integer \$1 \$1 String MapList \$1 \$1 StringList StringMap  
Erforderlich: Ja  
Einschränkungen:  
+ MapList kann eine maximale Anzahl von 200 Elementen enthalten.
+ Schlüssellängen können eine Mindestlänge von 1 und eine Maximallänge von 50 haben.
+ StringList kann eine Mindestanzahl von 0 Elementen und eine maximale Anzahl von 50 Elementen sein.
+ Die Länge einer Zeichenfolge kann eine Mindestlänge von 1 und eine Maximallänge von 512 haben.Ausgabe

Keine  


# `aws:waitForAwsResourceProperty`— Warte auf eine AWS Ressourceneigenschaft


Die `aws:waitForAwsResourceProperty`-Aktion erlaubt Ihrer Automatisierung auf einen bestimmten Ressourcenstatus oder Ereignisstatus zu warten, bevor Sie die Automatisierung fortsetzen. Weitere Beispiele zur Verwendung dieser Aktion finden Sie unter [Weitere Runbook-Beispiele](automation-document-examples.md).

**Anmerkung**  
Der Standardwert für die Zeitüberschreitung für diese Aktion beträgt 3 600 Sekunden (eine Stunde). Sie können die Zeitüberschreitung über den Parameter `timeoutSeconds` für einen `aws:waitForAwsResourceProperty`-Schritt anpassen. Weitere Informationen und Beispiele zur Verwendung dieser Aktion finden Sie unter [Behandeln von Timeouts in Runbooks](automation-handling-timeouts.md).

**Anmerkung**  
Die Aktion `aws:waitForAwsResourceProperty` unterstützt die automatische Drosselungswiederholung. Weitere Informationen finden Sie unter [Konfigurieren der automatischen Wiederholung für gedrosselte Vorgänge](automation-throttling-retry.md).

**Input**  
Eingaben werden von der ausgewählten API-Operation bestimmt.

------
#### [ YAML ]

```
action: aws:waitForAwsResourceProperty
inputs:
  Service: The official namespace of the service
  Api: The API operation or method name
  API operation inputs or parameters: A value
  PropertySelector: Response object
  DesiredValues:
  - Desired property value
```

------
#### [ JSON ]

```
{
  "action": "aws:waitForAwsResourceProperty",
  "inputs": {
    "Service":"The official namespace of the service",
    "Api":"The API operation or method name",
    "API operation inputs or parameters":"A value",
    "PropertySelector": "Response object",
    "DesiredValues": [
      "Desired property value"
    ]
  }
}
```

------

Service  
Der AWS-Service Namespace, der die API-Operation enthält, die Sie ausführen möchten. Der Namespace für ist beispielsweise. AWS Systems Manager `ssm` Der Namespace für Amazon Elastic Compute Cloud (Amazon EC2) ist `ec2`. *Eine Liste der unterstützten AWS-Service Namespaces finden Sie im Abschnitt [Verfügbare Dienste der Befehlsreferenz](https://docs.aws.amazon.com/cli/latest/reference/#available-services).AWS CLI *  
Typ: Zeichenfolge  
Erforderlich: Ja

Api  
Der Name der API-Operation, die Sie ausführen möchten. Sie können die API-Operationen (auch als Methoden bezeichnet) anzeigen, indem Sie einen Service in der linken Navigationsleiste auf der folgenden [Service-Referenzen](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/index.html)-Seite auswählen. Wählen Sie eine Methode im Abschnitt **Client** für den Service, den Sie aufrufen möchten. Beispielsweise werden alle API-Vorgänge (Methoden) für Amazon Relational Database Service (Amazon RDS) auf der folgenden Seite aufgelistet: [Amazon RDS-Methoden](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rds.html).  
Typ: Zeichenfolge  
Erforderlich: Ja

API-Operation-Eingaben  
Eine oder mehrere API-Eingaben. Sie können die verfügbaren Eingaben (auch als Parameter bezeichnet) anzeigen, indem Sie einen Service in der linken Navigationsleiste auf der folgenden [Service-Referenzen](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/index.html)-Seite auswählen. Wählen Sie eine Methode im Abschnitt **Client** für den Service, den Sie aufrufen möchten. Beispielsweise sind alle Methoden für Amazon RDS auf der folgenden Seite aufgeführt: [Amazon RDS-Methoden](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rds.html). ******Wählen Sie die Methode [describe\$1db\$1instances](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rds.html#RDS.Client.describe_db_instances) und scrollen Sie nach unten, um die verfügbaren Parameter wie Identifier, Name und Values zu sehen. DBInstance******  

```
inputs:
  Service: The official namespace of the service
  Api: The API operation name
  API input 1: A value
  API Input 2: A value
  API Input 3: A value
```

```
"inputs":{
      "Service":"The official namespace of the service",
      "Api":"The API operation name",
      "API input 1":"A value",
      "API Input 2":"A value",
      "API Input 3":"A value"
}
```
Typ: Abhängig von der gewählten API-Operation  
Erforderlich: Ja

PropertySelector  
Das JSONPath zu einem bestimmten Attribut im Antwortobjekt. Sie können die Antwortobjekte anzeigen indem Sie einen Service in der linken Navigationsleiste auf der folgenden [Service-Referenzen](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/index.html)-Seite auswählen. Wählen Sie eine Methode im Abschnitt **Client** für den Service, den Sie aufrufen möchten. Beispielsweise sind alle Methoden für Amazon RDS auf der folgenden Seite aufgeführt: [Amazon RDS-Methoden](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rds.html). **Wählen Sie die Methode [describe\$1db\$1instances](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rds.html#RDS.Client.describe_db_instances) und scrollen Sie nach unten zum Abschnitt Antwortstruktur.** **DBInstances**ist als Antwortobjekt aufgeführt.  
Typ: Zeichenfolge  
Erforderlich: Ja

DesiredValues  
Die erwartete Status oder Zustand, bei dem die Automatisierung fortgesetzt werden soll.  
Typ: MapList, StringList  
Erforderlich: Ja

# Systemvariablen für Automation


AWS Systems Manager-Automation-Runbooks verwenden die folgenden Variablen. Ein Beispiel für die Verwendung dieser Variablen erhalten Sie, wenn Sie die JSON-Quelle des `AWS-UpdateWindowsAmi`-Runbooks anzeigen. 

**So zeigen Sie die JSON-Quelle des `AWS-UpdateWindowsAmi`-Runbooks an**

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 die Option **Dokumente** aus.

1. Wählen Sie in der Dokumentliste entweder über die Suchleiste oder die Zahlen rechts neben der Suchleiste das Runbook `AWS-UpdateWindowsAmi` aus.

1. Wählen Sie die Registerkarte **Content** aus. 

**Systemvariablen**  
Automation-Runbooks unterstützen die folgenden Variablen.


****  

| Variable | Details | 
| --- | --- | 
|  `global:ACCOUNT_ID`  |  Die AWS-Konto-ID des Benutzers oder der Rolle, in dem die Automatisierung ausgeführt wird.  | 
|  `global:DATE`  |  Das Datum (zur Ausführungszeit) im Format yyyy-MM-dd.  | 
|  `global:DATE_TIME`  |  Das Datum und die Uhrzeit (zur Ausführungszeit) im Format yyyy-MM-dd\$1HH.mm.ss.  | 
|  `global:AWS_PARTITION`  |  Die Partition, in der sich die Ressource befindet. Für Standard-AWS-Regionen lautet die Partition `aws`. Für Ressourcen in anderen Partitionen lautet die Partition `aws-partitionname`. Beispielsweise ist die Partition für Ressourcen in der AWS-GovCloud (US-West)-Region `aws-us-gov`.  | 
|  `global:REGION`  |  Die Region, in der das Runbook ausgeführt wird. Beispiel: us-east-2.  | 

**Variablen für Automation**  
Automation-Runbooks unterstützen die folgenden Automatisierungsvariablen.


****  

| Variable | Details | 
| --- | --- | 
|  `automation:EXECUTION_ID`  |  Die eindeutige ID, die der aktuellen Automatisierung zugewiesen ist. Beispiel, `1a2b3c-1a2b3c-1a2b3c-1a2b3c1a2b3c1a2b3c`.  | 

**Topics**
+ [

## Terminologie
](#automation-terms)
+ [

## Unterstützte Szenarien
](#automation-variables-support)
+ [

## Nicht unterstützte Szenarien
](#automation-variables-unsupported)

## Terminologie


Die folgenden Bedingungen beschreiben, wie Variablen und Parameter gelöst werden.


****  

| Begriff | Definition | Beispiel | 
| --- | --- | --- | 
|  Konstanter ARN  |  Ein gültiger Amazon-Ressourcenname (ARN) ohne Variablen.  |  `arn:aws:iam::123456789012:role/roleName`  | 
|  Runbook-Parameter  |  Ein auf der Runbook-Ebene definierter Parameter (z. B. `instanceId`). Der Parameter wird in einer grundlegenden Zeichenfolgenersetzung verwendet. Sein Wert wird zur Startausführungszeit bereitgestellt.  |  <pre>{ <br />   "description": "Create Image Demo",<br />   "version": "0.3",<br />   "assumeRole": "Your_Automation_Assume_Role_ARN",<br />   "parameters":{ <br />      "instanceId": { <br />         "type": "String",<br />         "description": "Instance to create image from"<br />   }<br />}</pre>  | 
|  Systemvariable  |  Eine allgemeine Variable, die in das Runbook eingefügt wird, wenn ein beliebiger Teil des Runbooks bewertet wird.  |  <pre>"activities": [ <br />   { <br />      "id": "copyImage",<br />      "activityType": "AWS-CopyImage",<br />      "maxAttempts": 1,<br />      "onFailure": "Continue",<br />      "inputs": { <br />         "ImageName": "{{imageName}}",<br />         "SourceImageId": "{{sourceImageId}}",<br />         "SourceRegion": "{{sourceRegion}}",<br />         "Encrypted": true,<br />         "ImageDescription": "Test CopyImage Description created on {{global:DATE}}"<br />      }<br />   }<br />]</pre>  | 
|  Variable für Automation  |  Eine Variable, die sich auf die Automatisierung bezieht, die in das Runbook eingefügt wird, wenn ein Teil des Runbooks bewertet wird.  |  <pre>{ <br />   "name": "runFixedCmds",<br />   "action": "aws:runCommand",<br />   "maxAttempts": 1,<br />   "onFailure": "Continue",<br />   "inputs": { <br />      "DocumentName": "AWS-RunPowerShellScript",<br />      "InstanceIds": [ <br />         "{{LaunchInstance.InstanceIds}}"<br />      ],<br />      "Parameters": { <br />         "commands": [ <br />            "dir",<br />            "date",<br />            "“{{outputFormat}}” -f “left”,”right”,”{{global:DATE}}”,”{{automation:EXECUTION_ID}}”<br />         ]<br />      }<br />   }<br />}</pre>  | 
|  Systems Manager-Parameter  |  Eine in AWS Systems Manager Parameter Store definierte Variable. Eine direkte Referenzierung in der Schritteingabe ist nicht möglich. Eventuell sind für den Zugriff auf den Parameter Berechtigungen erforderlich.  |  <pre><br />description: Launch new Windows test instance<br />schemaVersion: '0.3'<br />assumeRole: '{{AutomationAssumeRole}}'<br />parameters:<br />  AutomationAssumeRole:<br />    type: String<br />    default: ''<br />    description: >-<br />      (Required) The ARN of the role that allows Automation to perform the<br />      actions on your behalf. If no role is specified, Systems Manager<br />      Automation uses your IAM permissions to run this runbook.<br />  LatestAmi:<br />    type: String<br />    default: >-<br />      {{ssm:/aws/service/ami-windows-latest/Windows_Server-2016-English-Full-Base}}<br />    description: The latest Windows Server 2016 AMI queried from the public parameter.<br />mainSteps:<br />  - name: launchInstance<br />    action: 'aws:runInstances'<br />    maxAttempts: 3<br />    timeoutSeconds: 1200<br />    onFailure: Abort<br />    inputs:<br />      ImageId: '{{LatestAmi}}'<br />...</pre>  | 

## Unterstützte Szenarien



****  

| Szenario | Kommentare | Beispiel | 
| --- | --- | --- | 
|  Konstanter ARN `assumeRole` beim Erstellen.  |  Es wird eine Autorisierungsprüfung durchgeführt, um zu bestätigen, dass der aufrufende Benutzer über die Berechtigung zum Übergeben der Rolle `assumeRole` verfügt.  |  <pre>{<br />  "description": "Test all Automation resolvable parameters",<br />  "schemaVersion": "0.3",<br />  "assumeRole": "arn:aws:iam::123456789012:role/roleName",<br />  "parameters": { <br />  ...</pre>  | 
|  Der Runbook-Parameter wird für `AssumeRole` bereitgestellt, wenn die Automatisierung gestartet wird.  |  Muss in der Parameterliste des Runbooks definiert werden.  |  <pre>{<br />  "description": "Test all Automation resolvable parameters",<br />  "schemaVersion": "0.3",<br />  "assumeRole": "{{dynamicARN}}",<br />  "parameters": {<br /> ...</pre>  | 
|  Für Runbookparameter beim Start bereitgestellter Wert.  |  Der Kunde stellt den für einen Parameter zu verwendenden Wert bereit. Alle zur bereitgestellten Eingaben müssen in der Parameterliste des Runbooks definiert sein.  |  <pre>...<br />"parameters": {<br />    "amiId": {<br />      "type": "String",<br />      "default": "ami-12345678",<br />      "description": "list of commands to run as part of first step"<br />    },<br />...</pre> Eingaben zum Start der Automation-Ausführung umfassen : `{"amiId" : ["ami-12345678"] }`  | 
|  Systems Manager Parameter, auf den im Runbook-Inhalt verwiesen wird.  |  Die Variable existiert im Kundenkonto oder ist ein öffentlich zugänglicher Parameter und die `AssumeRole` für das Runbook hat Zugriff auf die Variable. Beim Erstellen wird eine Überprüfung durchgeführt, um zu bestätigen, dass `AssumeRole` Zugriff hat. Der Parameter kann nicht direkt in der Schritteingabe referenziert werden.  |  <pre><br />...<br />parameters:<br />    LatestAmi:<br />    type: String<br />    default: >-<br />      {{ssm:/aws/service/ami-windows-latest/Windows_Server-2016-English-Full-Base}}<br />    description: The latest Windows Server 2016 AMI queried from the public parameter.<br />mainSteps:<br />  - name: launchInstance<br />    action: 'aws:runInstances'<br />    maxAttempts: 3<br />    timeoutSeconds: 1200<br />    onFailure: Abort<br />    inputs:<br />      ImageId: '{{LatestAmi}}'<br />...</pre>  | 
|  Die Systemvariable, auf die in der Definition des Schritts verwiesen wird  |  Eine Systemvariable wird beim Start der Automatisierung in das Runbook eingefügt. Der in das Runbook eingefügte Wert steht in Relation zum Zeitpunkt des Einfügens. Das bedeutet, dass der Wert einer Zeitvariable, die in Schritt 1 eingefügt wurde, aufgrund der erforderlichen Zeit für die Ausführung der Schritte vom in Schritt 3 eingefügten Wert abweicht. Systemvariablen müssen nicht in der Parameterliste des Runbooks festgelegt werden.  |  <pre>...<br />  "mainSteps": [<br />    {<br />      "name": "RunSomeCommands",<br />      "action": "aws:runCommand",<br />      "maxAttempts": 1,<br />      "onFailure": "Continue",<br />      "inputs": {<br />        "DocumentName": "AWS:RunPowerShell",<br />        "InstanceIds": ["{{LaunchInstance.InstanceIds}}"],<br />        "Parameters": {<br />            "commands" : [<br />                "echo {The time is now {{global:DATE_TIME}}}"<br />            ]<br />        }<br />    }<br />}, ... </pre>  | 
|  Die Automation-Variable, auf die in der Definition des Schritts verwiesen wird.  |  Automation-Variablen müssen nicht in der Parameterliste des Runbooks festgelegt werden. Die einzige unterstützte AAutomation-Variable ist **automation:EXECUTION\$1ID**.  |  <pre>...<br />"mainSteps": [<br />    {<br />      "name": "invokeLambdaFunction",<br />      "action": "aws:invokeLambdaFunction",<br />      "maxAttempts": 1,<br />      "onFailure": "Continue",<br />      "inputs": {<br />        "FunctionName": "Hello-World-LambdaFunction",<br /><br />"Payload" : "{ "executionId" : "{{automation:EXECUTION_ID}}" }"<br />      }<br />    }<br />... </pre>  | 
|  Weitere Informationen finden Sie in der Ausgabe des vorherigen Schritts in der Definition des nächsten Schritts.  |  Dies ist die Parameterumleitung. Mithilfe der Syntax `{{stepName.OutputName}}` wird auf die Ausgabe eines vorherigen Schritts verwiesen. Diese Syntax kann vom Kunden nicht für Runbookparameter verwendet werden. Dies wird behoben, wenn der verweisende Schritt ausgeführt wird. Der Parameter ist nicht in der Liste der Parameter des Runbooks aufgeführt.  |  <pre>...<br />"mainSteps": [<br />    {<br />      "name": "LaunchInstance",<br />      "action": "aws:runInstances",<br />      "maxAttempts": 1,<br />      "onFailure": "Continue",<br />      "inputs": {<br />        "ImageId": "{{amiId}}",<br />        "MinInstanceCount": 1,<br />        "MaxInstanceCount": 2<br />      }<br />    },<br />    {<br />      "name":"changeState",<br />      "action": "aws:changeInstanceState",<br />      "maxAttempts": 1,<br />      "onFailure": "Continue",<br />      "inputs": {<br />        "InstanceIds": ["{{LaunchInstance.InstanceIds}}"],<br />        "DesiredState": "terminated"<br />      }<br />    }<br /><br />... </pre>  | 

## Nicht unterstützte Szenarien



****  

| Szenario | Kommentar | Beispiel | 
| --- | --- | --- | 
|  Systems Manager Parameter bereitgestellt für `assumeRole` beim Erstellen  |  Nicht unterstützt  |  <pre>...<br /><br />{<br />  "description": "Test all Automation resolvable parameters",<br />  "schemaVersion": "0.3",<br />  "assumeRole": "{{ssm:administratorRoleARN}}",<br />  "parameters": {<br /><br />... </pre>  | 
|  System Manager-Parameter, der direkt in der Schritteingabe referenziert wird.  |  Gibt eine `InvalidDocumentContent`-Ausnahme zur Erstellungszeit zurück.  |  <pre><br />...<br />mainSteps:<br />  - name: launchInstance<br />    action: 'aws:runInstances'<br />    maxAttempts: 3<br />    timeoutSeconds: 1200<br />    onFailure: Abort<br />    inputs:<br />      ImageId: '{{ssm:/aws/service/ami-windows-latest/Windows_Server-2016-English-Full-Base}}'<br />...</pre>  | 
|  Variablenschrittdefinition  |  Die Definition eines Schritts im Runbook wird anhand von Variablen zusammengestellt.  |  <pre>...<br /><br />"mainSteps": [<br />    {<br />      "name": "LaunchInstance",<br />      "action": "aws:runInstances",<br />      "{{attemptModel}}": 1,<br />      "onFailure": "Continue",<br />      "inputs": {<br />        "ImageId": "ami-12345678",<br />        "MinInstanceCount": 1,<br />        "MaxInstanceCount": 2<br />      }<br /><br />...<br /><br />User supplies input : { "attemptModel" : "minAttempts" } </pre>  | 
|  Querverweise auf Runbook-Parameter  |  Der Benutzer liefert zur Startzeit einen Eingabeparameter, der ein Verweis auf einen anderen Parameter im Runbook ist.  |  <pre>...<br />"parameters": {<br />    "amiId": {<br />      "type": "String",<br />      "default": "ami-7f2e6015",<br />      "description": "list of commands to run as part of first step"<br />    },<br />    "alternateAmiId": {<br />      "type": "String",<br />      "description": "The alternate AMI to try if this first fails".<br /><br />"default" : "{{amiId}}"<br />    },<br /><br />... </pre>  | 
|  Multi-Level-Expansion  |  Das Runbook definiert eine Variable, die den Namen einer Variablen ergibt. Dieser befindet sich in den Variablentrennzeichen (d. h. *\$1\$1 \$1\$1*) und wird auf den Wert dieser Variable/dieses Parameters erweitert.  |  <pre>...<br />  "parameters": {<br />    "firstParameter": {<br />      "type": "String",<br />      "default": "param2",<br />      "description": "The parameter to reference"<br />    },<br />    "secondParameter": {<br />      "type": "String",<br />      "default" : "echo {Hello world}",<br />      "description": "What to run"<br />    }<br />  },<br />  "mainSteps": [{<br />      "name": "runFixedCmds",<br />      "action": "aws:runCommand",<br />      "maxAttempts": 1,<br />      "onFailure": "Continue",<br />      "inputs": {<br />        "DocumentName": "AWS-RunPowerShellScript",<br /><br />"InstanceIds" : "{{LaunchInstance.InstanceIds}}",<br />        "Parameters": {<br />          "commands": [ "{{ {{firstParameter}} }}"]<br /><br />}<br /><br />...<br /><br />Note: The customer intention here would be to run a command of "echo {Hello world}" </pre>  | 
|  Verweis auf die Ausgabe aus einem Runbook-Schritt, bei dem es sich um einen anderen Variablentyp handelt  |  Der Benutzer verweist auf die Ausgabe eines vorherigen Runbook-Schritts in einem späteren Schritt. Die Ausgabe ist ein Variablentyp, der nicht den Anforderungen der Aktion des nachfolgenden Schritts erfüllt.  |  <pre>...<br />mainSteps:<br />- name: getImageId<br />  action: aws:executeAwsApi<br />  inputs:<br />    Service: ec2<br />    Api: DescribeImages<br />    Filters:  <br />    - Name: "name"<br />      Values: <br />      - "{{ImageName}}"<br />  outputs:<br />  - Name: ImageIdList<br />    Selector: "$.Images"<br />    Type: "StringList"<br />- name: copyMyImages<br />  action: aws:copyImage<br />  maxAttempts: 3<br />  onFailure: Abort<br />  inputs:<br />    SourceImageId: {{getImageId.ImageIdList}}<br />    SourceRegion: ap-northeast-2<br />    ImageName: Encrypted Copies of LAMP base AMI in ap-northeast-2<br />    Encrypted: true <br />... <br />Note: You must provide the type required by the Automation action. <br />In this case, aws:copyImage requires a "String" type variable but the preceding step outputs a "StringList" type variable.<br />                                        </pre>  |