• Das AWS Systems Manager CloudWatch Dashboard wird nach dem 30. April 2026 nicht mehr verfügbar sein. Kunden können die CloudWatch Amazon-Konsole weiterhin verwenden, um ihre CloudWatch Amazon-Dashboards anzuzeigen, 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.

# Verwenden von Aktionsausgaben als Eingaben
<a name="automation-action-outputs-inputs"></a>

Verschiedene Automatisierungs-Aktionen geben vordefinierte Ausgaben zurück. Sie können diese Ausgaben mithilfe des Formats `{{{{stepName}}.{{outputName}}}}` als Eingaben an spätere Schritte in Ihrem Runbook übergeben. Sie können benutzerdefinierte Ausgaben für Automatisierungs-Aktionen in Ihren Runbooks definieren. Auf diese Weise können Sie Skripts ausführen oder API-Operationen für ein anderes AWS-Services Mal aufrufen, sodass Sie die Werte als Eingaben für spätere Aktionen wiederverwenden können. Parametertypen in Runbooks sind statisch. Dies bedeutet, dass der Parametertyp nicht geändert werden kann, nachdem er definiert wurde. Um eine Schrittausgabe zu definieren, geben Sie die folgenden Felder an:
+ Name: (Erforderlich) Der Ausgabename, der in späteren Schritten verwendet wird, um auf den Ausgabewert zu verweisen.
+ Selektor: (Erforderlich) Der JSONPath-Ausdruck, der verwendet wird, um den Ausgabewert zu bestimmen.
+ Typ: (Optional) Der Datentyp des Werts, der vom Auswahlfeld zurückgegeben wird. Gültige Typwerte sind `String`, `Integer`, `Boolean`, `StringList`, `StringMap`, `MapList`. Der Standardwert ist `String`.

Wenn der Wert einer Ausgabe nicht dem von Ihnen angegebenen Datentyp entspricht, versucht Automation, den Datentyp zu konvertieren. Wenn der zurückgegebene Wert beispielsweise ein `Integer` ist, der angegebene `Type` jedoch ein `String` ist, ist der endgültige Ausgabewert ein `String`-Wert. Die folgenden Typkonvertierungen werden unterstützt:
+ `String`-Werte können in `StringList`, `Integer` und `Boolean` umgewandelt werden.
+ `Integer`-Werte können in `String` und `StringList` umgewandelt werden.
+ `Boolean`-Werte können in `String` und `StringList` umgewandelt werden.
+ `StringList`-, `IntegerList`-, oder `BooleanList`-Werte, die ein Element enthalten, können in `String`, `Integer` oder `Boolean` umgewandelt werden.

Bei der Verwendung von Parametern oder Ausgaben mit Automatisierungs-Aktionen kann der Datentyp nicht dynamisch innerhalb der Eingabe einer Aktion geändert werden.

Hier ist ein Beispiel-Runbook, das veranschaulicht, wie Sie Aktionsausgaben definieren und auf den Wert als Eingabe für eine spätere Aktion verweisen. Die Runbooks tun Folgendes:
+ Verwendet die `aws:executeAwsApi` Aktion, um den Amazon DescribeImages EC2-API-Vorgang aufzurufen, um den Namen eines bestimmten Windows Server 2016 abzurufen. AMI Es gibt die Image-ID als `ImageId` aus.
+ Verwendet die `aws:executeAwsApi` Aktion, um den Amazon RunInstances EC2-API-Vorgang aufzurufen, um eine Instance zu starten, die den `ImageId` aus dem vorherigen Schritt verwendet. Es gibt die Instance-ID als `InstanceId` aus.
+ Verwendet die ` aws:waitForAwsResourceProperty` Aktion, um den Amazon DescribeInstanceStatus EC2-API-Vorgang abzufragen und darauf zu warten, dass die Instance den `running` Status erreicht. Die Aktion endet nach 60 Sekunden durch Timeout. Der Schritt endet durch Timeout, wenn die Instance nach 60 Sekunden Abfrage nicht den Status `running` erreicht.
+ Verwendet die `aws:assertAwsResourceProperty`-Aktion zum Aufrufen der Amazon EC2 `DescribeInstanceStatus`-API-Operation, um geltend zu machen, dass sich die Instance im `running`-Zustand befindet. Der Schritt schlägt fehl, wenn der Status der Instance nicht `running` ist.

