• La AWS Systems Manager CloudWatch dashboard non sarà più disponibile dopo il 30 aprile 2026. I clienti possono continuare a utilizzare la CloudWatch console Amazon per visualizzare, creare e gestire le proprie CloudWatch dashboard Amazon, proprio come fanno oggi. Per ulteriori informazioni, consulta la [documentazione di Amazon CloudWatch Dashboard](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Dashboards.html). 

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Utilizzo degli output delle operazioni come input
<a name="automation-action-outputs-inputs"></a>

Diverse operazioni di automazione restituiscono output predefiniti. Puoi passare questi output come input ai passaggi successivi nel runbook usando il formato `{{stepName.outputName}}`. Puoi inoltre definire output personalizzati per varie operazioni di automazione nei tuoi runbook. Ciò consente di eseguire script o richiamare operazioni API per altre Servizi AWS volte in modo da poter riutilizzare i valori come input nelle azioni successive. I tipi di parametri nei runbook sono statici. Ciò significa che il tipo di parametro non può essere modificato dopo che è stato definito. Per definire l'output di un passaggio, completa i seguenti campi:
+ Nome (obbligatorio): il nome dell'output utilizzato per fare riferimento al valore di output nei passaggi successivi.
+ Selettore: (Obbligatorio) L' JSONPath espressione utilizzata per determinare il valore di output.
+ Tipo: (facoltativo) il tipo di dati del valore restituito dal campo del selettore. I valori di tipo validi sono `String`, `Integer`, `Boolean`, `StringList`, `StringMap`, `MapList`. Il valore predefinito è `String`.

Se il valore di un output non corrisponde al tipo di dati specificato, Automation prova a convertire il tipo di dati. Ad esempio, se il valore restituito è un `Integer`, ma il `Type` specificato è `String`, allora il valore dell'output finale è un valore `String`. Sono supportati i seguenti tipi di conversione:
+ I valori `String` possono essere convertiti in `StringList`, `Integer` e `Boolean`.
+ I valori `Integer` possono essere convertiti in `String`, e `StringList`.
+ I valori `Boolean` possono essere convertiti in `String`, e `StringList`.
+ I valori `StringList`, `IntegerList` o `BooleanList` contenenti un elemento possono essere convertiti in `String``Integer` o `Boolean`.

Quando si utilizzano parametri o output con operazioni di automazione, il tipo di dati non può essere modificato dinamicamente all'interno dell'input di un'operazione.

Di seguito è riportato un runbook di esempio che illustra come definire gli output delle operazioni e come utilizzare tale valore come input per un'operazione successiva. l runbook eseguono le operazioni seguenti:
+ Utilizza l'`aws:executeAwsApi`azione per richiamare l'operazione dell' DescribeImages API Amazon EC2 per ottenere il nome di uno specifico Windows Server 2016. AMI Restituisce l'ID immagine come `ImageId`.
+ Utilizza l'`aws:executeAwsApi`azione per richiamare l'operazione dell' RunInstances API Amazon EC2 per avviare un'istanza che utilizza l'operazione del `ImageId` passaggio precedente. Restituisce l'ID di istanza come `InstanceId`.
+ Utilizza l'` aws:waitForAwsResourceProperty`azione per eseguire il polling dell'operazione dell'API Amazon DescribeInstanceStatus EC2 per attendere che l'istanza `running` raggiunga lo stato. Il timeout dell'operazione è pari a 60 secondi. Si verifica il timeout della fase se l'istanza non raggiunge lo stato `running` dopo 60 secondi dall'avvio del polling.
+ Utilizza l'operazione `aws:assertAwsResourceProperty` per chiamare l'operazione API `DescribeInstanceStatus` di Amazon EC2 per affermare che l'istanza si trova nello stato `running`. La fase ha esito negativo se lo stato dell'istanza non è `running`.

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

Ciascuna delle operazioni di automazione precedentemente descritte consente di chiamare un'operazione API specifica specificando il namespace del servizio, il nome dell'operazione API, i parametri di input e i parametri di output. Gli input vengono definiti dall'operazione API selezionata. Puoi visualizzare le operazioni API (definite anche metodi) scegliendo un servizio nel pannello di navigazione a sinistra nella pagina [Services Reference (Informazioni di riferimento relative ai servizi)](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/index.html). Scegliere un metodo nella sezione **Client** del servizio che si desidera chiamare. Ad esempio, tutte le operazioni API (metodi) per Amazon Relational Database Service (Amazon RDS) sono elencate nella seguente pagina: [Amazon RDS methods (Metodi di Amazon RDS)](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/rds.html).