```
---
description: Sample runbook using AWS API operations
schemaVersion: '0.3'
assumeRole: "{{ AutomationAssumeRole }}"
parameters:
  AutomationAssumeRole:
    type: String
    description: "(Optional) The ARN of the role that allows Automation to perform the actions on your behalf."
    default: ''
  ImageName:
    type: String
    description: "(Optional) Image Name to launch EC2 instance with."
    default: "Windows_Server-2022-English-Full-Base*"
mainSteps:
- name: getImageId
  action: aws:executeAwsApi
  inputs:
    Service: ec2
    Api: DescribeImages
    Filters:  
    - Name: "name"
      Values: 
      - "{{ ImageName }}"
  outputs:
  - Name: ImageId
    Selector: "$.Images[0].ImageId"
    Type: "String"
- name: launchOneInstance
  action: aws:executeAwsApi
  inputs:
    Service: ec2
    Api: RunInstances
    ImageId: "{{ getImageId.ImageId }}"
    MaxCount: 1
    MinCount: 1
  outputs:
  - Name: InstanceId
    Selector: "$.Instances[0].InstanceId"
    Type: "String"
- name: waitUntilInstanceStateRunning
  action: aws:waitForAwsResourceProperty
  timeoutSeconds: 60
  inputs:
    Service: ec2
    Api: DescribeInstanceStatus
    InstanceIds:
    - "{{ launchOneInstance.InstanceId }}"
    PropertySelector: "$.InstanceStatuses[0].InstanceState.Name"
    DesiredValues:
    - running
- name: assertInstanceStateRunning
  action: aws:assertAwsResourceProperty
  inputs:
    Service: ec2
    Api: DescribeInstanceStatus
    InstanceIds:
    - "{{ launchOneInstance.InstanceId }}"
    PropertySelector: "$.InstanceStatuses[0].InstanceState.Name"
    DesiredValues:
    - running
outputs:
- "launchOneInstance.InstanceId"
...
```

Mit jeder der zuvor beschriebenen Automatisierungsaktionen können Sie eine bestimmte API-Operation aufrufen, indem Sie den Service-Namespace, den Namen der API-Operation, die Eingabeparameter und die Ausgabeparameter angeben. Eingaben werden von der ausgewählten API-Operation bestimmt. 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).

Sie können das Schema für jede Automatisierungsaktion an den folgenden Orten anzeigen:
+ [`aws:assert AwsResourceProperty` — Bestätigt eine AWS Ressourcenstatus oder Ereignisstatus](automation-action-assertAwsResourceProperty.md)
+ [`aws:execute AwsApi` — Aufrufen und ausführen AWS API-Operationen](automation-action-executeAwsApi.md)
+ [`aws:wait ForAwsResourceProperty — Warte` auf einen AWS Ressourceneigenschaften](automation-action-waitForAwsResourceProperty.md)

Die Schemata umfassen Beschreibungen der erforderlichen Felder für jede Aktion.

**Verwenden der Felder Selector/PropertySelector**  
Jede Automatisierungsaktion erfordert, dass Sie entweder eine Ausgabe `Selector` (für `aws:executeAwsApi`) oder einen `PropertySelector` (für `aws:assertAwsResourceProperty` und `aws:waitForAwsResourceProperty`) enthalten. Diese Felder werden verwendet, um die JSON-Antwort aus einer AWS API-Operation zu verarbeiten. Diese Felder verwenden Sie die JSONPath-Syntax.

Hier finden Sie ein Beispiel, das dieses Konzept für die Aktion `aws:executeAwsAPi` erläutert.

```
---
mainSteps:
- name: getImageId
  action: aws:executeAwsApi
  inputs:
    Service: ec2
    Api: DescribeImages
    Filters:  
      - Name: "name"
        Values: 
          - "{{ ImageName }}"
  outputs:
    - Name: ImageId
      Selector: "$.Images[0].ImageId"
      Type: "String"
...
```

Im `aws:executeAwsApi`-Schritt`getImageId` ruft die Automatisierung die `DescribeImages`-API-Operation auf und empfängt eine Antwort von `ec2`. Die Automatisierung wendet dann `Selector - "$.Images[0].ImageId"` auf die API-Antwort an und weist der `ImageId`-Ausgabevariablen den ausgewählten Wert zu. Weitere Schritte in dieser Automatisierung können den Wert von `ImageId` verwenden, indem `"{{ getImageId.ImageId }}"` angegeben wird.

Hier finden Sie ein Beispiel, das dieses Konzept für die Aktion `aws:waitForAwsResourceProperty` erläutert.

```
---
- name: waitUntilInstanceStateRunning
  action: aws:waitForAwsResourceProperty
  # timeout is strongly encouraged for action - aws:waitForAwsResourceProperty
  timeoutSeconds: 60
  inputs:
    Service: ec2
    Api: DescribeInstanceStatus
    InstanceIds:
    - "{{ launchOneInstance.InstanceId }}"
    PropertySelector: "$.InstanceStatuses[0].InstanceState.Name"
    DesiredValues:
    - running
...
```

Im `aws:waitForAwsResourceProperty`-Schritt`waitUntilInstanceStateRunning` ruft die Automatisierung die `DescribeInstanceStatus`-API-Operation auf und empfängt eine Antwort von `ec2`. Die Automatisierung wendet dann `PropertySelector - "$.InstanceStatuses[0].InstanceState.Name"` auf die Antwort an und prüft, ob der angegebene zurückgegebene Wert einem Wert in der Liste `DesiredValues` entspricht (in diesem Fall `running`). Der Schritt wiederholt den Prozess, bis die Antwort den Instance-Status `running` zurückgibt. 

## Verwenden von JSONPath in Runbooks
<a name="automation-action-json-path"></a>

Ein JSONPath-Ausdruck ist eine Zeichenfolge, die mit „$“ beginnt. die zur Auswahl einer oder mehrerer Komponenten in einem JSON-Element verwendet wird. Die folgende Liste enthält Informationen zu JSONPath-Operatoren, die von Systems Manager Automation unterstützt werden:
+ **Dot-notated Kind (.) **: Mit einem JSON-Objekt verwenden. Dieser Operator wählt den Wert eines bestimmten Schlüssels aus.
+ **Deep-scan (..) **: Mit einem JSON-Element verwenden. Dieser Operator untersucht das JSON-Element Ebene für Ebene und wählt eine Liste von Werten mit dem spezifischen Schlüssel aus. Der Rückgabetyp dieses Operators ist immer ein JSON-Array. Im Kontext eines Ausgabetyps einer Automatisierungsaktion kann der Operator entweder StringList oder sein MapList.
+ **Array-Index ([])**: Wird mit einem JSON-Array verwendet. Dieser Operator ruft den Wert eines bestimmten Index ab.
+ **Filter ([? ({{expression}})])**: Wird mit einem JSON-Array verwendet. Dieser Operator filtert JSON-Array-Werte, die den im Filterausdruck definierten Kriterien entsprechen. Filterausdrücke können nur die folgenden Operatoren verwenden: ==,\! =, >, <, >= oder <=. Die Kombination mehrerer Filterausdrücke mit AND (&&) oder OR (\|\|) wird nicht unterstützt. Der Rückgabetyp dieses Operators ist immer ein JSON-Array. 

Sehen Sie sich zum besseren Verständnis der JSONPath-Operatoren die folgende JSON-Antwort von der ec2-API-Operation `DescribeInstances` an. Unter dieser Antwort sehen Sie verschiedene Beispiele mit unterschiedlichen Ergebnissen durch die Verwendung verschiedener JSONPath-Ausdrücke für die Antwort von der API-Operation `DescribeInstances`.