Puoi visualizzare lo schema per ciascuna operazione di automazione nelle seguenti posizioni:
+ [`aws:assertAwsResourceProperty`— Affermare uno stato di AWS risorsa o uno stato di evento](automation-action-assertAwsResourceProperty.md)
+ [`aws:executeAwsApi`— Chiama ed esegui operazioni AWS API](automation-action-executeAwsApi.md)
+ [`aws:waitForAwsResourceProperty`— Attendi una proprietà della AWS risorsa](automation-action-waitForAwsResourceProperty.md)

Gli schemi includono le descrizioni dei campi obbligatori per l'utilizzo di ciascuna operazione.

**Utilizzo dei campi Selector/PropertySelector**  
Per ogni operazione di automazione è necessario specificare un output `Selector` (per `aws:executeAwsApi`) o un `PropertySelector` (per `aws:assertAwsResourceProperty` e `aws:waitForAwsResourceProperty`). Questi campi vengono utilizzati per elaborare la risposta JSON da un'operazione AWS API. Questi campi utilizzano la JSONPath sintassi.

Ecco un esempio che illustra questo concetto per l'operazione `aws:executeAwsAPi`.

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

Nella fase `aws:executeAwsApi` dell'elemento `getImageId`, l'automazione richiama l'operazione API `DescribeImages` e riceve una risposta da `ec2`. L'automazione applica quindi `Selector - "$.Images[0].ImageId"` alla risposta API e assegna il valore selezionato alla variabile di output `ImageId`. Altre fasi della stessa automazione possono utilizzare il valore di `ImageId` specificando `"{{ getImageId.ImageId }}"`.

Ecco un esempio che illustra questo concetto per l'operazione `aws:waitForAwsResourceProperty`:

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

Nella fase `aws:waitForAwsResourceProperty` dell'elemento `waitUntilInstanceStateRunning`, l'automazione richiama l'operazione API `DescribeInstanceStatus` e riceve una risposta da `ec2`. L'automazione applica quindi `PropertySelector - "$.InstanceStatuses[0].InstanceState.Name"` alla risposta e verifica se il valore restituito specificato corrisponde a un valore nell'elenco `DesiredValues` (in questo caso `running`). La fase ripete il processo finché la risposta non restituisce lo stato di istanza `running`. 

## Utilizzo JSONPath nei runbook
<a name="automation-action-json-path"></a>

Un' JSONPath espressione è una stringa che inizia con «\$1». utilizzato per selezionare uno o più componenti all'interno di un elemento JSON. L'elenco seguente include informazioni sugli JSONPath operatori supportati da Systems Manager Automation:
+ **Dot-notated child (.)**: da utilizzare con un oggetto JSON. Questo operatore seleziona il valore di una chiave specifica.
+ **Deep-scan (..)**: da utilizzare con un elemento JSON. Questo operatore analizza il livello dell'elemento JSON per livello e seleziona un elenco di valori con la chiave specificata. Si noti che il tipo restituito di questo operatore è sempre un array JSON. Nel contesto di un tipo di output di un'azione di automazione, l'operatore può essere uno StringList o MapList.
+ **Array-Index ([ ])**: da utilizzare con un array JSON. Questo operatore recupera il valore di un indice specifico.
+ **Filtro ([? (*expression*)])**: da utilizzare con un array JSON. Questo operatore filtra i valori dell'array JSON che corrispondono ai criteri definiti nell'espressione del filtro. Le espressioni di filtro possono utilizzare solo i seguenti operatori: ==, \$1=, >, <, >= o <=. La combinazione di più espressioni di filtro con AND (&&) o OR (\$1\$1) non è supportata. Si noti che il tipo restituito di questo operatore è sempre un array JSON. 

Per comprendere meglio JSONPath gli operatori, consulta la seguente risposta JSON dell'operazione dell'API ec2`DescribeInstances`. Di seguito sono riportati diversi esempi che mostrano risultati diversi applicando JSONPath espressioni diverse alla risposta dell'operazione `DescribeInstances` API.

```
{
    "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 Esempio 1: ottieni una stringa specifica da una risposta JSON**

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

Returns:
"ami-12345678"

Type: String
```

**JSONPath Esempio 2: ottieni un booleano specifico da una risposta JSON**

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

Type: Boolean
```

**JSONPath Esempio 3: ottieni un numero intero specifico da una risposta JSON**

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

Type: Integer
```

**JSONPath Esempio 4: scansiona in profondità una risposta JSON, quindi ottieni tutti i valori per VolumeId StringList** 

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

Type: StringList
```

**JSONPath Esempio 5: ottieni un BlockDeviceMappings oggetto specifico come StringMap**

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

Type: StringMap
```

**JSONPath Esempio 6: scansiona in profondità una risposta JSON, quindi ottieni tutti gli oggetti State come MapList**

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

Type: MapList
```

**JSONPath Esempio 7: filtro per le istanze nello stato `running`**

```
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 Esempio 8: restituisce `ImageId` le istanze che non si trovano nello stato `running`**

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

Returns:
[
  "ami-12345678"
]

Type: StringList | String
```