```
{
    "NextToken": "abcdefg",
    "Reservations": [
        {
            "OwnerId": "123456789012",
            "ReservationId": "r-abcd12345678910",
            "Instances": [
                {
                    "ImageId": "ami-12345678",
                    "BlockDeviceMappings": [
                        {
                            "Ebs": {
                                "DeleteOnTermination": true,
                                "Status": "attached",
                                "VolumeId": "vol-000000000000"
                            },
                            "DeviceName": "/dev/xvda"
                        }
                    ],
                    "State": {
                        "Code": 16,
                        "Name": "running"
                    }
                }
            ],
            "Groups": []
        },
        {
            "OwnerId": "123456789012",
            "ReservationId": "r-12345678910abcd",
            "Instances": [
                {
                    "ImageId": "ami-12345678",
                    "BlockDeviceMappings": [
                        {
                            "Ebs": {
                                "DeleteOnTermination": true,
                                "Status": "attached",
                                "VolumeId": "vol-111111111111"
                            },
                            "DeviceName": "/dev/xvda"
                        }
                    ],
                    "State": {
                        "Code": 80,
                        "Name": "stopped"
                    }
                }
            ],
            "Groups": []
        }
    ]
}
```

**JSONPath-Beispiel 1: Abrufen einer bestimmten Zeichenfolge aus einer JSON-Antwort**

```
JSONPath: 
$.Reservations[0].Instances[0].ImageId 

Returns:
"ami-12345678"

Type: String
```

**JSONPath-Beispiel 2: Abrufen eines bestimmten booleschen Werts aus einer JSON-Antwort**

```
JSONPath:
$.Reservations[0].Instances[0].BlockDeviceMappings[0].Ebs.DeleteOnTermination
        
Returns:
true

Type: Boolean
```

**JSONPath-Beispiel 3: Abrufen einer bestimmten Ganzzahl aus einer JSON-Antwort**

```
JSONPath:
$.Reservations[0].Instances[0].State.Code
        
Returns:
16

Type: Integer
```

**JSONPath Beispiel 4: Scannen Sie eine JSON-Antwort gründlich und rufen Sie dann alle Werte für VolumeId als ab StringList ** 

```
JSONPath:
$.Reservations..BlockDeviceMappings..VolumeId
        
Returns:
[
   "vol-000000000000",
   "vol-111111111111"
]

Type: StringList
```

**JSONPath-Beispiel 5: Holen Sie sich ein bestimmtes Objekt als BlockDeviceMappings StringMap **

```
JSONPath:
$.Reservations[0].Instances[0].BlockDeviceMappings[0]
        
Returns:
{
   "Ebs" : {
      "DeleteOnTermination" : true,
      "Status" : "attached",
      "VolumeId" : "vol-000000000000"
   },
   "DeviceName" : "/dev/xvda"
}

Type: StringMap
```

**JSONPath-Beispiel 6: Eine JSON-Antwort gründlich scannen und dann alle State-Objekte als abrufen MapList **

```
JSONPath:
$.Reservations..Instances..State 
    
Returns:
[
   {
      "Code" : 16,
      "Name" : "running"
   },
   {
      "Code" : 80,
      "Name" : "stopped"
   }
]

Type: MapList
```

**JSONPath Beispiel 7: Nach Instances im Status `running` filtern**

```
JSONPath:
$.Reservations..Instances[?(@.State.Name == 'running')]

Returns:
[
  {
    "ImageId": "ami-12345678",
    "BlockDeviceMappings": [
      {
        "Ebs": {
          "DeleteOnTermination": true,
          "Status": "attached",
          "VolumeId": "vol-000000000000"
        },
        "DeviceName": "/dev/xvda"
      }
    ],
    "State": {
      "Code": 16,
      "Name": "running"
    }
  }
]

Type: MapList
```

**JSONPath Beispiel 8: Gibt die `ImageId` der Instances zurück, die sich nicht im `running`-Status befinden**

```
JSONPath:
$.Reservations..Instances[?(@.State.Name != 'running')].ImageId

Returns:
[
  "ami-12345678"
]

Type: StringList | String
```