

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

# In che modo Image Builder utilizza l' AWS Task Orchestrator and Executor applicazione per gestire i componenti
<a name="toe-component-manager"></a>

EC2 Image Builder utilizza l'applicazione AWS Task Orchestrator and Executor (AWSTOE) per orchestrare flussi di lavoro complessi, modificare le configurazioni di sistema e testare le immagini senza la necessità di script o codice DevOps aggiuntivi. Questa applicazione gestisce ed esegue componenti che implementano lo schema dichiarativo del documento.

AWSTOE è un'applicazione autonoma che Image Builder installa nelle sue istanze di build e test quando si crea un'immagine. È inoltre possibile installarla manualmente sulle EC2 istanze per creare componenti personalizzati. Non richiede alcuna configurazione aggiuntiva e può essere eseguito anche in locale.

**Topics**
+ [AWSTOE scarica](#toe-downloads)
+ [Regioni supportate](#toe-supported-regions)
+ [AWSTOE riferimento al comando](#toe-commands)
+ [Configurazione manuale per sviluppare componenti personalizzati con AWSTOE](toe-get-started.md)
+ [Usa il framework AWSTOE dei documenti dei componenti per i componenti personalizzati](toe-use-documents.md)
+ [Moduli di azione supportati dal gestore AWSTOE dei componenti](toe-action-modules.md)
+ [Configurare l'input per il comando AWSTOE run](toe-run-config-input.md)

## AWSTOE scarica
<a name="toe-downloads"></a>

Per l'installazione AWSTOE, scegli il link per il download adatto alla tua architettura e piattaforma. Se ti colleghi a un endpoint VPC per il tuo servizio (Image Builder, ad esempio), devi allegare una policy endpoint personalizzata che includa l'accesso al bucket S3 per i download. AWSTOE In caso contrario, le istanze di build e test non saranno in grado di scaricare lo script bootstrap () e installare l'applicazione. `bootstrap.sh` AWSTOE Per ulteriori informazioni, consulta [Crea una policy per gli endpoint VPC per Image Builder](vpc-interface-endpoints.md#vpc-endpoint-policy).

**Importante**  
AWS sta eliminando gradualmente il supporto per le versioni TLS 1.0 e 1.1. Per accedere al bucket S3 per i AWSTOE download, il software client deve utilizzare la versione TLS 1.2 o successiva. Per ulteriori informazioni, consulta questo post sul blog [AWS sulla sicurezza](https://aws.amazon.com/blogs/security/tls-1-2-required-for-aws-endpoints/).


| Architettura | Piattaforma | Collegamento per il download | Esempio | 
| --- | --- | --- | --- | 
| 386 |  AL 2 e 2023 RHEL 7, 8 e 9 Ubuntu 16.04, 18.04, 20.04, 22.04 e 24.04 CentOS 7 e 8 SUSE 12 e 15  | `https://awstoe-<region>.s3.<region>.amazonaws.com/latest/linux/386/awstoe`  | [https://awstoe-us-east-1.s3.us-east-1.amazonaws.com/latest/linux/386/awstoe](https://awstoe-us-east-1.s3.us-east-1.amazonaws.com/latest/linux/386/awstoe) | 
| AMD64 |  AL 2 e 2023 RHEL 7, 8 e 9 Ubuntu 16.04, 18.04, 20.04, 22.04 e 24.04 CentOS 7 e 8 CentOS Stream 8 SUSE 12 e 15  | https://awstoe-<region>.s3.<region>.amazonaws.com/latest/linux/amd64/awstoe | [https://awstoe-us-east-1.s3.us-east-1.amazonaws.com/latest/linux/amd64/awstoe](https://awstoe-us-east-1.s3.us-east-1.amazonaws.com/latest/linux/amd64/awstoe) | 
| AMD64 |  macOS 10.14.x (Mojave), 10.15.x (Catalina), 11.x (Big Sur), 12.x (Monterey)  | https://awstoe-region.s3.region.amazonaws.com/latest/darwin/amd64/awstoe | [https://awstoe-us-east-1.s3.us-east-1.amazonaws.com/latest/darwin/amd64/awstoe](https://awstoe-us-east-1.s3.us-east-1.amazonaws.com/latest/darwin/amd64/awstoe) | 
|  AMD64  |  Windows Server 2012 R2, 2016, 2019 e 2022  |   `https://awstoe-<region>.s3.<region>.amazonaws.com/latest/windows/amd64/awstoe.exe`  | [https://awstoe-us-east-1.s3.us-east-1.amazonaws.com/latest/windows/amd64/awstoe.exe](https://awstoe-us-east-1.s3.us-east-1.amazonaws.com/latest/windows/amd64/awstoe.exe) | 
| ARM64 |  AL 2 e 2023 RHEL 7, 8 e 9 Ubuntu 16.04, 18.04, 20.04, 22.04 e 24.04 CentOS 7 e 8 CentOS Stream 8 SUSE 12 e 15  | https://awstoe-<region>.s3.<region>.amazonaws.com/latest/linux/arm64/awstoe | [https://awstoe-us-east-1.s3.us-east-1.amazonaws.com/latest/linux/arm64/awstoe](https://awstoe-us-east-1.s3.us-east-1.amazonaws.com/latest/linux/arm64/awstoe) | 

## Regioni supportate
<a name="toe-supported-regions"></a>

AWSTOE è supportata come applicazione autonoma nelle seguenti regioni.


| Regione AWS nome | Regione AWS | 
| --- | --- | 
|  Stati Uniti orientali (Ohio)  |  us-east-2  | 
|  US East (N. Virginia)  |  us-east-1  | 
|  AWS GovCloud (Stati Uniti orientali)  |  us-gov-east-1  | 
|  AWS GovCloud (Stati Uniti occidentali)  |  us-gov-west-1  | 
|  US West (N. California)  | us-west-1 | 
|  US West (Oregon)  | us-west-2 | 
|  Africa (Cape Town)  | af-south-1 | 
|  Asia Pacifico (Hong Kong)  | ap-east-1 | 
|  Asia Pacifico (Osaka-Locale)  | ap-northeast-3 | 
|  Asia Pacifico (Seoul)  | ap-northeast-2 | 
|  Asia Pacifico (Mumbai)  | ap-south-1 | 
|  Asia Pacific (Hyderabad)  | ap-south-2 | 
|  Asia Pacific (Singapore)  | ap-southeast-1 | 
|  Asia Pacific (Sydney)  | ap-southeast-2 | 
|  Asia Pacifico (Giacarta)  | ap-southeast-3 | 
|  Asia Pacifico (Tokyo)  | ap-northeast-1 | 
|  Canada (Central)  | ca-central-1 | 
|  Europa (Francoforte)  | eu-central-1 | 
|  Europa (Zurigo)  | eu-central-2 | 
|  Europa (Stoccolma)  | eu-north-1 | 
|  Europa (Milano)  | eu-south-1 | 
|  Europa (Spagna)  | eu-south-2 | 
|  Europa (Irlanda)  | eu-west-1 | 
|  Europe (London)  | eu-west-2 | 
|  Europe (Paris)  | eu-west-3 | 
|  Israele (Tel Aviv)  | il-central-1 | 
|  Medio Oriente (Emirati Arabi Uniti)  | me-central-1 | 
|  Medio Oriente (Bahrein)  | me-south-1 | 
|  Sud America (São Paulo)  | sa-east-1 | 
|  China (Beijing)  | cn-north-1 | 
|  China (Ningxia)  | cn-northwest-1 | 

## AWSTOE riferimento al comando
<a name="toe-commands"></a>

AWSTOE è un'applicazione di gestione dei componenti a riga di comando che viene eseguita su EC2 istanze Amazon. Quando Image Builder avvia un'istanza di EC2 build o di test, viene installata sull'istanza. AWSTOE Quindi esegue AWSTOE i comandi AWS CLI per installare o convalidare i componenti specificati nell'immagine o nella ricetta del contenitore.

**Nota**  
Alcuni moduli di AWSTOE azione richiedono autorizzazioni elevate per essere eseguiti su un server Linux. Per utilizzare autorizzazioni elevate, inserisci come prefisso la sintassi del comando o esegui **sudo** il **sudo su** comando una sola volta quando accedi prima di eseguire i comandi collegati di seguito. Per ulteriori informazioni sui moduli di AWSTOE azione, vedere. [Moduli di azione supportati dal gestore AWSTOE dei componenti](toe-action-modules.md)

***[run](#cmd-run)***  
Utilizzate il **run** comando per eseguire gli script dei documenti YAML per uno o più documenti componenti.

***[validate](#cmd-validate)***  
Esegui il **validate** comando per convalidare la sintassi del documento YAML per uno o più documenti componenti.

### comando awstoe run
<a name="cmd-run"></a>

Questo comando esegue gli script dei documenti dei componenti YAML nell'ordine in cui sono inclusi nel file di configurazione specificato dal `--config` parametro o nell'elenco dei documenti dei componenti specificato dal parametro. `--documents`

**Nota**  
È necessario specificare esattamente uno dei seguenti parametri, mai entrambi:  
--config  
--documenti

#### Sintassi
<a name="run-syntax"></a>

```
awstoe run [--config <file path>] [--cw-ignore-failures <?>] 
      [--cw-log-group <?>] [--cw-log-region us-west-2] [--cw-log-stream <?>] 
      [--document-s3-bucket-owner <owner>] [--documents <file path,file path,...>] 
      [--execution-id <?>] [--log-directory <file path>] 
      [--log-s3-bucket-name <name>] [--log-s3-bucket-owner <owner>] 
      [--log-s3-key-prefix <?>] [--parameters name1=value1,name2=value2...] 
      [--phases <phase name>] [--state-directory <directory path>] [--version <?>] 
      [--help] [--trace]
```

#### Parametri e opzioni
<a name="run-parameters"></a>Parametri

**--config *`./config-example.json`***  
Forma breve: -c *`./config-example.json`*  
Il file di configurazione *(condizionale*). Questo parametro contiene la posizione del file JSON che contiene le impostazioni di configurazione per i componenti in esecuzione con questo comando. Se si specificano le impostazioni dei **run** comandi in un file di configurazione, non è necessario specificare il `--documents` parametro. Per ulteriori informazioni sulla configurazione degli input, vedere[Configurare l'input per il comando AWSTOE run](toe-run-config-input.md).  
Le località valide includono:  
+ Un percorso di file locale (*`./config-example.json`*)
+ Un URI S3 () `s3://bucket/key`

**--cw-ignore-failures**  
Forma breve: N/A  
Ignora gli errori di registrazione nei registri. CloudWatch 

**--cw-log-group**  
Forma breve: N/A  
Il `LogGroup` nome dei registri. CloudWatch 

**--cw-log-region**  
Forma breve: N/A  
La AWS regione che si applica ai registri. CloudWatch 

**--cw-log-stream**  
Forma breve: N/A  
Il `LogStream` nome dei CloudWatch log, che indica AWSTOE dove trasmettere il file. `console.log`

**--document-s3-bucket-owner**  
Forma breve: N/A  
L'ID dell'account del proprietario del bucket per i documenti basati su URI S3.

**--documenti *`./doc-1.yaml`,`./doc-n.yaml`***  
Forma breve: -d, *`./doc-1.yaml`* *`./doc-n`*  
I documenti componenti *(condizionali*). Questo parametro contiene un elenco separato da virgole di posizioni di file per l'esecuzione dei documenti del componente YAML. Se si specificano documenti YAML per il **run** comando utilizzando il `--documents` parametro, non è necessario specificare il parametro. `--config`  
Le posizioni valide includono:  
+ percorsi di file locali (*./component-doc-example.yaml*).
+ S3 URIs (`s3://bucket/key`).
+ Versione di build del componente Image Builder ARNs (arn:aws:imagebuilder:us-west--- /2021.12.02/1). *2:123456789012* *my-example-component*
Non ci sono spazi tra gli elementi nell'elenco, solo virgole.

**--execution-id**  
Forma breve: -i  
Questo è l'ID univoco che si applica all'esecuzione del **run** comando corrente. Questo ID è incluso nei nomi dei file di output e di registro, per identificare in modo univoco tali file e collegarli all'esecuzione corrente del comando. Se questa impostazione viene omessa, AWSTOE genera un GUID.

**--log-directory**  
Forma breve: -l  
La directory di destinazione in cui vengono AWSTOE archiviati tutti i file di registro dell'esecuzione di questo comando. Per impostazione predefinita, questa directory si trova all'interno della seguente directory principale:`TOE_<DATETIME>_<EXECUTIONID>`. Se non si specifica la directory di registro, AWSTOE utilizza la directory di lavoro corrente (`.`).

**--log-s3-bucket-name**  
Forma breve: -b  
Se i log dei componenti sono archiviati in Amazon S3 (consigliato) AWSTOE , carica i log delle applicazioni dei componenti nel bucket S3 indicato in questo parametro.

**--log-s3-bucket-owner**  
Forma breve: N/A  
Se i log dei componenti sono archiviati in Amazon S3 (consigliato), questo è l'ID dell'account proprietario per il bucket AWSTOE in cui vengono scritti i file di registro.

**--log-s3-key-prefix**  
Forma breve: -k  
Se i log dei componenti sono archiviati in Amazon S3 (consigliato), questo è il prefisso della chiave oggetto S3 per la posizione del registro nel bucket.

**--parameters =, =... *name1* *value1* *name2* *value2***  
Forma breve: N/A  
I parametri sono variabili mutabili definite nel documento del componente, con impostazioni che l'applicazione chiamante può fornire in fase di esecuzione.

**--phases**  
Forma breve: -p  
Un elenco separato da virgole che specifica quali fasi eseguire dai documenti del componente YAML. Se un documento componente include fasi aggiuntive, queste non verranno eseguite.

**--state-directory**  
Forma breve: -s  
Il percorso del file in cui sono archiviati i file di tracciamento dello stato.

**--versione**  
Forma breve: -v  
Specifica la versione dell'applicazione del componente.Opzioni

**--help**  
Forma breve: -h  
Visualizza un manuale di aiuto per l'utilizzo delle opzioni dell'applicazione di gestione dei componenti.

**--trace**  
Forma breve: -t  
Abilita la registrazione dettagliata sulla console.

### comando awstoe validate
<a name="cmd-validate"></a>

Quando si esegue questo comando, convalida la sintassi del documento YAML per ciascuno dei documenti componenti specificati dal parametro. `--documents`

#### Sintassi
<a name="validate-syntax"></a>

```
awstoe validate [--document-s3-bucket-owner <owner>] 
      --documents <file path,file path,...> [--help] [--trace]
```

#### Parametri e opzioni
<a name="validate-parameters"></a>Parametri

**--document-s3-bucket-owner**  
Forma breve: N/A  
ID dell'account di origine dei documenti basati sull'URI S3 fornito.

**--documenti *`./doc-1.yaml`,`./doc-n.yaml`***  
Forma breve: -d, *`./doc-1.yaml`* *`./doc-n`*  
I documenti che lo compongono *(obbligatorio).* Questo parametro contiene un elenco separato da virgole delle posizioni dei file in cui eseguire i documenti del componente YAML. Le posizioni valide includono:  
+ percorsi di file locali (*./component-doc-example.yaml*)
+ S3 URIs () `s3://bucket/key`
+ Versione di build del componente Image Builder ARNs (arn:aws:imagebuilder:us-west-527/ /2021.12.02/1) *2:123456789012* *my-example-component*
Non ci sono spazi tra gli elementi nell'elenco, solo virgole.Opzioni

**--help**  
Forma breve: -h  
Visualizza un manuale di aiuto per l'utilizzo delle opzioni dell'applicazione di gestione dei componenti.

**--trace**  
Forma breve: -t  
Abilita la registrazione dettagliata sulla console.

# Configurazione manuale per sviluppare componenti personalizzati con AWSTOE
<a name="toe-get-started"></a>

L'applicazione AWS Task Orchestrator and Executor (AWSTOE) è un'applicazione autonoma che crea, convalida ed esegue comandi all'interno di un framework di definizione dei componenti. AWS i servizi possono essere utilizzati AWSTOE per orchestrare flussi di lavoro, installare software, modificare le configurazioni di sistema e testare le build di immagini.

Segui questi passaggi per installare manualmente l' AWSTOE applicazione e utilizzarla come applicazione autonoma per sviluppare componenti personalizzati. Image Builder si occupa di questi passaggi per voi, se utilizzate la console AWS CLI o i comandi di Image Builder per creare componenti personalizzati. Per ulteriori informazioni, consulta [Crea componenti personalizzati con Image Builder](create-component.md).

# Verifica la firma del download AWSTOE di installazione
<a name="awstoe-verify-sig"></a>

Questa sezione descrive la procedura consigliata per verificare la validità del download dell'installazione per i sistemi operativi basati AWSTOE su Linux, macOS e Windows.

**Topics**
+ [Verifica la firma del download dell' AWSTOE installazione su Linux o macOS](#awstoe-verify-sig-linux)
+ [Verifica la firma del download di AWSTOE installazione su Windows](#awstoe-verify-sig-win)

## Verifica la firma del download dell' AWSTOE installazione su Linux o macOS
<a name="awstoe-verify-sig-linux"></a>

Questo argomento descrive la procedura consigliata per verificare la validità del download dell'installazione per i sistemi operativi basati AWSTOE su Linux o macOS.

Ogni volta che scarichi un'applicazione da Internet, ti consigliamo di autenticare l'identità dell'editore del software. Inoltre, verificate che l'applicazione non sia stata alterata o danneggiata da quando è stata pubblicata. Ciò consente di evitare di installare una versione dell'applicazione contenente un virus o altro malware.

Se, dopo aver eseguito i passaggi descritti in questo argomento, stabilite che il software dell' AWSTOE applicazione è alterato o danneggiato, non eseguite il file di installazione. Contatta invece. Supporto Per ulteriori informazioni sulle opzioni di supporto disponibili, consulta [Supporto](https://aws.amazon.com/premiumsupport/).

AWSTOE i file per i sistemi operativi basati su Linux e macOS sono firmati utilizzando`GnuPG`, un'implementazione open source dello standard Pretty Good Privacy (OpenPGP) per le firme digitali sicure. `GnuPG`(noto anche come`GPG`) fornisce l'autenticazione e il controllo dell'integrità tramite una firma digitale. Amazon EC2 pubblica una chiave pubblica e firme che puoi utilizzare per verificare gli strumenti dell'interfaccia a riga di comando di Amazon EC2 scaricati. Per ulteriori informazioni su `PGP` e `GnuPG` (`GPG`), consulta [http://www.gnupg.org](https://www.gnupg.org/).

La prima fase prevede la verifica dell'affidabilità dell'autore del software. Scarica la chiave pubblica dell'autore del software, controlla l'autenticità di tale proprietario e quindi aggiungi la chiave pubblica al tuo *keyring*. Il keyring è una raccolta di chiavi pubbliche nota. Dopo aver confermato l'autenticità della chiave pubblica, puoi usarla per verificare la firma dell'applicazione.

**Topics**
+ [Installazione degli strumenti GPG](#awstoe-verify-signature-of-binary-download-install-tools)
+ [Autenticazione e importazione della chiave pubblica](#awstoe-verify-signature-of-binary-download-authenticate-import-public-key)
+ [Verifica della firma del pacchetto](#awstoe-verify-signature-of-binary-package)

### Installazione degli strumenti GPG
<a name="awstoe-verify-signature-of-binary-download-install-tools"></a>

Se il tuo sistema operativo è Linux, Unix o macOS, è probabile che gli strumenti GPG siano già installati. Per sapere se gli strumenti sono installati nel sistema, digita **gpg** al prompt dei comandi. Se gli strumenti GPG sono installati, viene visualizzato un prompt dei comandi GPG. Se gli strumenti GPG non sono installati, viene visualizzato un messaggio di errore che indica che il comando non è stato trovato. Puoi installare il pacchetto GnuPG da un repository.

Per installare gli strumenti GPG, seleziona il sistema operativo che corrisponde alla tua istanza.

------
#### [ Debian-based Linux ]

Da un terminale, esegui il comando seguente:

```
apt-get install gnupg
```

------
#### [ Red Hat–based Linux ]

Da un terminale, esegui il comando seguente:

```
yum install gnupg
```

------
#### [ macOS ]

Da un terminale, esegui il comando seguente:

```
brew install gnupg
```

------

### Autenticazione e importazione della chiave pubblica
<a name="awstoe-verify-signature-of-binary-download-authenticate-import-public-key"></a>

La fase successiva del processo consiste nell'autenticare la chiave AWSTOE pubblica e aggiungerla come chiave affidabile nel portachiavi. `GPG`

**Per autenticare e importare la chiave pubblica AWSTOE**

1. Recupera una copia della chiave pubblica `GPG` in uno dei modi seguenti:
   + Scarica la chiave da

      https://awstoe - **<region>** .s3. **<region>**.amazonaws. com/assets/awstoe.gpg. Ad esempio, [https://awstoe-us-east-1.s3.us-east-1.amazonaws.com/latest/assets/awstoe.gpg](https://awstoe-us-east-1.s3.us-east-1.amazonaws.com/latest/assets/awstoe.gpg).
   + Copia la chiave dal seguente testo e incollala in un file denominato `awstoe.gpg`. Assicurati di includere quanto segue:

     ```
     -----BEGIN PGP PUBLIC KEY BLOCK-----
     Version: GnuPG v2
     
     mQENBF8UqwsBCACdiRF2bkZYaFSDPFC+LIkWLwFvtUCRwAHtD8KIwTJ6LVn3fHAU
     GhuK0ZH9mRrqRT2bq/xJjGsnF9VqTj2AJqndGJdDjz75YCZYM+ocZ+r5HSJaeW9i
     S5dykHj7Txti2zHe0G5+W0v7v5bPi2sPHsN7XWQ7+G2AMEPTz8PjxY//I0DvMQns
     Sle3l9hz6wCClz1l9LbBzTyHfSm5ucTXvNe88XX5Gmt37OCDM7vfli0Ctv8WFoLN
     6jbxuA/sV71yIkPm9IYp3+GvaKeT870+sn8/JOOKE/U4sJV1ppbqmuUzDfhrZUaw
     8eW8IN9A1FTIuWiZED/5L83UZuQs1S7s2PjlABEBAAG0GkFXU1RPRSA8YXdzdG9l
     QGFtYXpvbi5jb20+iQE5BBMBCAAjBQJfFKsLAhsDBwsJCAcDAgEGFQgCCQoLBBYC
     AwECHgECF4AACgkQ3r3BVvWuvFJGiwf9EVmrBR77+Qe/DUeXZJYoaFr7If/fVDZl
     6V3TC6p0J0Veme7uXleRUTFOjzbh+7e5sDX19HrnPquzCnzfMiqbp4lSoeUuNdOf
     FcpuTCQH+M+sIEIgPno4PLl0Uj2uE1o++mxmonBl/Krk+hly8hB2L/9n/vW3L7BN
     OMb1Ll9PmgGPbWipcT8KRdz4SUex9TXGYzjlWb3jU3uXetdaQY1M3kVKE1siRsRN
     YYDtpcjmwbhjpu4xm19aFqNoAHCDctEsXJA/mkU3erwIRocPyjAZE2dnlkL9ZkFZ
     z9DQkcIarbCnybDM5lemBbdhXJ6hezJE/b17VA0t1fY04MoEkn6oJg==
     =oyze
     -----END PGP PUBLIC KEY BLOCK-----
     ```

1. Al prompt dei comandi nella directory in cui hai salvato **awstoe.gpg**, usa il seguente comando per importare la chiave pubblica nel tuo portachiavi. AWSTOE 

   ```
   gpg --import awstoe.gpg
   ```

   I risultati restituiti dal comando saranno simili a quanto segue:

   ```
   gpg: key F5AEBC52: public key "AWSTOE <awstoe@amazon.com>" imported
   gpg: Total number processed: 1
   gpg:               imported: 1  (RSA: 1)
   ```

   Annota il valore della chiave. Tale valore verrà usato nel passaggio successivo. Nell'esempio precedente, il valore della chiave è `F5AEBC52`.

1. Verifica l'impronta eseguendo il comando seguente, sostituendo *key-value* con il valore annotato nella fase precedente:

   ```
   gpg --fingerprint key-value
   ```

   Questo comando restituisce risultati simili ai seguenti:

   ```
   pub   2048R/F5AEBC52 2020-07-19
         Key fingerprint = F6DD E01C 869F D639 15E5  5742 DEBD C156 F5AE BC52
   uid       [ unknown] AWSTOE <awstoe@amazon.com>
   ```

   Inoltre, la stringa dell'impronta deve essere uguale al valore `F6DD E01C 869F D639 15E5 5742 DEBD C156 F5AE BC52` riportato nell'esempio precedente. Confronta l'impronta della chiave restituita con quella pubblicata in questa pagina. Le chiavi devono corrispondere. Se non corrispondono, non installate lo script di installazione e contattateci. AWSTOE Supporto

### Verifica della firma del pacchetto
<a name="awstoe-verify-signature-of-binary-package"></a>

Dopo aver installato gli strumenti `GPG`, avere eseguito l'autenticazione, avere importato la chiave pubblica di AWSTOE e avere verificato che la chiave pubblica sia affidabile, puoi verificare la firma dello script di installazione. 

**Per verificare la firma dello script di installazione di**

1. Al prompt dei comandi, esegui il comando seguente per scaricare il file binario dell'applicazione:

   ```
   curl -O https://awstoe-<region>.s3.<region>.amazonaws.com/latest/linux/<architecture>/awstoe
   ```

   Esempio:

   ```
   curl -O https://awstoe-us-east-1.s3.us-east-1.amazonaws.com/latest/linux/amd64/awstoe
   ```

   I valori supportati per **architecture** can be `amd64``386`, e`arm64`.

1. Al prompt dei comandi, esegui il comando seguente per scaricare il file della firma per il file binario dell'applicazione corrispondente dallo stesso percorso del prefisso della chiave S3:

   ```
   curl -O https://awstoe-<region>.s3.<region>.amazonaws.com/latest/linux/<architecture>/awstoe.sig
   ```

   Esempio:

   ```
   curl -O https://awstoe-us-east-1.s3.us-east-1.amazonaws.com/latest/linux/amd64/awstoe.sig
   ```

   I valori supportati per **architecture** can be`amd64`, e`386`. `arm64`

1. Verifica la firma eseguendo il comando seguente al prompt dei comandi nella directory in cui hai salvato `awstoe.sig` e nel file di AWSTOE installazione. Entrambi i file devono essere presenti.

   ```
   gpg --verify ./awstoe.sig ~/awstoe
   ```

   L'output deve essere simile al seguente:

   ```
   gpg: Signature made Mon 20 Jul 2020 08:54:55 AM IST using RSA key ID F5AEBC52
   gpg: Good signature from "AWSTOE awstoe@amazon.com" [unknown]
   gpg: WARNING: This key is not certified with a trusted signature!
   gpg:          There is no indication that the signature belongs to the owner.
   Primary key fingerprint: F6DD E01C 869F D639 15E5 5742 DEBD C156 F5AE BC52
   ```

   Se l'output contiene la frase `Good signature from "AWSTOE <awstoe@amazon.com>"`, significa che la firma è stata verificata correttamente ed è possibile eseguire lo script di installazione di AWSTOE .

   Se l'output include la frase `BAD signature`, controllare di avere eseguito la procedura correttamente. Se continui a ricevere questa risposta, non eseguire il file di installazione scaricato in precedenza e contatta Supporto.

Di seguito sono elencati i dettagli sugli avvisi che potrebbero comparire: 
+ **ATTENZIONE: questa chiave non è certificata con una firma affidabile\$1 Non vi è alcuna indicazione che la firma appartenga al proprietario.** Idealmente, visiteresti un AWS ufficio e riceveresti la chiave di persona. Tuttavia, molto probabilmente lo scaricherai da un sito Web. In questo caso, il sito Web è un AWS sito Web. 
+ **gpg: no ultimately trusted keys found.** Ciò significa che la chiave specifica non è «in ultima analisi considerata affidabile» da te o da altre persone di cui ti fidi.

Per ulteriori informazioni, consulta [http://www.gnupg.org](http://www.gnupg.org).

## Verifica la firma del download di AWSTOE installazione su Windows
<a name="awstoe-verify-sig-win"></a>

In questo argomento viene descritto il processo consigliato per verificare la validità del file di installazione dell' AWS Task Orchestrator and Executor applicazione sui sistemi operativi basati su Windows. 

Quando si esegue il download di un'applicazione da Internet, ti consigliamo di autenticare l'identità dell'autore del software e controllare che l'applicazione non risulti modificata o danneggiata rispetto alla versione pubblicata. Ciò consente di evitare di installare una versione dell'applicazione contenente un virus o altro malware.

Se, dopo aver eseguito i passaggi descritti in questo argomento, si determina che il software dell' AWSTOE applicazione è alterato o danneggiato, non eseguite il file di installazione. Contatta Supporto invece.

Per verificare la validità del file binario awstoe scaricato su sistemi operativi basati su Windows, assicurati che l'impronta digitale del relativo certificato di firma Amazon Services LLC sia uguale a questo valore:

**9D CA 72 17 DA FF B8 2F E4 C4 67 77 36 2F A4 AA C9 08 82 15**

**Nota**  
Durante la finestra di implementazione di un nuovo file binario, il certificato del firmatario potrebbe non corrispondere alla nuova impronta digitale. Se il certificato del firmatario non corrisponde, verifica che il valore dell'impronta digitale sia:   
**BA 81 25 EE AC 64 2E A9 F3 C5 93 CA 6D 3E B7 93 7D 68 75 74**

Per verificare questo valore, esegui la procedura seguente: 

1. Clicca con il pulsante destro del mouse sul file `awstoe.exe`, e apri la finestra **Proprietà**.

1. Scegli la scheda **Firme digitali**.

1. In **Elenco firme** scegli **Amazon Services LLC**, quindi **Dettagli**.

1. Scegli la scheda **Generale**, se non è già selezionata, quindi scegli **Visualizza certificato**.

1. Scegli la scheda **Dettagli**, quindi seleziona **Tutto** nell'elenco a discesa **Mostra**, se non è già selezionato.

1. Scorri fino a visualizzare il campo **Identificazione personale**, quindi scegli **Identificazione personale**. In questo modo viene visualizzato l'intero valore dell'identificazione personale nella finestra inferiore.
   + Se il valore dell'identificazione personale nella finestra inferiore è identico al valore seguente:

     **9D CA72 17 DAF B8 2F E4 C4 67 77 36 2F A4 AA C9 08 82 15**

     allora il file AWSTOE binario scaricato è autentico e può essere installato in sicurezza.
   + Se il valore dell'impronta digitale nella finestra dei dettagli inferiore non è identico al valore precedente, non eseguite. `awstoe.exe`

**Topics**
+ [Verifica la firma del download AWSTOE di installazione](awstoe-verify-sig.md)
+ [Fase 1: Installazione AWSTOE](#toe-start-install)
+ [Fase 2: Impostare AWS le credenziali](#toe-start-credentials)
+ [Fase 3: Sviluppare localmente i documenti dei componenti](#toe-start-develop)
+ [Fase 4: Convalida dei componenti AWSTOE](#toe-start-validate)
+ [Passaggio 5: Esegui i componenti AWSTOE](#toe-start-run)

## Fase 1: Installazione AWSTOE
<a name="toe-start-install"></a>

Per sviluppare componenti localmente, scaricate e installate l' AWSTOE applicazione.

1. 

**Scaricate l' AWSTOE applicazione**

   Per l'installazione AWSTOE, scegli il link di download appropriato per la tua architettura e piattaforma. Per l'elenco completo dei link per il download delle applicazioni, consulta [AWSTOE scarica](toe-component-manager.md#toe-downloads)
**Importante**  
AWS sta eliminando gradualmente il supporto per le versioni TLS 1.0 e 1.1. Per accedere al bucket S3 per i AWSTOE download, il software client deve utilizzare la versione TLS 1.2 o successiva. Per ulteriori informazioni, consulta questo post sul blog [AWS sulla sicurezza](https://aws.amazon.com/blogs/security/tls-1-2-required-for-aws-endpoints/).

1. 

**Verifica la firma**

   I passaggi per la verifica del download dipendono dalla piattaforma server su cui viene eseguita l' AWSTOE applicazione dopo l'installazione. Per verificare il download su un server Linux, consulta[Verifica la firma su Linux o macOS](awstoe-verify-sig.md#awstoe-verify-sig-linux). Per verificare il download su un server Windows, consulta[Verifica la firma su Windows](awstoe-verify-sig.md#awstoe-verify-sig-win).

**Nota**  
AWSTOE viene richiamato direttamente dalla posizione di download. Non è necessaria una fase di installazione separata. Ciò significa anche che AWSTOE può apportare modifiche all'ambiente locale.  
Per assicurarti di isolare le modifiche durante lo sviluppo dei componenti, ti consigliamo di utilizzare un' EC2 istanza per sviluppare e testare AWSTOE i componenti.

## Fase 2: Impostare AWS le credenziali
<a name="toe-start-credentials"></a>

 AWSTOE richiede AWS credenziali per connettersi ad altri Servizi AWS, come Amazon S3 e CloudWatch Amazon, durante l'esecuzione di attività come: 
+ Scaricamento di AWSTOE documenti da un percorso Amazon S3 fornito dall'utente.
+ Moduli in esecuzione `S3Download` o di `S3Upload` azione.
+ Lo streaming si registra su CloudWatch, se abilitato.

Se stai AWSTOE eseguendo un' EC2 istanza, l'esecuzione AWSTOE utilizza le stesse autorizzazioni del ruolo IAM associato all' EC2 istanza.

Per ulteriori informazioni sui ruoli IAM per EC2, consulta [Ruoli IAM per Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html).

Gli esempi seguenti mostrano come impostare AWS le credenziali utilizzando le variabili di `AWS_SECRET_ACCESS_KEY` ambiente `AWS_ACCESS_KEY_ID` e. 

Per impostare queste variabili su Linux, macOS o Unix, usa. `export`

```
export AWS_ACCESS_KEY_ID=your_access_key_id
```

```
export AWS_SECRET_ACCESS_KEY=your_secret_access_key
```

Per impostare queste variabili su Windows utilizzando PowerShell, usa. `$env`

```
$env:AWS_ACCESS_KEY_ID=your_access_key_id
```

```
$env:AWS_SECRET_ACCESS_KEY=your_secret_access_key
```

Per impostare queste variabili su Windows utilizzando il prompt dei comandi, usa`set`.

```
set AWS_ACCESS_KEY_ID=your_access_key_id
```

```
set AWS_SECRET_ACCESS_KEY=your_secret_access_key
```

## Fase 3: Sviluppare localmente i documenti dei componenti
<a name="toe-start-develop"></a>

I componenti sono creati con documenti YAML in testo semplice. Per ulteriori informazioni sulla sintassi dei documenti, vedere. [Usa il framework AWSTOE dei documenti dei componenti per i componenti personalizzati](toe-use-documents.md)

Di seguito sono riportati alcuni esempi di documenti *del componente Hello World* per aiutarti a iniziare.

------
#### [ Linux ]

Alcuni esempi di componenti Linux in questa guida si riferiscono a un file di documento del componente denominato`hello-world-linux.yml`. È possibile utilizzare il seguente documento per iniziare con questi esempi.

```
name: Hello World
description: This is hello world testing document for Linux.
schemaVersion: 1.0
phases:
  - name: build
    steps:
      - name: HelloWorldStep
        action: ExecuteBash
        inputs:
          commands:
            - echo 'Hello World from the build phase.'
  - name: validate
    steps:
      - name: HelloWorldStep
        action: ExecuteBash
        inputs:
          commands:
            - echo 'Hello World from the validate phase.'
  - name: test
    steps:
      - name: HelloWorldStep
        action: ExecuteBash
        inputs:
          commands:
            - echo 'Hello World from the test phase.'
```

------
#### [ Windows ]

Alcuni esempi di componenti Windows in questa guida si riferiscono a un file di documento del componente denominato`hello-world-windows.yml`. È possibile utilizzare il seguente documento per iniziare con questi esempi.

```
name: Hello World
description: This is Hello World testing document for Windows.
schemaVersion: 1.0
phases:
  - name: build
    steps:
      - name: HelloWorldStep
        action: ExecutePowerShell
        inputs:
          commands:
            - Write-Host 'Hello World from the build phase.'
  - name: validate
    steps:
      - name: HelloWorldStep
        action: ExecutePowerShell
        inputs:
          commands:
            - Write-Host 'Hello World from the validate phase.'
  - name: test
    steps:
      - name: HelloWorldStep
        action: ExecutePowerShell
        inputs:
          commands:
            - Write-Host 'Hello World from the test phase.'
```

------
#### [ macOS ]

Alcuni esempi di componenti macOS in questa guida si riferiscono a un file di documento del componente denominato. `hello-world-macos.yml` Puoi usare il seguente documento per iniziare con questi esempi.

```
name: Hello World
description: This is hello world testing document for macOS.
schemaVersion: 1.0
phases:
  - name: build
    steps:
      - name: HelloWorldStep
        action: ExecuteBash
        inputs:
          commands:
            - echo 'Hello World from the build phase.'
  - name: validate
    steps:
      - name: HelloWorldStep
        action: ExecuteBash
        inputs:
          commands:
            - echo 'Hello World from the validate phase.'
  - name: test
    steps:
      - name: HelloWorldStep
        action: ExecuteBash
        inputs:
          commands:
            - echo 'Hello World from the test phase.'
```

------

## Fase 4: Convalida dei componenti AWSTOE
<a name="toe-start-validate"></a>

È possibile convalidare la sintassi dei AWSTOE componenti localmente con l'applicazione. AWSTOE Gli esempi seguenti mostrano il `validate` comando AWSTOE application per convalidare la sintassi di un componente senza eseguirlo.

**Nota**  
L' AWSTOE applicazione può convalidare solo la sintassi del componente per il sistema operativo corrente. Ad esempio, quando è in esecuzione `awstoe.exe` su Windows, non è possibile convalidare la sintassi di un documento Linux che utilizza il modulo di azione. `ExecuteBash`

Linux o macOS:

```
awstoe validate --documents /home/user/hello-world.yml
```

Windows

```
awstoe.exe validate --documents C:\Users\user\Documents\hello-world.yml
```

## Passaggio 5: Esegui i componenti AWSTOE
<a name="toe-start-run"></a>

L' AWSTOE applicazione può eseguire una o più fasi di documenti specifici utilizzando l'argomento della `--phases` riga di comando. I valori supportati per `--phases` sono `build``validate`, e`test`. È possibile immettere valori di fase multipli come valori separati da virgole.

Quando si fornisce un elenco di fasi, l' AWSTOE applicazione esegue in sequenza le fasi specificate di ciascun documento. Ad esempio, AWSTOE esegue le `validate` fasi `build` e di`document1.yaml`, seguite dalle `validate` fasi `build` e di`document2.yaml`.

Per garantire che i log siano archiviati in modo sicuro e conservati per la risoluzione dei problemi, consigliamo di configurare lo storage dei log in Amazon S3. In Image Builder, la posizione Amazon S3 per la pubblicazione dei log è specificata nella configurazione dell'infrastruttura. Per ulteriori informazioni sulla configurazione dell'infrastruttura, consulta [Gestione della configurazione dell'infrastruttura Image Builder](manage-infra-config.md)

Se non viene fornito un elenco di fasi, l' AWSTOE applicazione esegue tutte le fasi nell'ordine indicato nel documento YAML.

Per eseguire fasi specifiche in uno o più documenti, utilizzate i seguenti comandi.

Monofase

```
awstoe run --documents hello-world.yml --phases build
```

Fasi multiple

```
awstoe run --documents hello-world.yml --phases build,test
```

**Esecuzione del documento**  
Esegui tutte le fasi in un unico documento

```
awstoe run --documents documentName.yaml
```

Esegui tutte le fasi in più documenti

```
awstoe run --documents documentName1.yaml,documentName2.yaml
```

Inserisci le informazioni di Amazon S3 per caricare AWSTOE i log da un percorso locale definito dall'utente (consigliato)

```
awstoe run --documents documentName.yaml --log-s3-bucket-name amzn-s3-demo-destination-bucket --log-s3-key-prefix S3KeyPrefix --log-s3-bucket-owner S3BucketOwner --log-directory local_path
```

Esegui tutte le fasi in un unico documento e visualizza tutti i log sulla console

```
awstoe run --documents documentName.yaml --trace
```

Comando della di esempio

```
awstoe run --documents s3://bucket/key/doc.yaml --phases build,validate
```

Esegui il documento con un ID univoco

```
awstoe run --documents documentName.yaml --execution-id user-provided-id --phases build,test
```

Fatti aiutare con AWSTOE

```
awstoe --help
```

# Usa il framework AWSTOE dei documenti dei componenti per i componenti personalizzati
<a name="toe-use-documents"></a>

Per creare un componente utilizzando il framework di componenti AWS Task Orchestrator and Executor (AWSTOE), devi fornire un documento basato su YAML che rappresenti le fasi e i passaggi applicabili al componente che crei. Servizi AWS usa il tuo componente quando creano una nuova Amazon Machine Image (AMI) o un'immagine del contenitore.

**Topics**
+ [Flusso di lavoro relativo ai documenti](#component-doc-workflow)
+ [Registrazione dei componenti](#component-logging)
+ [Concatenamento di input e output](#document-chaining)
+ [Schema e definizioni del documento](#document-schema)
+ [Esempi di documenti](#document-example)
+ [Usa le variabili nel tuo documento componente personalizzato](toe-user-defined-variables.md)
+ [Usa costrutti condizionali in AWSTOE](toe-conditional-constructs.md)
+ [Usa gli operatori di confronto nei documenti AWSTOE dei componenti](toe-comparison-operators.md)
+ [Utilizzo di operatori logici nei documenti AWSTOE dei componenti](toe-logical-operators.md)
+ [Usa costrutti a ciclo continuo in AWSTOE](toe-looping-constructs.md)

## Flusso di lavoro relativo ai documenti
<a name="component-doc-workflow"></a>

Il documento del AWSTOE componente utilizza fasi e passaggi per raggruppare le attività correlate e organizzarle in un flusso di lavoro logico per il componente.

**Suggerimento**  
Il servizio che utilizza il componente per creare un'immagine potrebbe implementare regole su quali fasi utilizzare per il processo di creazione e quando tali fasi possono essere eseguite. Questo è importante da considerare quando si progetta il componente.

**Fasi**  
Le fasi rappresentano la progressione del flusso di lavoro attraverso il processo di creazione dell'immagine. Ad esempio, il servizio Image Builder utilizza `validate` le fasi `build` e le fasi durante la *fase di creazione* per le immagini che produce. Utilizza `container-host-test` le fasi `test` and durante la *fase di test* per garantire che l'istantanea dell'immagine o l'immagine del contenitore produca i risultati previsti prima di creare l'AMI finale o distribuire l'immagine del contenitore.

Quando il componente viene eseguito, i comandi associati per ogni fase vengono applicati nell'ordine in cui appaiono nel documento del componente.

**Regole per le fasi**
+ Il nome di ogni fase deve essere univoco all'interno di un documento.
+ È possibile definire molte fasi del documento.
+ È necessario includere almeno una delle seguenti fasi nel documento:
  + **build**: per Image Builder, questa fase viene generalmente utilizzata durante la fase di *creazione*.
  + **validare**: per Image Builder, questa fase viene generalmente utilizzata durante *la* fase di creazione.
  + **test** — per Image Builder, questa fase viene generalmente utilizzata durante la fase di *test*.
+ Le fasi vengono sempre eseguite nell'ordine in cui sono definite nel documento. L'ordine in cui sono specificate per AWSTOE i comandi in non AWS CLI ha effetto.

**Fasi**  
I passaggi sono singole unità di lavoro che definiscono il flusso di lavoro all'interno di ciascuna fase. Le fasi vengono eseguite in ordine sequenziale. Tuttavia, l'input o l'output di una fase possono anche alimentare una fase successiva come input. Questo processo si chiama «concatenamento».

**Regole per i passaggi**
+ Il nome della fase deve essere univoco per la fase.
+ La fase deve utilizzare un'azione supportata (modulo di azione) che restituisca un codice di uscita.

  Per un elenco completo dei moduli di azione supportati, del loro funzionamento, input/output dei valori e degli esempi, consulta[Moduli di azione supportati dal gestore AWSTOE dei componenti](toe-action-modules.md).

## Registrazione dei componenti
<a name="component-logging"></a>

AWSTOE crea una nuova cartella di registro sulle istanze EC2 che vengono utilizzate per creare e testare una nuova immagine, ogni volta che il componente viene eseguito. Per le immagini del contenitore, la cartella di registro viene archiviata nel contenitore.

Per facilitare la risoluzione dei problemi in caso di problemi durante il processo di creazione dell'immagine, il documento di input e tutti i file di output AWSTOE creati durante l'esecuzione del componente vengono archiviati nella cartella di registro.

Il nome della cartella di registro è composto dalle seguenti parti:

1. **Directory di log**: quando un servizio esegue un AWSTOE componente, questo passa nella directory di log, insieme ad altre impostazioni per il comando. Per gli esempi seguenti, mostriamo il formato di file di registro utilizzato da Image Builder.
   + **Linux e macOS:** `/var/lib/amazon/toe/`
   + **Windows**: `$env:ProgramFiles\Amazon\TaskOrchestratorAndExecutor\`

1. **Prefisso del file**: si tratta di un prefisso standard utilizzato per tutti i componenti: "». `TOE_`

1. **Ora di esecuzione**: si tratta di un timestamp in formato \$1HH-MM-SS\$1UTC-0. YYYY-MM-DD

1. **ID di esecuzione: è il GUID** assegnato quando vengono eseguiti uno o più componenti. AWSTOE 

Ad esempio: `/var/lib/amazon/toe/TOE_2021-07-01_12-34-56_UTC-0_a1bcd2e3-45f6-789a-bcde-0fa1b2c3def4`

AWSTOE memorizza i seguenti file principali nella cartella di registro:

**File di input**
+ **document.yaml** — Il documento utilizzato come input per il comando. Dopo l'esecuzione del componente, questo file viene memorizzato come artefatto.

**File di output**
+ **application.log**: il registro dell'applicazione contiene informazioni a livello di debug con data e ora AWSTOE relative a ciò che accade durante l'esecuzione del componente.
+ **detailedoutput.json**: questo file JSON contiene informazioni dettagliate sullo stato di esecuzione, gli input, gli output e gli errori per tutti i documenti, le fasi e i passaggi relativi al componente durante l'esecuzione.
+ **console.log** — Il registro della console contiene tutte le informazioni sullo standard out (stdout) e sugli errori standard (stderr) che vengono scritte sulla console mentre il componente è in esecuzione. AWSTOE 
+ **chaining.json: questo file JSON** rappresenta le ottimizzazioni applicate per risolvere le espressioni di concatenamento. AWSTOE 

**Nota**  
La cartella di registro potrebbe contenere anche altri file temporanei che non sono trattati qui.

## Concatenamento di input e output
<a name="document-chaining"></a>

L'applicazione AWSTOE di gestione della configurazione fornisce una funzionalità per concatenare input e output scrivendo riferimenti nei seguenti formati:

`{{ phase_name.step_name.inputs/outputs.variable }}`

or

`{{ phase_name.step_name.inputs/outputs[index].variable }}`

La funzione di concatenamento consente di riciclare il codice e migliorare la manutenibilità del documento.

**Regole per il concatenamento**
+ Le espressioni di concatenamento possono essere utilizzate solo nella sezione degli input di ogni passaggio.
+ Le dichiarazioni con espressioni concatenate devono essere racchiuse tra virgolette. Esempio:
  + **Espressione non valida:** `echo {{ phase.step.inputs.variable }}`
  + **Espressione valida**: `"echo {{ phase.step.inputs.variable }}"`
  + **Espressione valida**: `'echo {{ phase.step.inputs.variable }}'`
+ Le espressioni concatenate possono fare riferimento a variabili di altri passaggi e fasi dello stesso documento. Tuttavia, il servizio di chiamata potrebbe avere regole che richiedono che le espressioni concatenate funzionino solo nel contesto di una singola fase. Ad esempio, Image Builder non supporta il concatenamento dalla fase di *compilazione alla fase* di *test, poiché esegue ogni fase* in modo indipendente.
+ Gli indici nelle espressioni concatenate seguono l'indicizzazione a base zero. L'indice inizia con zero (0) per fare riferimento al primo elemento.

**Esempi**

Per fare riferimento alla variabile source nella seconda voce del passaggio di esempio seguente, lo schema di concatenamento è`{{ build.SampleS3Download.inputs[1].source }}`.

```
phases:
  - name: 'build'
    steps:
      - name: SampleS3Download
        action: S3Download
        timeoutSeconds: 60
        onFailure: Abort
        maxAttempts: 3
        inputs:
          - source: 's3://sample-bucket/sample1.ps1'
            destination: 'C:\sample1.ps1'
          - source: 's3://sample-bucket/sample2.ps1'
            destination: 'C:\sample2.ps1'
```

Per fare riferimento alla variabile di output (uguale a «Hello») del seguente passaggio di esempio, lo schema di concatenamento è. `{{ build.SamplePowerShellStep.outputs.stdout }}`

```
phases:
  - name: 'build'
    steps:
      - name: SamplePowerShellStep
        action: ExecutePowerShell
        timeoutSeconds: 120
        onFailure: Abort
        maxAttempts: 3
        inputs:
          commands:
            - 'Write-Host "Hello"'
```

## Schema e definizioni del documento
<a name="document-schema"></a>

Di seguito è riportato lo schema YAML per un documento.

```
name: (optional)
description: (optional)
schemaVersion: "string"

phases:
  - name: "string"
    steps:
      - name: "string"
        action: "string"
        timeoutSeconds: integer
        onFailure: "Abort|Continue|Ignore"
        maxAttempts: integer
        inputs:
```

Le definizioni dello schema per un documento sono le seguenti.


| Campo | Description | Tipo | Richiesto | 
| --- | --- | --- | --- | 
| nome | Nome del documento. | Stringa | No | 
| description | Descrizione del documento. | Stringa |  No  | 
| schemaVersion | Versione dello schema del documento, attualmente 1.0. | Stringa |  Sì  | 
| phases | Un elenco di fasi con i relativi passaggi. |  List  |  Sì  | 

Le definizioni dello schema per una fase sono le seguenti.


| Campo | Description | Tipo | Richiesto | 
| --- | --- | --- | --- | 
| nome | Nome della fase. | Stringa | Sì | 
| steps | Elenco delle fasi della fase. | List  |  Sì  | 

Le definizioni dello schema per una fase sono le seguenti.


| Campo | Description | Tipo | Richiesto | Valore predefinito | 
| --- | --- | --- | --- | --- | 
| nome | Nome definito dall'utente per il passo. | Stringa |  |  | 
| operazione | Parola chiave relativa al modulo che esegue il passaggio. | Stringa |  |  | 
| timeoutSeconds |  Numero di secondi di esecuzione del passaggio prima di fallire o riprovare.  Inoltre, supporta il valore -1, che indica un timeout infinito. 0 e altri valori negativi non sono consentiti.  | Numero intero |  No  | 7.200 sec (120 minuti) | 
| onFailure |  Specifica cosa deve fare la fase in caso di errore. I valori validi sono:  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/imagebuilder/latest/userguide/toe-use-documents.html)  |  Stringa  |  No  | Interruzione | 
| maxAttempts | Numero massimo di tentativi consentiti prima di fallire il passaggio. | Numero intero |  No  | 1 | 
| inputs | Contiene i parametri richiesti dal modulo di azione per eseguire il passaggio. | Dict |  Sì  |  | 

## Esempi di documenti
<a name="document-example"></a>

Gli esempi seguenti mostrano i documenti dei AWSTOE componenti che eseguono attività per il sistema operativo di destinazione.

------
#### [ Linux ]

**Esempio 1: eseguire un file binario personalizzato**  
Di seguito è riportato un documento di esempio che scarica ed esegue un file binario personalizzato su un'istanza Linux.

```
name: LinuxBin
description: Download and run a custom Linux binary file.
schemaVersion: 1.0
phases:
  - name: build
    steps:
      - name: Download
        action: S3Download
        inputs:
          - source: s3://<replaceable>amzn-s3-demo-source-bucket</replaceable>/<replaceable>myapplication</replaceable>
            destination: /tmp/<replaceable>myapplication</replaceable>
      - name: Enable
        action: ExecuteBash
        onFailure: Continue
        inputs:
          commands:
            - 'chmod u+x {{ build.Download.inputs[0].destination }}'
      - name: Install
        action: ExecuteBinary
        onFailure: Continue
        inputs:
          path: '{{ build.Download.inputs[0].destination }}'
          arguments:
            - '--install'
      - name: Delete
        action: DeleteFile
        inputs:
          - path: '{{ build.Download.inputs[0].destination }}'
```

------
#### [ Windows ]

**Esempio 1: installare gli aggiornamenti di Windows**  
Di seguito è riportato un documento di esempio che installa tutti gli aggiornamenti di Windows disponibili, esegue uno script di configurazione, convalida le modifiche prima della creazione dell'AMI e verifica le modifiche dopo la creazione dell'AMI.

```
name: RunConfig_UpdateWindows
description: 'This document will install all available Windows updates and run a config script. It will then validate the changes before an AMI is created. Then after AMI creation, it will test all the changes.'
schemaVersion: 1.0
phases:
  - name: build
    steps:
      - name: DownloadConfigScript
        action: S3Download
        timeoutSeconds: 60
        onFailure: Abort
        maxAttempts: 3
        inputs:
          - source: 's3://customer-bucket/config.ps1'
            destination: 'C:\config.ps1'

      - name: RunConfigScript
        action: ExecutePowerShell
        timeoutSeconds: 120
        onFailure: Abort
        maxAttempts: 3
        inputs:
          file: '{{build.DownloadConfigScript.inputs[0].destination}}'

      - name: Cleanup
        action: DeleteFile
        onFailure: Abort
        maxAttempts: 3
        inputs:
          - path: '{{build.DownloadConfigScript.inputs[0].destination}}'

      - name: RebootAfterConfigApplied
        action: Reboot
        inputs:
          delaySeconds: 60

      - name: InstallWindowsUpdates
        action: UpdateOS

  - name: validate
    steps:
      - name: DownloadTestConfigScript
        action: S3Download
        timeoutSeconds: 60
        onFailure: Abort
        maxAttempts: 3
        inputs:
          - source: 's3://customer-bucket/testConfig.ps1'
            destination: 'C:\testConfig.ps1'

      - name: ValidateConfigScript
        action: ExecutePowerShell
        timeoutSeconds: 120
        onFailure: Abort
        maxAttempts: 3
        inputs:
          file: '{{validate.DownloadTestConfigScript.inputs[0].destination}}'

      - name: Cleanup
        action: DeleteFile
        onFailure: Abort
        maxAttempts: 3
        inputs:
          - path: '{{validate.DownloadTestConfigScript.inputs[0].destination}}'

  - name: test
    steps:
      - name: DownloadTestConfigScript
        action: S3Download
        timeoutSeconds: 60
        onFailure: Abort
        maxAttempts: 3
        inputs:
          - source: 's3://customer-bucket/testConfig.ps1'
            destination: 'C:\testConfig.ps1'

      - name: ValidateConfigScript
        action: ExecutePowerShell
        timeoutSeconds: 120
        onFailure: Abort
        maxAttempts: 3
        inputs:
          file: '{{test.DownloadTestConfigScript.inputs[0].destination}}'
```

**Esempio 2: installalo AWS CLI su un'istanza di Windows**  
Di seguito è riportato un documento di esempio che installa AWS CLI su un'istanza di Windows, utilizzando il file di installazione.

```
name: InstallCLISetUp
description: Install &CLI; using the setup file
schemaVersion: 1.0
phases:
  - name: build
    steps:
      - name: Download
        action: S3Download
        inputs:
          - source: s3://aws-cli/AWSCLISetup.exe
            destination: C:\Windows\temp\AWSCLISetup.exe
      - name: Install
        action: ExecuteBinary
        onFailure: Continue
        inputs:
          path: '{{ build.Download.inputs[0].destination }}'
          arguments:
            - '/install'
            - '/quiet'
            - '/norestart'
      - name: Delete
        action: DeleteFile
        inputs:
          - path: '{{ build.Download.inputs[0].destination }}'
```

**Esempio 3: installare il file AWS CLI con il programma di installazione MSI**  
Di seguito è riportato un documento di esempio che installa il AWS CLI con il programma di installazione MSI.

```
name: InstallCLIMSI
description: Install &CLI; using the MSI installer
schemaVersion: 1.0
phases:
  - name: build
    steps:
      - name: Download
        action: S3Download
        inputs:
          - source: s3://aws-cli/AWSCLI64PY3.msi
            destination: C:\Windows\temp\AWSCLI64PY3.msi
      - name: Install
        action: ExecuteBinary
        onFailure: Continue
        inputs:
          path: 'C:\Windows\System32\msiexec.exe'
          arguments:
            - '/i'
            - '{{ build.Download.inputs[0].destination }}'
            - '/quiet'
            - '/norestart'
      - name: Delete
        action: DeleteFile
        inputs:
          - path: '{{ build.Download.inputs[0].destination }}'
```

------
#### [ macOS ]

**Esempio 1: eseguire un file binario macOS personalizzato**  
Di seguito è riportato un documento di esempio che scarica ed esegue un file binario personalizzato su un'istanza macOS.

```
name: macOSBin
description: Download and run a binary file on macOS.
schemaVersion: 1.0
phases:
  - name: build
    steps:
      - name: Download
        action: S3Download
        inputs:
          - source: s3://<replaceable>amzn-s3-demo-source-bucket</replaceable>/<replaceable>myapplication</replaceable>
            destination: /tmp/<replaceable>myapplication</replaceable>
      - name: Enable
        action: ExecuteBash
        onFailure: Continue
        inputs:
          commands:
            - 'chmod u+x {{ build.Download.inputs[0].destination }}'
      - name: Install
        action: ExecuteBinary
        onFailure: Continue
        inputs:
          path: '{{ build.Download.inputs[0].destination }}'
          arguments:
            - '--install'
      - name: Delete
        action: DeleteFile
        inputs:
          - path: '{{ build.Download.inputs[0].destination }}'
```

------

# Usa le variabili nel tuo documento componente personalizzato
<a name="toe-user-defined-variables"></a>

Le variabili forniscono un modo per etichettare i dati con nomi significativi che possono essere utilizzati in un'applicazione. È possibile definire variabili personalizzate con formati semplici e leggibili per flussi di lavoro complessi e farvi riferimento nel documento del componente dell'applicazione YAML per un componente. AWSTOE 

Questa sezione fornisce informazioni per aiutarvi a definire le variabili per il AWSTOE componente nel documento del componente dell'applicazione YAML, tra cui sintassi, vincoli di nome ed esempi.

## Costanti
<a name="user-defined-vars-constants"></a>

Le costanti sono variabili immutabili che non possono essere modificate o sovrascritte una volta definite. Le costanti possono essere definite utilizzando i valori nella sezione di un documento. `constants` AWSTOE 

**Regole per i nomi delle costanti**
+ La lunghezza del nome deve essere compresa tra 3 e 128 caratteri.
+ Il nome può contenere solo caratteri alfanumerici (a-z, A-Z, 0-9), trattini (-) o caratteri di sottolineatura (\$1).
+ Il nome deve essere univoco all'interno del documento.
+ Il nome deve essere specificato come stringa YAML.

**Sintassi**

```
constants:
  - <name>:
      type: <constant type>
      value: <constant value>
```


| Nome chiave | Richiesto | Descrizione | 
| --- | --- | --- | 
|  `name`  |  Sì  | Nome della costante. Deve essere univoco per il documento (non deve essere uguale a nessun altro nome di parametro o costante). | 
| `value` | Sì | Valore della costante. | 
| `type` | Sì | Tipo di costante. Il tipo supportato èstring. | 

**Valori costanti di riferimento in un documento**  
Puoi fare riferimento alle costanti negli input step o loop all'interno del tuo documento YAML, come segue:
+ I riferimenti alle costanti fanno distinzione tra maiuscole e minuscole e il nome deve corrispondere esattamente.
+ Il nome deve essere racchiuso tra parentesi doppie arricciate. `{{` *MyConstant* `}}`
+ Gli spazi all'interno delle parentesi arricciate sono consentiti e vengono tagliati automaticamente. Ad esempio, tutti i seguenti riferimenti sono validi:

  `{{ MyConstant }}`, `{{ MyConstant}}`, `{{MyConstant }}`, `{{MyConstant}}`
+ Il riferimento nel documento YAML deve essere specificato come stringa (racchiusa tra virgolette singole o doppie).

  Ad esempio: non `- {{ MyConstant }}` è valido, in quanto non è identificato come stringa.

  Tuttavia, i seguenti riferimenti sono entrambi validi: `- '{{ MyConstant }}'` e`- "{{ MyConstant }}"`.

**Esempi**  
Costante a cui si fa riferimento negli ingressi Step

```
name: Download AWS CLI version 2
schemaVersion: 1.0
constants:
  - Source:
      type: string
      value: https://awscli.amazonaws.com/AWSCLIV2.msi
phases:
  - name: build
    steps:
      - name: Download
        action: WebDownload
        inputs:
          - source: '{{ Source }}'
            destination: 'C:\Windows\Temp\AWSCLIV2.msi'
```

Costante referenziata negli ingressi in loop

```
name: PingHosts
schemaVersion: 1.0
constants:
  - Hosts:
      type: string
      value: 127.0.0.1,amazon.com
phases:
  - name: build
    steps:
      - name: Ping
        action: ExecuteBash
        loop:
          forEach:
            list: '{{ Hosts }}'
            delimiter: ','
        inputs:
          commands:
            - ping -c 4 {{ loop.value }}
```

## Parameters
<a name="user-defined-vars-parameters"></a>

I parametri sono variabili mutabili, con impostazioni che l'applicazione chiamante può fornire in fase di esecuzione. È possibile definire i parametri nella `Parameters` sezione del documento YAML.

**Regole per i nomi dei parametri**
+ La lunghezza del nome deve essere compresa tra 3 e 128 caratteri.
+ Il nome può contenere solo caratteri alfanumerici (a-z, A-Z, 0-9), trattini (-) o caratteri di sottolineatura (\$1).
+ Il nome deve essere univoco all'interno del documento.
+ Il nome deve essere specificato come stringa YAML.

### Sintassi
<a name="vars-parameters-syntax"></a>

```
parameters:
  - <name>:
      type: <parameter type>
      default: <parameter value>
      description: <parameter description>
```


| Nome chiave | Richiesto | Descrizione | 
| --- | --- | --- | 
| `name` | Sì | Nome del parametro. Deve essere univoco per il documento (non deve essere uguale a nessun altro nome di parametro o costante). | 
| `type` | Sì | Il tipo di dati del parametro. I tipi supportati includono:`string`. | 
| `default` | No | Il valore predefinito per il parametro. | 
| `description` | No | Descrive il parametro. | 

### Valori dei parametri di riferimento in un documento
<a name="vars-parameters-referencing"></a>

Puoi fare riferimento ai parametri negli input step o loop all'interno del tuo documento YAML, come segue:
+ I riferimenti ai parametri fanno distinzione tra maiuscole e minuscole e il nome deve corrispondere esattamente.
+ Il nome deve essere racchiuso tra parentesi graffe doppie. `{{` *MyParameter* `}}`
+ Gli spazi all'interno delle parentesi arricciate sono consentiti e vengono tagliati automaticamente. Ad esempio, tutti i seguenti riferimenti sono validi:

  `{{ MyParameter }}`, `{{ MyParameter}}`, `{{MyParameter }}`, `{{MyParameter}}`
+ Il riferimento nel documento YAML deve essere specificato come stringa (racchiusa tra virgolette singole o doppie).

  Ad esempio: non `- {{ MyParameter }}` è valido, in quanto non è identificato come stringa.

  Tuttavia, i seguenti riferimenti sono entrambi validi: `- '{{ MyParameter }}'` e`- "{{ MyParameter }}"`.

**Esempi**  
Gli esempi seguenti mostrano come utilizzare i parametri nel documento YAML:
+ Fate riferimento a un parametro in Step Inputs:

  ```
  name: Download AWS CLI version 2
  schemaVersion: 1.0
  parameters:
    - Source:
        type: string
        default: 'https://awscli.amazonaws.com/AWSCLIV2.msi'
        description: The AWS CLI installer source URL.
  phases:
    - name: build
      steps:
        - name: Download
          action: WebDownload
          inputs:
            - source: '{{ Source }}'
              destination: 'C:\Windows\Temp\AWSCLIV2.msi'
  ```
+ Fate riferimento a un parametro negli ingressi del loop:

  ```
  name: PingHosts
  schemaVersion: 1.0
  parameters:
    - Hosts:
        type: string
        default: 127.0.0.1,amazon.com
        description: A comma separated list of hosts to ping.
  phases:
    - name: build
      steps:
        - name: Ping
          action: ExecuteBash
          loop:
            forEach:
              list: '{{ Hosts }}'
              delimiter: ','
          inputs:
            commands:
              - ping -c 4 {{ loop.value }}
  ```

### Sostituisci i parametri in fase di esecuzione
<a name="vars-parameters-set-at-runtime"></a>

È possibile utilizzare l'`--parameters`opzione AWS CLI con una coppia chiave-valore per impostare il valore di un parametro in fase di esecuzione.
+ <name><value>Specificate la coppia chiave-valore del parametro come nome e valore, separati da un segno di uguale (=).
+ Più parametri devono essere separati da una virgola.
+ I nomi dei parametri che non si trovano nel documento del componente YAML vengono ignorati.
+ Il nome e il valore del parametro sono entrambi obbligatori.

**Importante**  
I parametri dei componenti sono valori di testo semplice e vengono registrati. AWS CloudTrail Ti consigliamo di utilizzare Gestione dei segreti AWS o il AWS Systems Manager Parameter Store per archiviare i tuoi segreti. Per ulteriori informazioni su Secrets Manager, vedi [Cos'è Secrets Manager?](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) nella *Guida Gestione dei segreti AWS per l'utente*. Per ulteriori informazioni su AWS Systems Manager Parameter Store, vedere [AWS Systems Manager Parameter Store](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html) nella *Guida AWS Systems Manager per l'utente*.

#### Sintassi
<a name="vars-runtime-parameters-syntax"></a>

```
--parameters name1=value1,name2=value2...
```


| Opzione CLI | Richiesto | Description | 
| --- | --- | --- | 
| --parameters *name* =*value*,... | No | Questa opzione accetta l'elenco delle coppie chiave-valore, con il nome del parametro come chiave. | 

**Esempi**  
Gli esempi seguenti mostrano come utilizzare i parametri nel documento YAML:
+ La coppia chiave-valore del parametro specificata in questa `--parameter` opzione non è valida:

  ```
  --parameters ntp-server=
  ```
+ Imposta una coppia chiave-valore di parametro con l'opzione in`--parameter`: AWS CLI

  ```
  --parameters ntp-server=ntp-server-windows-qe.us-east1.amazon.com
  ```
+ Imposta più coppie chiave-valore di parametri con l'opzione in`--parameter`: AWS CLI

  ```
  --parameters ntp-server=ntp-server.amazon.com,http-url=https://internal-us-east1.amazon.com
  ```

## Usa i parametri del Parameter Store di Systems Manager
<a name="toe-ssm-parameters"></a>

È possibile fare riferimento ai parametri AWS Systems Manager Parameter Store (parametri SSM) nei documenti dei componenti aggiungendo alle variabili il prefisso. `aws:ssm` Ad esempio, 

`{{ aws:ssm:/my/param }}`si risolve al valore del parametro SSM. `/my/param`

Questa funzionalità supporta i seguenti tipi di parametri SSM:
+ Stringa: esegue il mapping al tipo di AWSTOE stringa.
+ StringList — Esegue il mapping al AWSTOE `stringList` tipo.
+ SecureString — Esegue il mapping al tipo di AWSTOE stringa.

Per ulteriori informazioni sull'archivio dei parametri, vedere [AWS Systems Manager Parameter Store](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html) nella *Guida AWS Systems Manager per l'utente*.

Puoi anche fare riferimento ai Gestione dei segreti AWS segreti utilizzando un parametro `SecureString` SSM. Ad esempio: `{{ aws:ssm:/aws/reference/secretsmanager/test/test-secret }}`. Per ulteriori informazioni, vedere [Riferimento ai Gestione dei segreti AWS segreti dai parametri del Parameter Store](https://docs.aws.amazon.com/systems-manager/latest/userguide/integration-ps-secretsmanager.html).

**Importante**  
Image Builder esclude la risoluzione `SecureString` dei parametri dai suoi registri. Tuttavia, l'utente è anche responsabile di garantire che le informazioni riservate non vengano registrate tramite i comandi immessi nel documento del componente. Ad esempio, se si utilizza il `echo` comando con una stringa sicura, il comando scrive un valore in chiaro nel registro.

### Autorizzazioni IAM richieste
<a name="toe-ssm-parameters-permissions"></a>

Per utilizzare i parametri Systems Manager nei componenti, il ruolo dell'istanza deve disporre dell'`ssm:GetParameter`autorizzazione per la risorsa parametrica ARN. Esempio:

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

****  

```
{
	"Version":"2012-10-17",		 	 	 
	"Statement": [
		{
			"Effect": "Allow",
			"Action": "ssm:GetParameter",
			"Resource": "arn:aws:ssm:*:111122223333:parameter/ImageBuilder-*"
		}
	]
}
```

------

Per accedere ai valori crittografati, sono inoltre necessarie le seguenti autorizzazioni:
+ Aggiungi `kms:Decrypt` per `SecureString` parametri o Gestione dei segreti AWS valori crittografati con un servizio gestito AWS KMS key dal cliente.
+ Aggiungi `secretsmanager:GetSecretValue` se fai riferimento a un segreto di Secrets Manager.

### Fai riferimento a un parametro SSM in un documento componente
<a name="toe-ssm-parameters-example"></a>

L'esempio seguente mostra come fare riferimento a un parametro Systems Manager Parameter Store dei parametri di Systems Manager in un componente:

```
name: UseSSMParameterVariable
description: This is a sample component document that prints out the value of an SSM Parameter. Never do this for a SecureString parameter.
schemaVersion: 1.0

phases:
  - name: verify
    steps:
      - name: EchoParameterValue
        action: ExecuteBash
        inputs:
          commands:
            - echo "Log SSM parameter name: /my/test/param, value {{ aws:ssm:/my/test/param }}."
```

### Risoluzione variabile dinamica di runtime per i parametri SSM
<a name="toe-dynamic-vars"></a>

AWSTOE fornisce la seguente funzione integrata che è possibile utilizzare all'interno dei riferimenti alle variabili per manipolare o trasformare i valori in fase di esecuzione.

#### funzione di risoluzione
<a name="toe-function-resolve"></a>

La `resolve` funzione risolve un riferimento a una variabile all'interno di un altro riferimento a una variabile, consentendo il riferimento dinamico al nome della variabile. Ciò è utile quando si lavora con parametri SSM in cui parte del percorso del parametro può essere variabile e passata come parametro del documento.

La `resolve` funzione supporta solo la risoluzione dinamica della parte relativa al nome di un parametro SSM.

##### Sintassi
<a name="toe-function-resolve-syntax"></a>

L'`dynamic_variable`esempio seguente rappresenta il nome di un parametro SSM e deve essere uno dei seguenti:
+ Un riferimento a un parametro SSM (ad esempio,) `aws:ssm:/my/param`
+ Un riferimento a un parametro del documento componente (ad esempio,`parameter-name`)

```
{{ aws:ssm:resolve(dynamic_variable) }}
```

##### Esempio: risolvi un parametro SSM in fase di esecuzione
<a name="toe-function-resolve-examples"></a>

L'esempio seguente mostra come utilizzare la `resolve` funzione in un documento del componente YAML:

```
name: SsmParameterTest
description: This component verifies an SSM parameter variable reference with the echo command.
schemaVersion: 1.0

parameters:
  - parameter-name:
      type: string
      description: "test"

phases:
  - name: validate
    steps:
      - name: PrintDynamicVariable
        action: ExecuteBash
        inputs:
          commands:
            - echo "{{ aws:ssm:resolve(parameter-name) }}"
```

# Usa costrutti condizionali in AWSTOE
<a name="toe-conditional-constructs"></a>

I costrutti condizionali eseguono azioni diverse nel documento del componente a seconda che l'espressione condizionale specificata restituisca o meno. `true` `false` È possibile utilizzare il `if` costrutto per controllare il flusso di esecuzione nel documento componente.

## if Construct
<a name="toe-conditional-if"></a>

È possibile utilizzare il `if` costrutto per valutare se un passaggio deve essere eseguito o meno. Per impostazione predefinita, quando l'espressione `if` condizionale restituisce`true`, AWSTOE esegue il passaggio e quando la condizione restituisce a`false`, AWSTOE salta il passaggio. Se un passaggio viene saltato, viene considerato come un passaggio riuscito quando si AWSTOE valuta se la fase e il documento sono stati eseguiti correttamente.

**Nota**  
Un'`if`istruzione viene valutata solo una volta, anche se il passaggio attiva un riavvio. Se un passaggio si riavvia, riconosce che l'`if`istruzione è già stata valutata e continua da dove era stata interrotta.

### Sintassi
<a name="toe-conditional-if-syntax"></a>

```
if:
  - <conditional expression>:
      [then: <step action>]
      [else: <step action>]
```


| Nome chiave | Richiesto | Description | 
| --- | --- | --- | 
| espressione condizionale | Sì |  L'espressione condizionale può contenere esattamente uno dei seguenti tipi di operatori al livello superiore. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/imagebuilder/latest/userguide/toe-conditional-constructs.html) Se l'espressione deve soddisfare più condizioni, utilizzate un operatore logico per specificare le condizioni.  | 
| poi | No |  Definisce l'azione da intraprendere se l'espressione condizionale restituisce. `true`  | 
| altro | No |  Definisce l'azione da intraprendere se l'espressione condizionale restituisce un risultato. `false`  | 
| azione graduale | Condizionale |  Quando si utilizza `then` o`else`, è necessario specificare una delle seguenti azioni di fase: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/imagebuilder/latest/userguide/toe-conditional-constructs.html)  | 

**Esempio 1: pacchetto di installazione**  
I seguenti passaggi di esempio tratti da un documento relativo a un AWSTOE componente utilizzano operatori logici per testare il valore di un parametro ed eseguire i comandi appropriati del gestore di pacchetti per installare un'applicazione se il pacchetto è decompresso.

```
    - name: InstallUnzipAptGet
      action: ExecuteBash
      if:
        and:
            - binaryExists: 'apt-get'
            - not:
                binaryExists: 'unzip'
      inputs:
        commands:
            - sudo apt-get update
            - sudo apt-get install -y unzip

    - name: InstallUnzipYum
      action: ExecuteBash
      if:
        and:
            - binaryExists: 'yum'
            - not:
                binaryExists: 'unzip'
      inputs:
        commands:
            - sudo yum install -y unzip

    - name: InstallUnzipZypper
      action: ExecuteBash
      if:
        and:
            - binaryExists: 'zypper'
            - not:
                binaryExists: 'unzip'
      inputs:
        commands:
            - sudo zypper refresh
            - sudo zypper install -y unzip
```

**Esempio 2: saltare un passaggio**  
L'esempio seguente mostra due modi per saltare un passaggio. Uno utilizza un operatore logico e l'altro utilizza un operatore di confronto con l'azione del `Skip` passaggio.

```
# Creates a file if it does not exist using not
- name: CreateMyConfigFile-1
  action: ExecuteBash
  if:
    not:
      fileExists: '/etc/my_config'
  inputs:
    commands:
      - echo "Hello world" > '/etc/my_config'

# Creates a file if it does not exist using then and else
- name: CreateMyConfigFile-2
  action: ExecuteBash
  if:
    fileExists: '/etc/my_config'
    then: Skip
    else: Execute
  inputs:
    commands:
      - echo "Hello world" > '/etc/my_config'
```

# Usa gli operatori di confronto nei documenti AWSTOE dei componenti
<a name="toe-comparison-operators"></a>

È possibile utilizzare i seguenti operatori di confronto con il modulo di **[Affermare](toe-action-modules.md#action-modules-assertion)** azione e con le espressioni condizionali che utilizzano il[if ConstructSintassi](toe-conditional-constructs.md#toe-conditional-if). Un operatore di confronto può operare su un singolo valore, ad esempio`stringIsEmpty`, oppure confrontare un valore di base con un secondo valore (valore variabile) per determinare se l'espressione condizionale restituisce o. `true` `false`

Se il confronto opera su due valori, il secondo valore può essere una variabile di concatenamento.

Quando si confrontano valori di tipo diverso, prima del confronto possono verificarsi le seguenti conversioni di valore:
+ Per i confronti numerici, se il valore della variabile è una stringa, AWSTOE converte la stringa in un numero prima della valutazione. Se la conversione non è possibile, viene restituito il confronto. `false` Ad esempio, se il valore della variabile è`"1.0"`, la conversione funziona, ma se il valore della variabile è `"a10"` la conversione fallisce.
+ Per i confronti tra stringhe, se il valore della variabile è un numero, lo AWSTOE converte in una stringa prima della valutazione.

## Confronta le stringhe
<a name="toe-compare-strings"></a>

I seguenti operatori di confronto utilizzano le stringhe per confrontare valori, verificare la presenza di spazi o una stringa vuota o confrontare un valore di input con un modello regex. I confronti tra stringhe non fanno distinzione tra maiuscole e minuscole e non tagliano gli spazi dall'inizio o dalla fine degli input di stringa.

**Operatori di confronto tra stringhe**
+ [stringIsEmpty](#stringIsEmpty)
+ [stringIsWhitespace](#stringIsWhitespace)
+ [stringEquals](#stringEquals)
+ [stringLessThan](#stringLessThan)
+ [stringLessThanEquals](#stringLessThanEquals)
+ [stringGreaterThan](#stringGreaterThan)
+ [stringGreaterThanEquals](#stringGreaterThanEquals)
+ [patternMatches](#patternMatches)

**stringIsEmpty**  
L'`stringIsEmpty`operatore restituisce `true` se la stringa specificata non contiene caratteri. Esempio:  

```
# Evaluates to true
stringIsEmpty: ""

# Evaluates to false
stringIsEmpty: " "
				
# Evaluates to false
stringIsEmpty: "Hello."
```

**stringIsWhitespace**  
Verifica se la stringa specificata per `stringIsWhitespace` contiene solo spazi. Esempio:  

```
# Evaluates to true
stringIsWhitespace: "   "

# Evaluates to false
stringIsWhitespace: ""
				
# Evaluates to false
stringIsWhitespace: " Hello?"
```

**StringEquals**  
Verifica se la stringa specificata per `stringEquals` corrisponde esattamente alla stringa specificata nel parametro. `value` Esempio:  

```
# Evaluates to true
stringEquals: 'Testing, testing...'
value: 'Testing, testing...'

# Evaluates to false
stringEquals: 'Testing, testing...'
value: 'Hello again.'

# Evaluates to false
stringEquals: 'Testing, testing...'
value: 'TESTING, TESTING....'

# Evaluates to false
stringEquals: 'Testing, testing...'
value: '   Testing, testing...'
				
# Evaluates to false
stringEquals: 'Testing, testing...'
value: 'Testing, testing...   '
```

**stringLessThan**  
Verifica se la stringa specificata per `stringLessThan` è inferiore alla stringa specificata nel `value` parametro. Esempio:  

```
# Evaluates to true
# This comparison operator isn't case sensitive
stringlessThan: 'A'
value: 'a'

# Evaluates to true - 'a' is less than 'b'
stringlessThan: 'b'
value: 'a'

# Evaluates to true
# Numeric strings compare as less than alphabetic strings
stringlessThan: 'a'
value: '0'

# Evaluates to false
stringlessThan: '0'
value: 'a'
```

**stringLessThanUguale a**  
Verifica se la stringa specificata per `stringLessThanEquals` è minore o uguale alla stringa specificata nel `value` parametro. Esempio:  

```
# Evaluates to true - 'a' is equal to 'a'
stringLessThanEquals: 'a'
value: 'a'

# Evaluates to true - since the comparison isn't case sensitive, 'a' is equal to 'A'
stringLessThanEquals: 'A'
value: 'a'

# Evaluates to true - 'a' is less than 'b'
stringLessThanEquals: 'b'
value: 'a'

# Evaluates to true - '0' is less than 'a'
stringLessThanEquals: 'a'
value: '0'

# Evaluates to false - 'a' is greater than '0'
stringLessThanEquals: '0'
value: 'a'
```

**stringGreaterThan**  
Verifica se la stringa specificata per `stringGreaterThan` è maggiore della stringa specificata nel `value` parametro. Esempio:  

```
# Evaluates to false - since the comparison isn't case sensitive, 'A' is equal to 'a'
stringGreaterThan: 'a'
value: 'A'

# Evaluates to true - 'b' is greater than 'a'
stringGreaterThan: 'a'
value: 'b'

# Evaluates to true - 'a' is greater than '0'
stringGreaterThan: '0'
value: 'a'

# Evaluates to false - '0' is less than 'a'
stringGreaterThan: 'a'
value: '0'
```

**stringGreaterThanUguale a**  
Verifica se la stringa specificata per `stringGreaterThanEquals` è maggiore o uguale alla stringa specificata nel `value` parametro. Esempio:  

```
# Evaluates to true - 'a' is equal to 'A'
stringGreaterThanEquals: 'A'
value: 'a'

# Evaluates to true - 'b' is greater than 'a'
stringGreaterThanEquals: 'a'
value: 'b'

# Evaluates to true - 'a' is greater than '0'
stringGreaterThanEquals: '0'
value: 'a'

# Evaluates to false - '0' is less than 'a'
stringGreaterThanEquals: 'a'
value: '0'
```

**Pattern Matches**  
Verifica se la stringa specificata nel `value` parametro corrisponde al modello regex specificato per. `patternMatches` Il confronto utilizza il [pacchetto Golang regexp](https://pkg.go.dev/regexp), che è conforme alla sintassi. RE2 Per ulteriori informazioni sulle RE2 regole, consulta il repository [google/re2](https://github.com/google/re2/wiki/Syntax) in. *GitHub*  
L'esempio seguente mostra un pattern match che restituisce: `true`  

```
patternMatches: '^[a-z]+$'
value: 'ThisIsValue'
```

## Confronta i numeri
<a name="toe-compare-numbers"></a>

I seguenti operatori di confronto funzionano con i numeri. I valori forniti per questi operatori devono essere di uno dei seguenti tipi, in base alla specifica YAML. Il supporto per i confronti numerici utilizza l'operatore di confronto di pacchetti golang big, ad esempio: [func (](https://pkg.go.dev/math/big#Float.Cmp)\$1Float) Cmp.
+ Numero intero
+ Float (basato su float64, che supporta numeri da -1.7e\$1308 a \$11.7e\$1308)
+ Una stringa che corrisponde al seguente schema regex: `^[-+]?([0-9]+[.])?[0-9]+$`

**Operatori di confronto numerico**
+ [numberEquals](#numberEquals)
+ [numberLessThan](#numberLessThan)
+ [numberLessThanEquals](#numberLessThanEquals)
+ [numberGreaterThan](#numberGreaterThan)
+ [numberGreaterThanEquals](#numberGreaterThanEquals)

**Numero uguale a**  
Verifica se il numero specificato per `numberEquals` è uguale al numero specificato nel parametro. `value` Tutti i seguenti esempi di confronto restituiscono`true`:  

```
# Values provided as a positive number
numberEquals: 1
value: 1

# Comparison value provided as a string
numberEquals: '1'
value: 1

# Value provided as a string
numberEquals: 1
value: '1'

# Values provided as floats
numberEquals: 5.0
value: 5.0

# Values provided as a negative number
numberEquals: -1
value: -1
```

**numberLessThan**  
Verifica se il numero specificato per `numberLessThan` è inferiore al numero specificato nel `value` parametro. Esempio:  

```
# Evaluates to true
numberLessThan: 2
value: 1

# Evaluates to true
numberLessThan: 2
value: 1.9

# Evaluates to false
numberLessThan: 2
value: '2'
```

**numberLessThanUguale a**  
Verifica se il numero specificato per `numberLessThanEquals` è inferiore o uguale al numero specificato nel `value` parametro. Esempio:  

```
# Evaluates to true
numberLessThanEquals: 2
value: 1

# Evaluates to true
numberLessThanEquals: 2
value: 1.9

# Evaluates to true
numberLessThanEquals: 2
value: '2'

# Evaluates to false
numberLessThanEquals: 2
value: 2.1
```

**numberGreaterThan**  
Verifica se il numero specificato per `numberGreaterThan` è maggiore del numero specificato nel `value` parametro. Esempio:  

```
# Evaluates to true
numberGreaterThan: 1
value: 2

# Evaluates to true
numberGreaterThan: 1
value: 1.1

# Evaluates to false
numberGreaterThan: 1
value: '1'
```

**numberGreaterThanUguale a**  
Verifica se il numero specificato per `numberGreaterThanEquals` è maggiore o uguale al numero specificato nel `value` parametro. Esempio:  

```
# Evaluates to true
numberGreaterThanEquals: 1
value: 2

# Evaluates to true
numberGreaterThanEquals: 1
value: 1.1

# Evaluates to true
numberGreaterThanEquals: 1
value: '1'

# Evaluates to false
numberGreaterThanEquals: 1
value: 0.8
```

## Controlla i file
<a name="toe-check-files"></a>

I seguenti operatori di confronto controllano l'hash del file o controllano se esiste un file o una cartella.

**Operatori di file e cartelle**
+ [binaryExists](#binaryExists)
+ [fileExists](#fileExists)
+ [folderExists](#folderExists)
+ [fileMD5Equals](#fileMD5Equals)
+ [fileSHA1Equals](#fileSHA1Equals)
+ [fileSHA256Equals](#fileSHA256Equals)
+ [fileSHA512Equals](#fileSHA512Equals)

**Il binario esiste**  
Verifica se un'applicazione è disponibile nel percorso corrente. Esempio:  

```
binaryExists: 'foo'
```
Sui sistemi Linux e macOS, per un'applicazione denominata*foo*, funziona come il seguente comando bash:**type *foo* >/dev/null 2>&1**, dove **\$1? == 0** indica un confronto riuscito.  
Sui sistemi Windows, per un'applicazione denominata*foo*, funziona come il PowerShell comando **& C:\$1Windows\$1System32\$1where.exe /Q *foo*** dove **\$1LASTEXITCODE = 0** indica un confronto riuscito.

**Il file esiste**  
Verifica se un file esiste nel percorso specificato. È possibile fornire un percorso assoluto o relativo. Se la posizione specificata esiste ed è un file, il confronto restituisce. `true` Esempio:  

```
fileExists: '/path/to/file'
```
Sui sistemi Linux e macOS, funziona come il seguente comando bash:**-d */path/to/file***, dove **\$1? == 0** indica un confronto riuscito.  
Sui sistemi Windows, funziona come il PowerShell comando. **Test-Path -Path '*C:\$1path\$1to\$1file*' -PathType 'Leaf'**

**La cartella esiste**  
Verifica se esiste una cartella nel percorso specificato. È possibile fornire un percorso assoluto o relativo. Se la posizione specificata esiste ed è una cartella, il confronto restituisce. `true` Esempio:  

```
folderExists: '/path/to/folder'
```
Sui sistemi Linux e macOS, funziona come il seguente comando bash:**-d */path/to/folder***, dove **\$1? == 0** indica un confronto riuscito.  
Sui sistemi Windows, funziona come il PowerShell comando. **Test-Path -Path '*C:\$1path\$1to\$1folder*' -PathType 'Container'**

**file è uguale MD5 a**  
Verifica se l' MD5 hash di un file è uguale a un valore specificato. Esempio:  

```
fileMD5Equals: '<MD5Hash>'
path: '/path/to/file'
```

**file è uguale a SHA1**  
Verifica se l' SHA1 hash di un file è uguale a un valore specificato. Esempio:  

```
fileSHA1Equals: '<SHA1Hash>'
path: '/path/to/file'
```

**file è uguale a SHA256**  
Verifica se l' SHA256 hash di un file è uguale a un valore specificato. Esempio:  

```
fileSHA256Equals: '<SHA256Hash>'
path: '/path/to/file'
```

**file è uguale a SHA512**  
Verifica se l' SHA512 hash di un file è uguale a un valore specificato. Esempio:  

```
fileSHA512Equals: '<SHA512Hash>'
path: '/path/to/file'
```

# Utilizzo di operatori logici nei documenti AWSTOE dei componenti
<a name="toe-logical-operators"></a>

È possibile utilizzare i seguenti operatori logici per aggiungere o modificare espressioni condizionali nel documento componente. AWSTOE valuta le espressioni condizionali nell'ordine in cui sono specificate le condizioni. Per ulteriori informazioni sugli operatori di confronto per i documenti dei componenti, vedere. [Usa gli operatori di confronto nei documenti AWSTOE dei componenti](toe-comparison-operators.md)

** e **  
Con l'`and`operatore, è possibile valutare due o più confronti come un'unica espressione. L'espressione restituisce `true` quando tutte le condizioni dell'elenco sono vere. In caso contrario, l'espressione restituisce. `false`  
**Esempi:**  
L'esempio seguente esegue due confronti: una stringa e un numero. Entrambi i confronti sono veri, quindi l'espressione restituisce vero.

```
and:
  - stringEquals: 'test_string'
    value: 'test_string'
  - numberEquals: 1
    value: 1
```
L'esempio seguente esegue anche due confronti. Il primo confronto è falso, a quel punto la valutazione si interrompe e il secondo confronto viene saltato. L'espressione restituisce. `false`  

```
and:
  - stringEquals: 'test_string'
    value: 'Hello world!'
  - numberEquals: 1
    value: 1
```

**oppure**  
Con l'`or`operatore, è possibile valutare due o più confronti come un'unica espressione. L'espressione restituisce `true` quando uno dei confronti specificati è vero. Se nessuno dei confronti specificati restituisce un risultato positivo`true`, l'espressione restituisce lo stesso risultato. `false`  
**Esempi:**  
L'esempio seguente esegue due confronti: una stringa e un numero. Il primo confronto è vero, quindi l'espressione restituisce un risultato `true` e il secondo confronto viene saltato.

```
or:
  - stringEquals: 'test_string'
    value: 'test_string'
  - numberEquals: 1
    value: 3
```
L'esempio seguente esegue anche due confronti. Il primo confronto è falso e la valutazione continua. Il secondo confronto è vero, quindi l'espressione restituisce come. `true`  

```
or:
  - stringEquals: 'test_string'
    value: 'Hello world!'
  - numberEquals: 1
    value: 1
```
Nell'ultimo esempio, entrambi i confronti sono falsi, quindi l'espressione restituisce come. `false`  

```
or:
  - stringEquals: 'test_string'
    value: 'Hello world!'
  - numberEquals: 1
    value: 3
```

**non**  
Con l'`not`operatore, puoi annullare un singolo confronto. L'espressione restituisce `true` se il confronto è falso. Se il confronto è vero, l'espressione restituisce. `false`  
**Esempi:**  
L'esempio seguente esegue un confronto tra stringhe. Il confronto è falso, quindi l'espressione restituisce come risultato. `true`

```
not:
  - stringEquals: 'test_string'
    value: 'Hello world!'
```
L'esempio seguente esegue anche un confronto tra stringhe. Il confronto è vero, quindi l'espressione restituisce. `false`  

```
not:
  - stringEquals: 'test_string'
    value: 'test_string'
```

# Usa costrutti a ciclo continuo in AWSTOE
<a name="toe-looping-constructs"></a>

Questa sezione fornisce informazioni per aiutarvi a creare costrutti ciclici in. AWSTOE I costrutti di looping definiscono una sequenza ripetuta di istruzioni. È possibile utilizzare i seguenti tipi di costrutti di loop in: AWSTOE
+ `for`costrutti: esegue l'iterazione su una sequenza limitata di numeri interi.
+ `forEach`costrutti
  + `forEach`loop with input list — Itera su una raccolta finita di stringhe. 
  + `forEach`loop con elenco delimitato — Itera su una raccolta finita di stringhe unite da un delimitatore.

**Nota**  
I costrutti di looping supportano solo i tipi di dati di tipo stringa.

**Topics**
+ [Variabili di iterazione di riferimento](#toe-loop-iteration-variables)
+ [Tipi di costrutti a ciclo continuo](#toe-loop-types)
+ [Campi Step](#toe-loop-step-fields)
+ [Uscite di fase e iterazione](#toe-loop-step-output)

## Variabili di iterazione di riferimento
<a name="toe-loop-iteration-variables"></a>

Per fare riferimento all'indice e al valore della variabile di iterazione corrente, l'espressione di riferimento `{{ loop.* }}` deve essere utilizzata all'interno del corpo di input di un passaggio che contiene un costrutto ciclico. Questa espressione non può essere utilizzata per fare riferimento alle variabili di iterazione del costrutto di looping di un altro passaggio.

L'espressione di riferimento è composta dai seguenti membri:
+ `{{ loop.index }}`— La posizione ordinale dell'iterazione corrente, indicizzata in. `0` 
+ `{{ loop.value }}`— Il valore associato alla variabile di iterazione corrente. 

### Nomi dei loop
<a name="toe-loop-iteration-variables-names"></a>

 Tutti i costrutti in loop hanno un campo nome opzionale per l'identificazione. Se viene fornito un nome di ciclo, può essere utilizzato per fare riferimento alle variabili di iterazione nel corpo di input del passaggio. Per fare riferimento agli indici di iterazione e ai valori di un ciclo denominato, utilizzate `{{ <loop_name>.* }}` with `{{ loop.* }}` nel corpo di input del passaggio. Questa espressione non può essere utilizzata per fare riferimento al costrutto di looping denominato di un altro passaggio. 

L'espressione di riferimento è composta dai seguenti membri:
+ `{{ <loop_name>.index }}`— La posizione ordinale dell'iterazione corrente del ciclo denominato, indicizzata in. `0`
+ `{{ <loop_name>.value }}`— Il valore associato alla variabile di iterazione corrente del ciclo denominato.

### Risolve le espressioni di riferimento
<a name="toe-loop-iteration-variables-expressions"></a>

 AWSTOE Risolve le espressioni di riferimento come segue: 
+ `{{ <loop_name>.* }}`— AWSTOE risolve questa espressione utilizzando la logica seguente:
  + Se il ciclo del passaggio attualmente in esecuzione corrisponde al `<loop_name>` valore, l'espressione di riferimento si risolve nel costrutto di loop del passaggio attualmente in esecuzione.
  + `<loop_name>`si risolve nel costrutto di looping denominato se appare nella fase attualmente in esecuzione.
+ `{{ loop.* }}`— AWSTOE risolve l'espressione utilizzando il costrutto di looping definito nella fase attualmente in esecuzione.

Se le espressioni di riferimento vengono utilizzate all'interno di un passaggio che non contiene un ciclo, non AWSTOE risolve le espressioni e vengono visualizzate nel passaggio senza alcuna sostituzione. 

**Nota**  
Le espressioni di riferimento devono essere racchiuse tra virgolette doppie per essere interpretate correttamente dal compilatore YAML.

## Tipi di costrutti a ciclo continuo
<a name="toe-loop-types"></a>

Questa sezione fornisce informazioni ed esempi sui tipi di costrutti di looping che possono essere utilizzati in. AWSTOE

**Topics**
+ [`for`ciclo](#toe-loop-types-for)
+ [`forEach`loop con elenco di input](#toe-loop-types-foreach)
+ [`forEach`ciclo con elenco delimitato](#toe-loop-types-foreach-delimited)

### `for`ciclo
<a name="toe-loop-types-for"></a>

Il `for` ciclo itera su un intervallo di numeri interi specificato all'interno di un limite delineato dall'inizio e dalla fine delle variabili. I valori di iterazione sono inclusi nel set `[start, end]` e includono i valori limite.

AWSTOE verifica i `updateBy` valori `start``end`, e per garantire che la combinazione non produca un ciclo infinito.

`for`schema ad anello

```
  - name: "StepName"
    action: "ActionModule"
    loop:
      name: "string"
      for:
        start: int
        end: int
        updateBy: int
inputs:
  ...
```


**`for`ingresso in loop**  

| Campo | Description | Tipo | Obbligatorio | Predefinita | 
| --- | --- | --- | --- | --- | 
|  `name`  | Nome univoco del ciclo. Deve essere univoco rispetto ad altri nomi di loop nella stessa fase. |  Stringa  |  No  |  ""  | 
|  `start`  | Valore iniziale dell'iterazione. Non accetta espressioni concatenate.  |  Numero intero  |  Sì  |  N/A  | 
| `end` | Valore finale dell'iterazione. Non accetta espressioni concatenate.  | Numero intero | Sì | N/A | 
| `updateBy` | Differenza in base alla quale un valore iterativo viene aggiornato tramite addizione. Deve essere un valore negativo o positivo diverso da zero. Non accetta espressioni concatenate.  | Numero intero | Sì | N/A | 

`for`esempio di input in loop

```
  - name: "CalculateFileUploadLatencies"
    action: "ExecutePowerShell"
    loop:
      for:
        start: 100000
        end: 1000000
        updateBy: 100000
    inputs:
      commands:
        - |
          $f = new-object System.IO.FileStream c:\temp\test{{ loop.index }}.txt, Create, ReadWrite
          $f.SetLength({{ loop.value }}MB)
          $f.Close()
        - c:\users\administrator\downloads\latencyTest.exe --file c:\temp\test{{ loop.index }}.txt
        - AWS s3 cp c:\users\administrator\downloads\latencyMetrics.json s3://bucket/latencyMetrics.json
        - |
          Remove-Item -Path c:\temp\test{{ loop.index }}.txt
          Remove-Item -Path c:\users\administrator\downloads\latencyMetrics.json
```

### `forEach`loop con elenco di input
<a name="toe-loop-types-foreach"></a>

Il `forEach` ciclo itera su un elenco esplicito di valori, che può essere costituito da stringhe ed espressioni concatenate. 

`forEach`ciclo con schema di elenco di input

```
  - name: "StepName"
    action: "ActionModule"
    loop:
      name: "string"
      forEach:
        - "string"
    inputs:
  ...
```


**`forEach`loop con immissione della lista di input**  

| Campo | Description | Tipo | Obbligatorio | Predefinita | 
| --- | --- | --- | --- | --- | 
|  `name`  | Nome univoco del ciclo. Deve essere univoco rispetto ad altri nomi di loop nella stessa fase. |  Stringa  |  No  |  ""  | 
|  Elenco di stringhe di loop `forEach`  |  Elenco di stringhe per l'iterazione. Accetta espressioni concatenate come stringhe nell'elenco. Le espressioni concatenate devono essere racchiuse tra virgolette doppie affinché il compilatore YAML le interpreti correttamente.  |  Elenco di stringhe  |  Sì  |  N/A  | 

`forEach`ciclo con elenco di input (esempio 1)

```
  - name: "ExecuteCustomScripts"
    action: "ExecuteBash"
    loop:
      name: BatchExecLoop
      forEach:
        - /tmp/script1.sh
        - /tmp/script2.sh
        - /tmp/script3.sh
    inputs:
      commands:
        - echo "Count {{ BatchExecLoop.index }}"
        - sh "{{ loop.value }}"
        - |
          retVal=$?
          if [ $retVal -ne 0 ]; then
            echo "Failed"
          else
            echo "Passed"
         fi
```

`forEach`ciclo con elenco di input (esempio 2)

```
  - name: "RunMSIWithDifferentArgs"
    action: "ExecuteBinary"
    loop:
      name: MultiArgLoop
      forEach:
        - "ARG1=C:\Users ARG2=1"
        - "ARG1=C:\Users"
        - "ARG1=C:\Users ARG3=C:\Users\Administrator\Documents\f1.txt"
    inputs:
      commands:
        path: "c:\users\administrator\downloads\runner.exe"
        args:
          - "{{ MultiArgLoop.value }}"
```

`forEach`ciclo con elenco di input (esempio 3)

```
  - name: "DownloadAllBinaries"
    action: "S3Download"
    loop:
      name: MultiArgLoop
      forEach:
        - "bin1.exe"
        - "bin10.exe"
        - "bin5.exe"
    inputs:
      - source: "s3://bucket/{{ loop.value }}"
        destination: "c:\temp\{{ loop.value }}"
```

### `forEach`ciclo con elenco delimitato
<a name="toe-loop-types-foreach-delimited"></a>

Il ciclo scorre su una stringa contenente valori separati da un delimitatore. Per iterare sui componenti della stringa, AWSTOE utilizza il delimitatore per dividere la stringa in un array adatto all'iterazione. 

`forEach`ciclo con schema a elenco delimitato

```
  - name: "StepName"
    action: "ActionModule"
    loop:
      name: "string"
      forEach:
        list: "string"
        delimiter: ".,;:\n\t -_"
    inputs:
  ...
```


**`forEach`ciclo con inserimento di un elenco delimitato**  

| Campo | Description | Tipo | Obbligatorio | Predefinita | 
| --- | --- | --- | --- | --- | 
|  `name`  | Nome univoco assegnato al ciclo. Dovrebbe essere unico se confrontato con altri nomi di loop nella stessa fase. |  Stringa  |  No  |  ""  | 
|  `list`  | Una stringa composta da stringhe costituenti unite da un carattere delimitatore comune. Accetta anche espressioni concatenate. In caso di espressioni concatenate, assicuratevi che siano racchiuse tra virgolette doppie per una corretta interpretazione da parte del compilatore YAML. | Stringa |  Sì  |  N/A  | 
| `delimiter` | Carattere usato per separare le stringhe all'interno di un blocco. L'impostazione predefinita è il carattere virgola. È consentito un solo carattere delimitatore dall'elenco fornito: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/imagebuilder/latest/userguide/toe-looping-constructs.html) Le espressioni concatenate non possono essere utilizzate. | Stringa | No | Virgola: "," | 

**Nota**  
Il valore di `list` viene considerato come una stringa immutabile. Se l'origine di `list` viene modificata durante l'esecuzione, non verrà riflessa durante l'esecuzione.

`forEach`ciclo con elenco delimitato (esempio 1)

Questo esempio utilizza il seguente modello di espressione concatenata per fare riferimento all'output di un altro passaggio:. `<phase_name>.<step_name>.[inputs | outputs].<var_name>`

```
  - name: "RunMSIs"
    action: "ExecuteBinary"
    loop:
      forEach:
        list: "{{ build.GetAllMSIPathsForInstallation.outputs.stdout }}"
        delimiter: "\n"
    inputs:
      commands:
        path: "{{ loop.value }}"
```

`forEach`ciclo con elenco delimitato (esempio 2)

```
  - name: "UploadMetricFiles"
    action: "S3Upload"
    loop:
      forEach:
        list: "/tmp/m1.txt,/tmp/m2.txt,/tmp/m3.txt,..."
    inputs:
      commands:
        - source: "{{ loop.value }}"
          destination: "s3://bucket/key/{{ loop.value }}"
```

## Campi Step
<a name="toe-loop-step-fields"></a>

I loop fanno parte di un passaggio. Qualsiasi campo relativo all'esecuzione di un passaggio non viene applicato alle singole iterazioni. I campi della fase si applicano solo a livello di fase, come segue:
+ *TimeoutSeconds*: tutte le iterazioni del ciclo devono essere eseguite entro il periodo di tempo specificato in questo campo. Se l'esecuzione del ciclo scade, AWSTOE esegue la politica di riprova del passaggio e reimposta il parametro di timeout per ogni nuovo tentativo. Se l'esecuzione del ciclo supera il valore di timeout dopo aver raggiunto il numero massimo di tentativi, il messaggio di errore della fase indica che l'esecuzione del ciclo è scaduta. 
+ *OnFailure*: la gestione degli errori viene applicata alla fase nel modo seguente:
  + Se *OnFailure* è impostato su`Abort`, AWSTOE esce dal ciclo e riprova il passaggio in base alla politica di ripetizione dei tentativi. Dopo il numero massimo di tentativi, AWSTOE contrassegna il passaggio corrente come fallito e interrompe l'esecuzione del processo.

    AWSTOE imposta il codice di stato per la fase principale e il documento su`Failed`.
**Nota**  
Nessun altro passaggio viene eseguito dopo il passaggio fallito.
  + Se *OnFailure* è impostato su`Continue`, AWSTOE esce dal ciclo e riprova il passaggio in base alla politica di ripetizione dei tentativi. Dopo il numero massimo di tentativi, AWSTOE contrassegna il passaggio corrente come fallito e continua a eseguire il passaggio successivo.

    AWSTOE imposta il codice di stato per la fase principale e il documento su`Failed`.
  + Se *OnFailure* è impostato su`Ignore`, AWSTOE esce dal ciclo e riprova il passaggio in base alla politica di ripetizione dei tentativi. Dopo il numero massimo di tentativi, AWSTOE contrassegna il passaggio corrente come `IgnoredFailure` e continua a eseguire il passaggio successivo.

    AWSTOE imposta il codice di stato per la fase principale e il documento su`SuccessWithIgnoredFailure`.
**Nota**  
Viene comunque considerata un'esecuzione riuscita, ma include informazioni che indicano che uno o più passaggi non sono riusciti e sono stati ignorati.
+ *MaxAttempts*: per ogni nuovo tentativo, l'intero passaggio e tutte le iterazioni vengono eseguiti dall'inizio.
+ *status: lo* stato generale dell'esecuzione di un passaggio. `status`non rappresenta lo stato delle singole iterazioni. Lo stato di un passaggio con loop è determinato come segue:
  + Se una singola iterazione non viene eseguita, lo stato di un passaggio indica un errore.
  + Se tutte le iterazioni hanno esito positivo, lo stato di un passaggio indica un successo.
+ *startTime*: l'ora di inizio complessiva dell'esecuzione di un passaggio. Non rappresenta l'ora di inizio delle singole iterazioni.
+ *EndTime*: l'ora di fine complessiva dell'esecuzione di un passaggio. Non rappresenta l'ora di fine delle singole iterazioni.
+ *FailureMessage*: include gli indici di iterazione che hanno avuto esito negativo in caso di errori diversi dal timeout. In caso di errori di timeout, il messaggio indica che l'esecuzione del ciclo non è riuscita. Non vengono forniti messaggi di errore individuali per ogni iterazione per ridurre al minimo la dimensione dei messaggi di errore.

## Uscite di fase e iterazione
<a name="toe-loop-step-output"></a>

Ogni iterazione contiene un output. Alla fine di un ciclo, AWSTOE consolida tutti gli output di iterazione riusciti in. `detailedOutput.json` Gli output consolidati sono una raccolta di valori che appartengono alle chiavi di output corrispondenti, come definito nello schema di output del modulo di azione. L'esempio seguente mostra come vengono consolidati gli output:

**Output di `ExecuteBash` per l'iterazione 1**

```
{
	"stdout":"Hello"
}
```

**Output di `ExecuteBash` per l'iterazione 2**

```
{
	"stdout":"World"
}
```

**Output di `ExecuteBash` for Step**

```
{
	"stdout":"Hello\nWorld"
}
```

Ad esempio `ExecuteBash``ExecutePowerShell`, e `ExecuteBinary` sono moduli di azione che restituiscono `STDOUT` come output del modulo di azione. `STDOUT`i messaggi vengono uniti al nuovo carattere di riga per produrre l'output complessivo dello step in`detailedOutput.json`.

AWSTOE non consoliderà i risultati delle iterazioni non riuscite.

# Moduli di azione supportati dal gestore AWSTOE dei componenti
<a name="toe-action-modules"></a>

I servizi di creazione di immagini, come EC2 Image Builder AWSTOE , utilizzano moduli di azione per facilitare la configurazione delle istanze EC2 utilizzate per creare e testare immagini di macchine personalizzate. Questa sezione descrive le funzionalità dei moduli di AWSTOE azione di uso comune e come configurarli, inclusi alcuni esempi.

I componenti sono creati con documenti YAML in testo semplice. Per ulteriori informazioni sulla sintassi dei documenti, vedere. [Usa il framework AWSTOE dei documenti dei componenti per i componenti personalizzati](toe-use-documents.md)

**Nota**  
Tutti i moduli di azione utilizzano lo stesso account dell'agente Systems Manager quando vengono eseguiti, ovvero `root` su Linux e `NT Authority\SYSTEM` su Windows.

Il seguente riferimento incrociato classifica i moduli di azione in base al tipo di azioni che eseguono.

 

**Esecuzione generale**
+ [Assert (Linux, Windows, macOS)](#action-modules-assertion)
+ [ExecuteBash (Linux, macOS)](#action-modules-executebash)
+ [ExecuteBinary (Linux, Windows, macOS)](#action-modules-executebinary)
+ [ExecuteDocument (Linux, Windows, macOS)](#action-modules-executedocument)
+ [ExecutePowerShell (Windows)](#action-modules-executepowershell)

 

**Scaricamento e caricamento di file**
+ [Scarica S3 (Linux, Windows, macOS)](#action-modules-s3download)
+ [Caricamento S3 (Linux, Windows, macOS)](#action-modules-s3upload)
+ [WebDownload (Linux, Windows, macOS)](#action-modules-webdownload)

 

**Operazioni del file system**
+ [AppendFile (Linux, Windows, macOS)](#action-modules-appendfile)
+ [CopyFile (Linux, Windows, macOS)](#action-modules-copyfile)
+ [CopyFolder (Linux, Windows, macOS)](#action-modules-copyfolder)
+ [CreateFile (Linux, Windows, macOS)](#action-modules-createfile)
+ [CreateFolder (Linux, Windows, macOS)](#action-modules-createfolder)
+ [CreateSymlink (Linux, Windows, macOS)](#action-modules-createsymlink)
+ [DeleteFile (Linux, Windows, macOS)](#action-modules-deletefile)
+ [DeleteFolder (Linux, Windows, macOS)](#action-modules-deletefolder)
+ [ListFiles (Linux, Windows, macOS)](#action-modules-listfiles)
+ [MoveFile (Linux, Windows, macOS)](#action-modules-movefile)
+ [MoveFolder (Linux, Windows, macOS)](#action-modules-movefolder)
+ [ReadFile (Linux, Windows, macOS)](#action-modules-readfile)
+ [SetFileEncoding (Linux, Windows, macOS)](#action-modules-setfileencoding)
+ [SetFileOwner (Linux, Windows, macOS)](#action-modules-setfileowner)
+ [SetFolderOwner (Linux, Windows, macOS)](#action-modules-setfolderowner)
+ [SetFilePermissions (Linux, Windows, macOS)](#action-modules-setfilepermissions)
+ [SetFolderPermissions (Linux, Windows, macOS)](#action-modules-setfolderpermissions)

 

**Azioni di installazione del software**
+ [Installa MSI (Windows)](#action-modules-install-msi)
+ [Disinstalla MSI (Windows)](#action-modules-uninstall-msi)

 

**Azioni di sistema**
+ [Riavvio (Linux, Windows)](#action-modules-reboot)
+ [SetRegistry (Windows)](#action-modules-setregistry)
+ [UpdateOS (Linux, Windows)](#action-modules-updateos)

## Moduli di esecuzione generali
<a name="action-modules-general-execution"></a>

La sezione seguente contiene dettagli sui moduli di azione che eseguono comandi e controllano il flusso di lavoro di esecuzione.

**Topics**
+ [Assert (Linux, Windows, macOS)](#action-modules-assertion)
+ [ExecuteBash (Linux, macOS)](#action-modules-executebash)
+ [ExecuteBinary (Linux, Windows, macOS)](#action-modules-executebinary)
+ [ExecuteDocument (Linux, Windows, macOS)](#action-modules-executedocument)
+ [ExecutePowerShell (Windows)](#action-modules-executepowershell)

### Assert (Linux, Windows, macOS)
<a name="action-modules-assertion"></a>

Il modulo di azione **Assert** esegue confronti di valori utilizzando [Operatori di confronto](toe-comparison-operators.md) o [Operatori logici](toe-logical-operators.md) come input. Il risultato dell'espressione dell'operatore (vero o falso) indica lo stato complessivo di successo o di fallimento della fase.

Se l'espressione dell'operatore logico o di confronto restituisce un risultato positivo`true`, il passaggio viene contrassegnato come`Success`. In caso contrario, il passaggio viene contrassegnato come`Failed`. Se il passaggio fallisce, il `onFailure` parametro decide il risultato del passaggio.


**Input**  

| Nome chiave | Description | Tipo | Richiesto | 
| --- | --- | --- | --- | 
| input | Contiene un singolo operatore logico o di confronto. Nota, gli operatori logici possono contenere più di un operatore di confronto. | Questo valore è variabile, a seconda dell'operatore | Sì | 

**Esempio di input: un semplice confronto utilizzando l'operatore di `stringEquals` confronto**

Questo esempio restituisce. `true`

```
- name: StringComparison
  action: Assert
  inputs:
    stringEquals: '2.1.1'
    value: '{{ validate.ApplicationVersion.outputs.stdout }}'
```

**Esempio di input: confronti Regex utilizzando l'operatore di confronto `patternMatches`**

Tutti questi esempi restituiscono. `true`

```
- name: Letters only
  action: Assert
  inputs:
    patternMatches: '^[a-zA-Z]+$'
    value: 'ThisIsOnlyLetters'

- name: Letters and spaces only
  action: Assert
  inputs:
    patternMatches: '^[a-zA-Z\s]+$'
    value: 'This text contains spaces'
  
- name: Numbers only
  action: Assert
  inputs:
    patternMatches: '^[0-9]+$'
    value: '1234567890'
```

**Esempio di input: confronti annidati con operatori logici e variabili concatenate**

L'esempio seguente illustra i confronti annidati con operatori logici che utilizzano confronti con variabili concatenate. Viene `Assert` restituito `true` se una delle seguenti condizioni è vera:
+ Il `ApplicationVersion` è maggiore `2.0` e `CPUArchitecture` uguale `arm64` a.
+ Gli `CPUArchitecture` uguali. `x86_64`

```
- name: NestedComparisons
  action: Assert
  inputs:
    or: # <- first level deep
      - and: # <- second level deep
          - numberGreaterThan: 2.0 # <- third level deep
            value: '{{ validate.ApplicationVersion.outputs.stdout }}'
          - stringEquals: 'arm64'
            value: '{{ validate.CPUArchitecture.outputs.stdout }}'
      - stringEquals: 'x86_64'
        value: '{{ validate.CPUArchitecture.outputs.stdout }}'
```

**Output:**

Il risultato di un `Assert` è il successo o il fallimento della fase.

### ExecuteBash (Linux, macOS)
<a name="action-modules-executebash"></a>

Il modulo **ExecuteBash**action consente di eseguire script bash con codice/comandi di shell in linea. Questo modulo supporta Linux. 

Tutti i comandi e le istruzioni specificati nel blocco dei comandi vengono convertiti in un file (ad esempio`input.sh`) ed eseguiti con la shell bash. Il risultato dell'esecuzione del file shell è il codice di uscita del passaggio. 

Il **ExecuteBash**modulo gestisce i riavvii del sistema se lo script esce con un codice di uscita di. `194` Una volta avviata, l'applicazione esegue una delle seguenti azioni:
+ L'applicazione consegna il codice di uscita al chiamante se viene eseguita dall'agente Systems Manager. Systems Manager Agent gestisce il riavvio del sistema ed esegue lo stesso passaggio che ha avviato il riavvio, come descritto in [Riavvio di un'istanza gestita dagli script](https://docs.aws.amazon.com/systems-manager/latest/userguide/send-commands-reboot.html).
+ L'applicazione salva la versione corrente`executionstate`, configura un trigger di riavvio per rieseguire l'applicazione e riavvia il sistema.

Dopo il riavvio del sistema, l'applicazione esegue lo stesso passaggio che ha avviato il riavvio. Se è necessaria questa funzionalità, è necessario scrivere script idempotenti in grado di gestire più invocazioni dello stesso comando di shell.


**Input**  

| Nome chiave | Description | Tipo | Richiesto | 
| --- | --- | --- | --- | 
| commands | Contiene un elenco di istruzioni o comandi da eseguire secondo la sintassi di bash. È consentito lo standard YAML multilinea. | List | Sì | 

**Esempio di input: prima e dopo il riavvio**

```
name: ExitCode194Example
description: This shows how the exit code can be used to restart a system with ExecuteBash
schemaVersion: 1.0
phases:
  - name: build
    steps:
      - name: RestartTrigger
        action: ExecuteBash
        inputs:
          commands:
            - |
              REBOOT_INDICATOR=/var/tmp/reboot-indicator
              if [ -f "${REBOOT_INDICATOR}" ]; then
                echo 'The reboot file exists. Deleting it and exiting with success.'
                rm "${REBOOT_INDICATOR}"
                exit 0
              fi
              echo 'The reboot file does not exist. Creating it and triggering a restart.'
              touch "${REBOOT_INDICATOR}"
              exit 194
```


**Output**  

| Campo | Description | Tipo | 
| --- | --- | --- | 
| stdout | Output standard dell'esecuzione del comando. | stringa | 

Se avvii un riavvio e restituisci il codice di uscita `194` come parte del modulo di azione, la compilazione riprenderà dalla stessa fase del modulo di azione che ha avviato il riavvio. Se avvii un riavvio senza il codice di uscita, il processo di compilazione potrebbe non riuscire.

**Esempio di output: prima del riavvio (prima lettura del documento)**

```
{
	“stdout”: “The reboot file does not exist. Creating it and triggering a restart."
}
```

**Esempio di output: dopo il riavvio, (seconda volta nel documento)**

```
{
	“stdout”: “The reboot file exists. Deleting it and exiting with success."
}
```

### ExecuteBinary (Linux, Windows, macOS)
<a name="action-modules-executebinary"></a>

Il modulo di **ExecuteBinary**azione consente di eseguire file binari con un elenco di argomenti della riga di comando.

Il **ExecuteBinary**modulo gestisce i riavvii del sistema se il file binario esce con un codice di uscita `194` (Linux) o `3010` (Windows). Quando ciò accade, l'applicazione esegue una delle seguenti azioni:
+ L'applicazione consegna il codice di uscita al chiamante se viene eseguita dall'agente Systems Manager. Systems Manager Agent gestisce il riavvio del sistema ed esegue lo stesso passaggio che ha avviato il riavvio, come descritto in [Riavvio](https://docs.aws.amazon.com/systems-manager/latest/userguide/send-commands-reboot.html) di un'istanza gestita dagli script.
+ L'applicazione salva la versione corrente`executionstate`, configura un trigger di riavvio per rieseguire l'applicazione e riavvia il sistema.

Dopo il riavvio del sistema, l'applicazione esegue lo stesso passaggio che ha avviato il riavvio. Se è necessaria questa funzionalità, è necessario scrivere script idempotenti in grado di gestire più invocazioni dello stesso comando di shell.


**Input**  

| Nome chiave | Description | Tipo | Richiesto | 
| --- | --- | --- | --- | 
| path | Il percorso del file binario per l'esecuzione. | Stringa | Sì | 
| arguments | Contiene un elenco di argomenti della riga di comando da utilizzare durante l'esecuzione del file binario. | Elenco di stringhe | No | 

**Esempio di input: installare.NET**

```
  - name: "InstallDotnet"
    action: ExecuteBinary
    inputs:
      path: C:\PathTo\dotnet_installer.exe
      arguments:
        - /qb
        - /norestart
```


**Output**  

| Campo | Description | Tipo | 
| --- | --- | --- | 
| stdout | Output standard dell'esecuzione del comando. | stringa | 

**Esempio di output**

```
{
	"stdout": "success"
}
```

### ExecuteDocument (Linux, Windows, macOS)
<a name="action-modules-executedocument"></a>

Il modulo di **ExecuteDocument**azione aggiunge il supporto per i documenti di componenti annidati, eseguendo più documenti componenti da un unico documento. AWSTOE convalida il documento passato nel parametro di input in fase di esecuzione.

**Restrizioni**
+ Questo modulo di azione viene eseguito una sola volta, senza che siano consentiti nuovi tentativi e senza alcuna opzione per impostare limiti di timeout. **ExecuteDocument**imposta i seguenti valori predefiniti e restituisce un errore se si tenta di modificarli.
  + `timeoutSeconds`: -1
  + `maxAttempts`: 1
**Nota**  
È possibile lasciare vuoti questi valori e AWSTOE utilizzare i valori predefiniti.
+ L'annidamento dei documenti è consentito, fino a tre livelli di profondità, ma non di più. Tre livelli di nidificazione si traducono in quattro livelli di documento, poiché il livello superiore non è nidificato. In questo scenario, il documento di livello più basso non deve richiamare nessun altro documento.
+ L'esecuzione ciclica dei documenti dei componenti non è consentita. Qualsiasi documento che richiama se stesso al di fuori di un costrutto a ciclo continuo o che richiama un altro documento più in alto nella catena di esecuzione corrente avvia un ciclo che può generare un ciclo infinito. Quando AWSTOE rileva un'esecuzione ciclica, interrompe l'esecuzione e registra l'errore.

![\[Restrizioni a livello di nidificazione per il modulo di azione ExecuteDocument .\]](http://docs.aws.amazon.com/it_it/imagebuilder/latest/userguide/images/toe-component-document-nesting.png)


Se un documento componente tenta di eseguirsi da solo o di eseguire uno dei documenti componenti che si trovano più in alto nella catena di esecuzione corrente, l'esecuzione fallisce.

**Input**


| Nome chiave | Description | Tipo | Richiesto | 
| --- | --- | --- | --- | 
| document |  Percorso del documento componente. Le opzioni valide includono: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/imagebuilder/latest/userguide/toe-action-modules.html)  | Stringa | Sì | 
| document-s3-bucket-owner |  L'ID dell'account del proprietario del bucket S3 per il bucket S3 in cui sono archiviati i documenti dei componenti. *(Consigliato se utilizzi S3 URIs nel documento del componente.)*  | Stringa | No | 
| phases |  Fasi da eseguire nel documento del componente, espresse come elenco separato da virgole. Se non viene specificata alcuna fase, vengono eseguite tutte le fasi.  | Stringa | No | 
| parameters |  Parametri di input che vengono passati al documento del componente in fase di esecuzione come coppie chiave-valore.  | Elenco delle mappe dei parametri | No | 

**Inserimento della mappa dei parametri**


| Nome chiave | Description | Tipo | Richiesto | 
| --- | --- | --- | --- | 
| name |  Il nome del parametro di input da passare al documento del componente che il modulo di **ExecuteDocument**azione è in esecuzione.  | Stringa | Sì | 
| value |  Il valore del parametro di input.  | Stringa | Sì | 

**Esempi di input**  
Gli esempi seguenti mostrano le variazioni degli input per il documento del componente, a seconda del percorso di installazione.

**Esempio di input: percorso del documento locale**

```
# main.yaml
schemaVersion: 1.0

phases:
  - name: build
    steps:
      - name: ExecuteNestedDocument
        action: ExecuteDocument
        inputs:
          document: Sample-1.yaml
          phases: build
          parameters:
            - name: parameter-1
              value: value-1
            - name: parameter-2
              value: value-2
```

**Esempio di input: URI S3 come percorso del documento**

```
# main.yaml
schemaVersion: 1.0

phases:
  - name: build
    steps:
      - name: ExecuteNestedDocument
        action: ExecuteDocument
        inputs:
          document: s3://my-bucket/Sample-1.yaml
          document-s3-bucket-owner: 123456789012
          phases: build,validate
          parameters:
            - name: parameter-1
              value: value-1
            - name: parameter-2
              value: value-2
```

**Esempio di input: ARN del componente EC2 Image Builder come percorso del documento**

```
# main.yaml
schemaVersion: 1.0

phases:
  - name: build
    steps:
      - name: ExecuteNestedDocument
        action: ExecuteDocument
        inputs:
          document: arn:aws:imagebuilder:us-west-2:aws:component/Sample-Test/1.0.0
          phases: test
          parameters:
            - name: parameter-1
              value: value-1
            - name: parameter-2
              value: value-2
```

**Utilizzo di un ForEach ciclo per eseguire documenti**

```
# main.yaml
schemaVersion: 1.0

phases:
  - name: build
    steps:
      - name: ExecuteNestedDocument
        action: ExecuteDocument
        loop:
          name: 'myForEachLoop'
          forEach:
            - Sample-1.yaml
            - Sample-2.yaml
        inputs:
          document: "{{myForEachLoop.value}}"
          phases: test
          parameters:
            - name: parameter-1
              value: value-1
            - name: parameter-2
              value: value-2
```

**Utilizzo di un ciclo For per eseguire documenti**

```
# main.yaml
schemaVersion: 1.0

phases:
  - name: build
    steps:
      - name: ExecuteNestedDocument
        action: ExecuteDocument
        loop:
          name: 'myForLoop'
          for:
            start: 1
            end: 2
            updateBy: 1
        inputs:
          document: "Sample-{{myForLoop.value}}.yaml"
          phases: test
          parameters:
            - name: parameter-1
              value: value-1
            - name: parameter-2
              value: value-2
```

**Output**  
AWSTOE crea un file di output chiamato `detailedoutput.json` ogni volta che viene eseguito. Il file contiene dettagli su ogni fase e passaggio di ogni documento componente che viene richiamato durante l'esecuzione. Per il modulo **ExecuteDocument**d'azione, è possibile trovare un breve riepilogo del runtime nel `outputs` campo e dettagli sulle fasi, i passaggi e i documenti in cui viene eseguito. `detailedOutput`

```
{
	\"executedStepCount\":1,\"executionId\":\"97054e22-06cc-11ec-9b14-acde48001122\",\"failedStepCount\":0,\"failureMessage\":\"\",\"ignoredFailedStepCount\":0,\"logUrl\":\"\",\"status\":\"success\"
}",
```

L'oggetto di riepilogo dell'output di ogni documento componente contiene i seguenti dettagli, come illustrato di seguito, con valori di esempio:
+ executedStepCount«:1
+ «ID esecuzione» :"12345a67-89bc-01de-2f34-abcd56789012"
+ failedStepCount««:0
+ «FailureMessage»: "»
+ «Conteggio»: 0 ignoredFailedStep
+ «logUrl»: "»
+ «status»: «successo»

**Esempio di output**  
L'esempio seguente mostra l'output del modulo di **ExecuteDocument**azione quando si verifica un'esecuzione annidata. In questo esempio, il documento `main.yaml` componente esegue correttamente il documento del `Sample-1.yaml` componente.

```
{
    "executionId": "12345a67-89bc-01de-2f34-abcd56789012",
    "status": "success",
    "startTime": "2021-08-26T17:20:31-07:00",
    "endTime": "2021-08-26T17:20:31-07:00",
    "failureMessage": "",
    "documents": [
        {
            "name": "",
            "filePath": "main.yaml",
            "status": "success",
            "description": "",
            "startTime": "2021-08-26T17:20:31-07:00",
            "endTime": "2021-08-26T17:20:31-07:00",
            "failureMessage": "",
            "phases": [
                {
                    "name": "build",
                    "status": "success",
                    "startTime": "2021-08-26T17:20:31-07:00",
                    "endTime": "2021-08-26T17:20:31-07:00",
                    "failureMessage": "",
                    "steps": [
                        {
                            "name": "ExecuteNestedDocument",
                            "status": "success",
                            "failureMessage": "",
                            "timeoutSeconds": -1,
                            "onFailure": "Abort",
                            "maxAttempts": 1,
                            "action": "ExecuteDocument",
                            "startTime": "2021-08-26T17:20:31-07:00",
                            "endTime": "2021-08-26T17:20:31-07:00",
                            "inputs": "[{\"document\":\"Sample-1.yaml\",\"document-s3-bucket-owner\":\"\",\"phases\":\"\",\"parameters\":null}]",
                            "outputs": "[{\"executedStepCount\":1,\"executionId\":\"98765f43-21ed-09cb-8a76-fedc54321098\",\"failedStepCount\":0,\"failureMessage\":\"\",\"ignoredFailedStepCount\":0,\"logUrl\":\"\",\"status\":\"success\"}]",
                            "loop": null,
                            "detailedOutput": [
                                {
                                    "executionId": "98765f43-21ed-09cb-8a76-fedc54321098",
                                    "status": "success",
                                    "startTime": "2021-08-26T17:20:31-07:00",
                                    "endTime": "2021-08-26T17:20:31-07:00",
                                    "failureMessage": "",
                                    "documents": [
                                        {
                                            "name": "",
                                            "filePath": "Sample-1.yaml",
                                            "status": "success",
                                            "description": "",
                                            "startTime": "2021-08-26T17:20:31-07:00",
                                            "endTime": "2021-08-26T17:20:31-07:00",
                                            "failureMessage": "",
                                            "phases": [
                                                {
                                                    "name": "build",
                                                    "status": "success",
                                                    "startTime": "2021-08-26T17:20:31-07:00",
                                                    "endTime": "2021-08-26T17:20:31-07:00",
                                                    "failureMessage": "",
                                                    "steps": [
                                                        {
                                                            "name": "ExecuteBashStep",
                                                            "status": "success",
                                                            "failureMessage": "",
                                                            "timeoutSeconds": 7200,
                                                            "onFailure": "Abort",
                                                            "maxAttempts": 1,
                                                            "action": "ExecuteBash",
                                                            "startTime": "2021-08-26T17:20:31-07:00",
                                                            "endTime": "2021-08-26T17:20:31-07:00",
                                                            "inputs": "[{\"commands\":[\"echo \\\"Hello World!\\\"\"]}]",
                                                            "outputs": "[{\"stdout\":\"Hello World!\"}]",
                                                            "loop": null,
                                                            "detailedOutput": null
                                                        }]
                                                }]
                                        }]
                                }]
                        }]
                
                }]
        }]
}
```

### ExecutePowerShell (Windows)
<a name="action-modules-executepowershell"></a>

Il modulo di **ExecutePowerShell**azione consente di eseguire PowerShell script con codice/comandi di shell in linea. Questo modulo supporta la piattaforma Windows e Windows. PowerShell

Tutto ciò che è commands/instructions specificato nel blocco dei comandi viene convertito in un file di script (ad esempio`input.ps1`) ed eseguito utilizzando WindowsPowerShell. Il risultato dell'esecuzione del file shell è il codice di uscita.

Il **ExecutePowerShell**modulo gestisce i riavvii del sistema se il comando shell esce con un codice di uscita di. `3010` Una volta avviata, l'applicazione esegue una delle seguenti azioni: 
+ Fornisce il codice di uscita al chiamante se eseguito dall'agente Systems Manager. Systems Manager Agent gestisce il riavvio del sistema ed esegue lo stesso passaggio che ha avviato il riavvio, come descritto in [Riavvio di un'istanza gestita dagli script](https://docs.aws.amazon.com/systems-manager/latest/userguide/send-commands-reboot.html).
+ Salva la versione corrente`executionstate`, configura un trigger di riavvio per rieseguire l'applicazione e riavvia il sistema.

Dopo il riavvio del sistema, l'applicazione esegue lo stesso passaggio che ha avviato il riavvio. Se è necessaria questa funzionalità, è necessario scrivere script idempotenti in grado di gestire più invocazioni dello stesso comando di shell.


**Input**  

| Nome chiave | Description | Tipo | Richiesto | 
| --- | --- | --- | --- | 
| commands | Contiene un elenco di istruzioni o comandi da eseguire secondo la sintassi. PowerShell È consentito il formato YAML multilinea. | Elenco di stringhe | Sì. È necessario specificare `commands` o `file` non entrambi.  | 
| file | Contiene il percorso di un file di PowerShell script. PowerShell verrà eseguito su questo file utilizzando l'argomento della riga di -file comando. Il percorso deve puntare a un .ps1 file. | Stringa | Sì. È necessario specificare `commands` o `file` non entrambi.  | 

**Esempio di input: prima e dopo il riavvio**

```
name: ExitCode3010Example
description: This shows how the exit code can be used to restart a system with ExecutePowerShell
schemaVersion: 1.0
phases:
  - name: build
    steps:
      - name: RestartTrigger
        action: ExecutePowerShell
        inputs:
          commands:
            - |
              $rebootIndicator = Join-Path -Path $env:SystemDrive -ChildPath 'reboot-indicator'
              if (Test-Path -Path $rebootIndicator) {
                Write-Host 'The reboot file exists. Deleting it and exiting with success.'
                Remove-Item -Path $rebootIndicator -Force | Out-Null
                [System.Environment]::Exit(0)
              }
              Write-Host 'The reboot file does not exist. Creating it and triggering a restart.'
              New-Item -Path $rebootIndicator -ItemType File | Out-Null
              [System.Environment]::Exit(3010)
```


**Output**  

| Campo | Description | Tipo | 
| --- | --- | --- | 
| stdout | Output standard dell'esecuzione del comando. | stringa | 

Se esegui un riavvio e restituisci il codice di uscita `3010` come parte del modulo di azione, la compilazione riprenderà dalla stessa fase del modulo di azione che ha avviato il riavvio. Se esegui un riavvio senza il codice di uscita, il processo di compilazione potrebbe non riuscire.

**Esempio di output: prima del riavvio (prima lettura del documento)**

```
{
	“stdout”: “The reboot file does not exist. Creating it and triggering a restart."
}
```

**Esempio di output: dopo il riavvio, (seconda volta nel documento)**

```
{
	“stdout”: “The reboot file exists. Deleting it and exiting with success."
}
```

## Moduli per il download e il caricamento dei file
<a name="action-modules-download-upload"></a>

La sezione seguente contiene dettagli sui moduli di azione che caricano o scaricano file.

**Topics**
+ [Scarica S3 (Linux, Windows, macOS)](#action-modules-s3download)
+ [Caricamento S3 (Linux, Windows, macOS)](#action-modules-s3upload)
+ [WebDownload (Linux, Windows, macOS)](#action-modules-webdownload)

### Scarica S3 (Linux, Windows, macOS)
<a name="action-modules-s3download"></a>

Con il modulo di `S3Download` azione, puoi scaricare un oggetto Amazon S3, o un set di oggetti, in un file o una cartella locale che specifichi con il `destination` percorso. Se esiste già un file nella posizione specificata e il `overwrite` flag è impostato su true, `S3Download` sovrascrive il file.

La tua `source` posizione può puntare a un oggetto specifico in Amazon S3 oppure puoi utilizzare un prefisso chiave con un asterisco wildcard `*` () per scaricare un set di oggetti che corrispondono al percorso del prefisso chiave. Quando specificate un prefisso chiave nella vostra `source` posizione, il modulo di `S3Download` azione scarica tutto ciò che corrisponde al prefisso (file e cartelle inclusi). Assicurati che il prefisso della chiave termini con una barra, seguita da un asterisco (`/*`), in modo da scaricare tutto ciò che corrisponde al prefisso. Ad esempio: `s3://my-bucket/my-folder/*`.

Se l'`S3Download`azione per uno specifico key prefix fallisce durante un download, il contenuto della cartella non viene ripristinato allo stato precedente all'errore. La cartella di destinazione rimane com'era al momento dell'errore.

**Casi di utilizzo supportati**  
Il modulo di `S3Download` azione supporta i seguenti casi d'uso:
+ L'oggetto Amazon S3 viene scaricato in una cartella locale, come specificato nel percorso di download.
+ Gli oggetti Amazon S3 (con un prefisso chiave nel percorso del file Amazon S3) vengono scaricati nella cartella locale specificata, che copia in modo ricorsivo tutti gli oggetti Amazon S3 che corrispondono al prefisso della chiave nella cartella locale.

**Requisiti IAM**  
Il ruolo IAM associato al profilo dell'istanza deve disporre delle autorizzazioni per eseguire il modulo di `S3Download` azione. Le seguenti politiche IAM devono essere associate al ruolo IAM associato al profilo dell'istanza:
+ **File singolo**: `s3:GetObject` contro bucket/object (ad esempio,`arn:aws:s3:::BucketName/*`).
+ **File multipli**: `s3:ListBucket` contro bucket/object (ad esempio,`arn:aws:s3:::BucketName`) e `s3:GetObject` contro bucket/object (ad esempio,`arn:aws:s3:::BucketName/*`).


**Input**  

|  Chiave  |  Description  |  Tipo  |  Obbligatorio  |  Predefinita  | 
| --- | --- | --- | --- | --- | 
|  `source`  |  Il bucket Amazon S3 che è la fonte per il download. Potete specificare un percorso per un oggetto specifico o utilizzare un prefisso chiave che termina con una barra, seguita da un asterisco wildcard (`/*`), per scaricare un set di oggetti che corrispondono al prefisso della chiave.  |  Stringa  |  Sì  |  N/D  | 
|  `destination`  |  Il percorso locale in cui vengono scaricati gli oggetti Amazon S3. Per scaricare un singolo file, devi specificare il nome del file come parte del percorso. Ad esempio, `/myfolder/package.zip`.  |  Stringa  |  Sì  |  N/D  | 
|  `expectedBucketOwner`  |  ID dell'account proprietario previsto del bucket fornito nel `source` percorso. Ti consigliamo di verificare la proprietà del bucket Amazon S3 specificato nel codice sorgente.  |  Stringa  |  No  |  N/D  | 
|  `overwrite`  |  Se impostato su true, se un file con lo stesso nome esiste già nella cartella di destinazione per il percorso locale specificato, il file scaricato sovrascrive il file locale. Se impostato su false, il file esistente nel sistema locale è protetto dalla sovrascrittura e il modulo di azione ha esito negativo e restituisce un errore di download. Ad esempio, `Error: S3Download: File already exists and "overwrite" property for "destination" file is set to false. Cannot download.`  |  Boolean  |  No  |  true  | 

**Nota**  
Per gli esempi seguenti, il percorso della cartella Windows può essere sostituito con un percorso Linux. Ad esempio, `C:\myfolder\package.zip` può essere sostituito con`/myfolder/package.zip`.

**Esempio di input: copia un oggetto Amazon S3 in un file locale**  
L'esempio seguente mostra come copiare un oggetto Amazon S3 in un file locale.

```
  - name: DownloadMyFile
    action: S3Download
    inputs:
      - source: s3://amzn-s3-demo-source-bucket/path/to/package.zip
        destination: C:\myfolder\package.zip
        expectedBucketOwner: 123456789022
        overwrite: false
      - source: s3://amzn-s3-demo-source-bucket/path/to/package.zip
        destination: C:\myfolder\package.zip
        expectedBucketOwner: 123456789022
        overwrite: true
      - source: s3://amzn-s3-demo-source-bucket/path/to/package.zip
        destination: C:\myfolder\package.zip
        expectedBucketOwner: 123456789022
```

**Esempio di input: copia tutti gli oggetti Amazon S3 in un bucket Amazon S3 con prefisso chiave in una cartella locale**  
L'esempio seguente mostra come copiare tutti gli oggetti Amazon S3 in un bucket Amazon S3 con il prefisso chiave in una cartella locale. Amazon S3 non ha il concetto di cartella, pertanto tutti gli oggetti che corrispondono al prefisso del key vengono copiati. Il numero massimo di oggetti che possono essere scaricati è 1000.

```
  - name: MyS3DownloadKeyprefix
    action: S3Download
    maxAttempts: 3
    inputs:
      - source: s3://amzn-s3-demo-source-bucket/path/to/*
        destination: C:\myfolder\
        expectedBucketOwner: 123456789022
        overwrite: false
      - source: s3://amzn-s3-demo-source-bucket/path/to/*
        destination: C:\myfolder\
        expectedBucketOwner: 123456789022
        overwrite: true
      - source: s3://amzn-s3-demo-source-bucket/path/to/*
        destination: C:\myfolder\
        expectedBucketOwner: 123456789022
```

**Output**  
Nessuna.

### Caricamento S3 (Linux, Windows, macOS)
<a name="action-modules-s3upload"></a>

Con il modulo di azione **S3Upload**, puoi caricare un file da un file o una cartella di origine in una posizione Amazon S3. Puoi utilizzare un carattere jolly (`*`) nel percorso specificato per la posizione di origine per caricare tutti i file il cui percorso corrisponde al modello dei caratteri jolly.

Se l'azione **ricorsiva S3Upload** fallisce, tutti i file che sono già stati caricati rimarranno nel bucket Amazon S3 di destinazione.

**Casi di utilizzo supportati**
+ File locale su oggetto Amazon S3.
+ File locali nella cartella (con wildcard) nel prefisso chiave di Amazon S3.
+ Copia la cartella locale (deve essere `recurse` impostata su`true`) nel prefisso chiave di Amazon S3.

**Requisiti IAM**  
Il ruolo IAM associato al profilo dell'istanza deve disporre delle autorizzazioni per eseguire il modulo di `S3Upload` azione. La seguente policy IAM deve essere associata al ruolo IAM associato al profilo dell'istanza. La policy deve concedere `s3:PutObject` le autorizzazioni al bucket Amazon S3 di destinazione. Ad esempio, `arn:aws:s3:::BucketName/*`.


**Input**  

|  Chiave  |  Description  |  Tipo  |  Obbligatorio  |  Predefinita  | 
| --- | --- | --- | --- | --- | 
|  `source`  |  Il percorso locale da cui proviene l'origine. files/folders `source`Supporta un asterisco wildcard ()`*`.  |  Stringa  |  Sì  |  N/D  | 
|  `destination`  |  Il percorso del bucket Amazon S3 di destinazione in cui vengono caricati i file/le cartelle di origine.  |  Stringa  |  Sì  |  N/D  | 
|  `recurse`  |  **Se impostato su, esegue S3Upload in modo `true` ricorsivo.**  |  Stringa  |  No  |  `false`  | 
|  `expectedBucketOwner`  |  L'ID dell'account proprietario previsto per il bucket Amazon S3 specificato nel percorso di destinazione. Ti consigliamo di verificare la proprietà del bucket Amazon S3 specificato nella destinazione.  |  Stringa  |  No  |  N/D  | 

**Esempio di input: copia un file locale su un oggetto Amazon S3**  
L'esempio seguente mostra come copiare un file locale su un oggetto Amazon S3.

```
  - name: MyS3UploadFile
    action: S3Upload
    onFailure: Abort
    maxAttempts: 3
    inputs:
      - source: C:\myfolder\package.zip
        destination: s3://amzn-s3-demo-destination-bucket/path/to/package.zip
        expectedBucketOwner: 123456789022
```

**Esempio di input: copia tutti i file in una cartella locale in un bucket Amazon S3 con prefisso chiave**  
L'esempio seguente mostra come copiare tutti i file nella cartella locale in un bucket Amazon S3 con key prefix. Questo esempio non copia le sottocartelle o il loro contenuto perché non `recurse` è specificato e l'impostazione predefinita è. `false`

```
  - name: MyS3UploadMultipleFiles
    action: S3Upload
    onFailure: Abort
    maxAttempts: 3
    inputs:
      - source: C:\myfolder\*
        destination: s3://amzn-s3-demo-destination-bucket/path/to/
        expectedBucketOwner: 123456789022
```

**Esempio di input: copia ricorsivamente tutti i file e le cartelle da una cartella locale a un bucket Amazon S3**  
L'esempio seguente mostra come copiare tutti i file e le cartelle in modo ricorsivo da una cartella locale a un bucket Amazon S3 con prefisso chiave.

```
  - name: MyS3UploadFolder
    action: S3Upload
    onFailure: Abort
    maxAttempts: 3
    inputs:
      - source: C:\myfolder\*
        destination: s3://amzn-s3-demo-destination-bucket/path/to/
        recurse: true
        expectedBucketOwner: 123456789022
```

**Output**  
Nessuna.

### WebDownload (Linux, Windows, macOS)
<a name="action-modules-webdownload"></a>

Il modulo di **WebDownload**azione consente di scaricare file e risorse da una postazione remota tramite il HTTP/HTTPS protocollo (*si consiglia HTTPS*). Non ci sono limiti al numero o alla dimensione dei download. Questo modulo gestisce la logica dei tentativi e del backoff esponenziale. 

A ogni operazione di download vengono assegnati un massimo di 5 tentativi di successo in base agli input dell'utente. Questi tentativi sono diversi da quelli specificati nel `maxAttempts` campo del documento`steps`, che sono correlati agli errori del modulo di azione.

Questo modulo di azione gestisce implicitamente i reindirizzamenti. Tutti i codici di stato HTTP, ad eccezione di`200`, generano un errore.


**Input**  

| Nome chiave | Description | Tipo | Obbligatorio | Predefinita | 
| --- | --- | --- | --- | --- | 
| source | L' HTTP/HTTPS URL valido (si consiglia HTTPS), che segue lo standard RFC 3986. Le espressioni concatenate sono consentite. | Stringa |  Sì  | N/D | 
| destination | Un percorso di file o cartella assoluto o relativo nel sistema locale. I percorsi delle cartelle devono terminare con/. Se non terminano con/, verranno trattati come percorsi di file. Il modulo crea qualsiasi file o cartella necessario per il corretto download. Le espressioni concatenate sono consentite. | Stringa | Sì | N/D | 
| overwrite | Se abilitata, sovrascrive qualsiasi file esistente sul sistema locale con il file o la risorsa scaricati. Se non è abilitata, i file esistenti sul sistema locale non vengono sovrascritti e il modulo di azione si interrompe e restituisce un errore. Quando la sovrascrittura è abilitata e vengono specificati il checksum e l'algoritmo, il modulo di azione scarica il file solo se il checksum e l'hash dei file preesistenti non corrispondono.  | Boolean | No | true | 
| checksum | Quando si specifica il checksum, questo viene confrontato con l'hash del file scaricato generato con l'algoritmo fornito. Affinché la verifica dei file sia abilitata, è necessario fornire sia il checksum che l'algoritmo. Le espressioni concatenate sono consentite.  | Stringa | No | N/D | 
| algorithm | L'algoritmo utilizzato per calcolare il checksum. Le opzioni sonoMD5, SHA1 SHA256, e SHA512. Per abilitare la verifica dei file, è necessario fornire sia il checksum che l'algoritmo. Le espressioni concatenate sono consentite.  | Stringa | No | N/D | 
| ignoreCertificateErrors | La convalida del certificato SSL viene ignorata se abilitata. | Boolean | No | false | 


**Output**  

| Nome chiave | Description | Tipo | 
| --- | --- | --- | 
| destination | Stringa di nuova riga delimitata da caratteri che specifica il percorso di destinazione in cui sono archiviati i file o le risorse scaricati. | Stringa | 

**Esempio di input: scarica il file remoto nella destinazione locale**

```
  - name: DownloadRemoteFile
    action: WebDownload
    maxAttempts: 3
    inputs:
      - source: https://testdomain/path/to/java14.zip
        destination: C:\testfolder\package.zip
```

**Output:**

```
{
	"destination": "C:\\testfolder\\package.zip"
}
```

**Esempio di input: scaricare più di un file remoto su più di una destinazione locale**

```
  - name: DownloadRemoteFiles
    action: WebDownload
    maxAttempts: 3
    inputs:
      - source: https://testdomain/path/to/java14.zip
        destination: /tmp/java14_renamed.zip
      - source: https://testdomain/path/to/java14.zip
        destination: /tmp/create_new_folder_and_add_java14_as_zip/
```

**Output:**

```
{
	"destination": "/tmp/create_new_folder/java14_renamed.zip\n/tmp/create_new_folder_and_add_java14_as_zip/java14.zip"
}
```

**Esempio di input: scarica un file remoto senza sovrascrivere la destinazione locale e scarica un altro file remoto con la verifica del file**

```
  - name: DownloadRemoteMultipleProperties
    action: WebDownload
    maxAttempts: 3
    inputs:
      - source: https://testdomain/path/to/java14.zip
        destination: C:\create_new_folder\java14_renamed.zip
        overwrite: false
      - source: https://testdomain/path/to/java14.zip
        destination: C:\create_new_folder_and_add_java14_as_zip\
        checksum: ac68bbf921d953d1cfab916cb6120864
        algorithm: MD5
        overwrite: true
```

**Output:**

```
{
	"destination": "C:\\create_new_folder\\java14_renamed.zip\nC:\\create_new_folder_and_add_java14_as_zip\\java14.zip"
}
```

**Esempio di input: scarica il file remoto e ignora la convalida della certificazione SSL**

```
  - name: DownloadRemoteIgnoreValidation
    action: WebDownload
    maxAttempts: 3
    inputs:
      - source: https://www.bad-ssl.com/resource
        destination: /tmp/downloads/
        ignoreCertificateErrors: true
```

**Output:**

```
{
	"destination": "/tmp/downloads/resource"
}
```

## Moduli operativi del file system
<a name="action-modules-file-system-operations"></a>

La sezione seguente contiene dettagli sui moduli di azione che eseguono operazioni sul file system.

**Topics**
+ [AppendFile (Linux, Windows, macOS)](#action-modules-appendfile)
+ [CopyFile (Linux, Windows, macOS)](#action-modules-copyfile)
+ [CopyFolder (Linux, Windows, macOS)](#action-modules-copyfolder)
+ [CreateFile (Linux, Windows, macOS)](#action-modules-createfile)
+ [CreateFolder (Linux, Windows, macOS)](#action-modules-createfolder)
+ [CreateSymlink (Linux, Windows, macOS)](#action-modules-createsymlink)
+ [DeleteFile (Linux, Windows, macOS)](#action-modules-deletefile)
+ [DeleteFolder (Linux, Windows, macOS)](#action-modules-deletefolder)
+ [ListFiles (Linux, Windows, macOS)](#action-modules-listfiles)
+ [MoveFile (Linux, Windows, macOS)](#action-modules-movefile)
+ [MoveFolder (Linux, Windows, macOS)](#action-modules-movefolder)
+ [ReadFile (Linux, Windows, macOS)](#action-modules-readfile)
+ [SetFileEncoding (Linux, Windows, macOS)](#action-modules-setfileencoding)
+ [SetFileOwner (Linux, Windows, macOS)](#action-modules-setfileowner)
+ [SetFolderOwner (Linux, Windows, macOS)](#action-modules-setfolderowner)
+ [SetFilePermissions (Linux, Windows, macOS)](#action-modules-setfilepermissions)
+ [SetFolderPermissions (Linux, Windows, macOS)](#action-modules-setfolderpermissions)

### AppendFile (Linux, Windows, macOS)
<a name="action-modules-appendfile"></a>

Il modulo di **AppendFile**azione aggiunge il contenuto specificato al contenuto preesistente di un file.

Se il valore di codifica del file è diverso dal valore di codifica predefinito (`utf-8`), è possibile specificare il valore di codifica del file utilizzando l'opzione. `encoding` Per impostazione predefinita, `utf-16` si presume che utilizzino la `utf-32` codifica little-endian. 

Il modulo di azione restituisce un errore quando si verifica quanto segue:
+ Il file specificato non esiste in fase di esecuzione.
+ Non disponi delle autorizzazioni di scrittura per modificare il contenuto del file.
+ Il modulo rileva un errore durante l'operazione sul file.


**Input**  

| Nome chiave | Description | Tipo | Richiesto | Valore predefinito | Valori accettabili | Supportato su tutte le piattaforme | 
| --- | --- | --- | --- | --- | --- | --- | 
| path | Il percorso del file. | Stringa | Sì | N/D | N/D | Sì | 
| content | Il contenuto da aggiungere al file. | Stringa | No | Stringa vuota | N/D | Sì | 
| encoding | Lo standard di codifica. | Stringa | No | utf8 | utf8,utf-8,utf16,utf-16,utf16-LE, utf-16-LE utf16-BEutf-16-BE,utf32,utf-32,utf32-LE, utf-32-LEutf32-BE, e utf-32-BE. Il valore dell'opzione di codifica non fa distinzione tra maiuscole e minuscole. | Sì | 

**Esempio di input: aggiungi file senza codifica (Linux)**

```
  - name: AppendingFileWithOutEncodingLinux
    action: AppendFile
    inputs:
      - path: ./Sample.txt
        content: "The string to be appended to the file"
```

**Esempio di input: aggiungi file senza codifica (Windows)**

```
  - name: AppendingFileWithOutEncodingWindows
    action: AppendFile
    inputs:
      - path: C:\MyFolder\MyFile.txt
        content: "The string to be appended to the file"
```

**Esempio di input: aggiungi file con codifica (Linux)**

```
  - name: AppendingFileWithEncodingLinux
    action: AppendFile
    inputs:
      - path: /FolderName/SampleFile.txt
        content: "The string to be appended to the file"
        encoding: UTF-32
```

**Esempio di input: aggiungi file con codifica (Windows)**

```
  - name: AppendingFileWithEncodingWindows
    action: AppendFile
    inputs:
      - path: C:\MyFolderName\SampleFile.txt
        content: "The string to be appended to the file"
        encoding: UTF-32
```

**Esempio di input: aggiungi un file con una stringa vuota (Linux)**

```
  - name: AppendingEmptyStringLinux
    action: AppendFile
    inputs:
      - path: /FolderName/SampleFile.txt
```

**Esempio di input: aggiungi un file con una stringa vuota (Windows)**

```
  - name: AppendingEmptyStringWindows
    action: AppendFile
    inputs:
      - path: C:\MyFolderName\SampleFile.txt
```

**Output**  
Nessuna.

### CopyFile (Linux, Windows, macOS)
<a name="action-modules-copyfile"></a>

Il modulo di **CopyFile**azione copia i file dall'origine specificata alla destinazione specificata. Per impostazione predefinita, il modulo crea in modo ricorsivo la cartella di destinazione se non esiste in fase di esecuzione.

Se un file con il nome specificato esiste già nella cartella specificata, il modulo di azione, per impostazione predefinita, sovrascrive il file esistente. È possibile ignorare questo comportamento predefinito impostando l'opzione di sovrascrittura su. `false` Quando l'opzione di sovrascrittura è impostata su e nella posizione specificata è già presente un file con il nome specificato, il modulo di azione restituirà un errore. `false` Questa opzione funziona come il `cp` comando in Linux, che per impostazione predefinita sovrascrive.

Il nome del file sorgente può includere un wildcard ()`*`. I caratteri jolly sono accettati solo dopo l'ultimo separatore di percorso del file (`/`o). `\` Se nel nome del file di origine sono inclusi caratteri jolly, tutti i file che corrispondono ai caratteri jolly vengono copiati nella cartella di destinazione. Se desiderate spostare più di un file utilizzando un carattere jolly, l'input dell'`destination`opzione deve terminare con un separatore del percorso del file (`/`o`\`), che indica che l'input di destinazione è una cartella.

Se il nome del file di destinazione è diverso dal nome del file di origine, è possibile specificare il nome del file di destinazione utilizzando l'`destination`opzione. Se non si specifica un nome di file di destinazione, il nome del file di origine viene utilizzato per creare il file di destinazione. Qualsiasi testo che segue il separatore (`/`o`\`) dell'ultimo percorso del file viene considerato come nome del file. Se si desidera utilizzare lo stesso nome di file del file di origine, l'input dell'`destination`opzione deve terminare con un separatore di percorso del file (`/`o`\`). 

Il modulo di azione restituisce un errore quando si verifica quanto segue:
+ Non sei autorizzato a creare un file nella cartella specificata.
+ I file di origine non esistono in fase di esecuzione.
+ Esiste già una cartella con il nome di file specificato e l'`overwrite`opzione è impostata su`false`.
+ Il modulo di azione rileva un errore durante l'esecuzione dell'operazione.


**Input**  

| Nome chiave | Description | Tipo | Richiesto | Valore predefinito | Valori accettabili | Supportato su tutte le piattaforme | 
| --- | --- | --- | --- | --- | --- | --- | 
| source | Il percorso del file sorgente. | Stringa | Sì | N/D | N/D | Sì | 
| destination | Il percorso del file di destinazione. | Stringa | Sì | N/D | N/D | Sì | 
| overwrite | Se impostato su false, i file di destinazione non verranno sostituiti quando nella posizione specificata è già presente un file con il nome specificato. | Boolean | No | true | N/D | Sì | 

**Esempio di input: copia un file (Linux)**

```
  - name: CopyingAFileLinux
    action: CopyFile
    inputs:
      - source: /Sample/MyFolder/Sample.txt
        destination: /MyFolder/destinationFile.txt
```

**Esempio di input: copiare un file (Windows)**

```
  - name: CopyingAFileWindows
    action: CopyFile
    inputs:
      - source: C:\MyFolder\Sample.txt
        destination: C:\MyFolder\destinationFile.txt
```

**Esempio di input: copia un file usando il nome del file sorgente (Linux)**

```
  - name: CopyingFileWithSourceFileNameLinux
    action: CopyFile
    inputs:
      - source: /Sample/MyFolder/Sample.txt
        destination: /MyFolder/
```

**Esempio di input: copiare un file utilizzando il nome del file sorgente (Windows)**

```
  - name: CopyingFileWithSourceFileNameWindows
    action: CopyFile
    inputs:
      - source: C:\Sample\MyFolder\Sample.txt
        destination: C:\MyFolder\
```

**Esempio di input: copia un file usando il carattere jolly (Linux)**

```
  - name: CopyingFilesWithWildCardLinux
    action: CopyFile
    inputs:
      - source: /Sample/MyFolder/Sample*
        destination: /MyFolder/
```

**Esempio di input: copia un file usando il carattere jolly (Windows)**

```
  - name: CopyingFilesWithWildCardWindows
    action: CopyFile
    inputs:
      - source: C:\Sample\MyFolder\Sample*
        destination: C:\MyFolder\
```

**Esempio di input: copiare un file senza sovrascriverlo (Linux)**

```
  - name: CopyingFilesWithoutOverwriteLinux
    action: CopyFile
    inputs:
      - source: /Sample/MyFolder/Sample.txt
        destination: /MyFolder/destinationFile.txt
        overwrite: false
```

**Esempio di input: copiare un file senza sovrascriverlo (Windows)**

```
  - name: CopyingFilesWithoutOverwriteWindows
    action: CopyFile
    inputs:
      - source: C:\Sample\MyFolder\Sample.txt
        destination: C:\MyFolder\destinationFile.txt
        overwrite: false
```

**Output**  
Nessuna.

### CopyFolder (Linux, Windows, macOS)
<a name="action-modules-copyfolder"></a>

Il modulo di **CopyFolder**azione copia una cartella dall'origine specificata alla destinazione specificata. L'input per l'`source`opzione è la cartella da copiare e l'input per l'`destination`opzione è la cartella in cui viene copiato il contenuto della cartella di origine. Per impostazione predefinita, il modulo crea in modo ricorsivo la cartella di destinazione se non esiste in fase di esecuzione.

Se una cartella con il nome specificato esiste già nella cartella specificata, il modulo di azione, per impostazione predefinita, sovrascrive la cartella esistente. È possibile ignorare questo comportamento predefinito impostando l'opzione di sovrascrittura su. `false` Quando l'opzione di sovrascrittura è impostata su e nella posizione specificata è già presente una cartella con il nome specificato, il modulo di azione restituirà un errore. `false`

Il nome della cartella di origine può includere un carattere jolly ()`*`. I caratteri jolly sono accettati solo dopo l'ultimo separatore di percorso del file (`/`o). `\` Se nel nome della cartella di origine sono inclusi caratteri jolly, tutte le cartelle che corrispondono al carattere jolly vengono copiate nella cartella di destinazione. Se desiderate copiare più di una cartella utilizzando un carattere jolly, l'input dell'`destination`opzione deve terminare con un separatore del percorso del file (`/`o`\`), che indica che l'input di destinazione è una cartella.

Se il nome della cartella di destinazione è diverso dal nome della cartella di origine, è possibile specificare il nome della cartella di destinazione utilizzando l'`destination`opzione. Se non si specifica un nome per la cartella di destinazione, per creare la cartella di destinazione viene utilizzato il nome della cartella di origine. Qualsiasi testo che segue il separatore (`/`o`\`) dell'ultimo percorso del file viene considerato come nome della cartella. Se si desidera utilizzare lo stesso nome di cartella della cartella di origine, l'immissione dell'`destination`opzione deve terminare con un separatore del percorso del file (`/`o`\`). 

Il modulo di azione restituisce un errore quando si verifica quanto segue:
+ Non sei autorizzato a creare una cartella nella cartella specificata.
+ Le cartelle di origine non esistono in fase di esecuzione.
+ Esiste già una cartella con il nome specificato e l'`overwrite`opzione è impostata su`false`.
+ Il modulo di azione rileva un errore durante l'esecuzione dell'operazione.


**Input**  

| Nome chiave | Description | Tipo | Richiesto | Valore predefinito | Valori accettabili | Supportato su tutte le piattaforme | 
| --- | --- | --- | --- | --- | --- | --- | 
| source | Il percorso della cartella di origine. | Stringa | Sì | N/D | N/D | Sì | 
| destination | Il percorso della cartella di destinazione. | Stringa | Sì | N/D | N/D | Sì | 
| overwrite | Se impostato su false, le cartelle di destinazione non verranno sostituite se nella posizione specificata è già presente una cartella con il nome specificato. | Boolean | No | true | N/D | Sì | 

**Esempio di input: copia una cartella (Linux)**

```
  - name: CopyingAFolderLinux
    action: CopyFolder
    inputs:
      - source: /Sample/MyFolder/SampleFolder
        destination: /MyFolder/destinationFolder
```

**Esempio di input: copiare una cartella (Windows)**

```
  - name: CopyingAFolderWindows
    action: CopyFolder
    inputs:
      - source: C:\Sample\MyFolder\SampleFolder
        destination: C:\MyFolder\destinationFolder
```

**Esempio di input: copia una cartella usando il nome della cartella di origine (Linux)**

```
  - name: CopyingFolderSourceFolderNameLinux
    action: CopyFolder
    inputs:
      - source: /Sample/MyFolder/SourceFolder
        destination: /MyFolder/
```

**Esempio di input: copia una cartella usando il nome della cartella di origine (Windows)**

```
  - name: CopyingFolderSourceFolderNameWindows
    action: CopyFolder
    inputs:
      - source: C:\Sample\MyFolder\SampleFolder
        destination: C:\MyFolder\
```

**Esempio di input: copia una cartella usando il carattere jolly (Linux)**

```
  - name: CopyingFoldersWithWildCardLinux
    action: CopyFolder
    inputs:
      - source: /Sample/MyFolder/Sample*
        destination: /MyFolder/
```

**Esempio di input: copia una cartella usando il carattere jolly (Windows)**

```
  - name: CopyingFoldersWithWildCardWindows
    action: CopyFolder
    inputs:
      - source: C:\Sample\MyFolder\Sample*
        destination: C:\MyFolder\
```

**Esempio di input: copia una cartella senza sovrascriverla (Linux)**

```
  - name: CopyingFoldersWithoutOverwriteLinux
    action: CopyFolder
    inputs:
      - source: /Sample/MyFolder/SourceFolder
        destination: /MyFolder/destinationFolder
        overwrite: false
```

**Esempio di input: copiare una cartella senza sovrascriverla (Windows)**

```
  - name: CopyingFoldersWithoutOverwrite
    action: CopyFolder
    inputs:
      - source: C:\Sample\MyFolder\SourceFolder
        destination: C:\MyFolder\destinationFolder
        overwrite: false
```

**Output**  
Nessuna.

### CreateFile (Linux, Windows, macOS)
<a name="action-modules-createfile"></a>

Il modulo di **CreateFile**azione crea un file in una posizione specificata. Per impostazione predefinita, se necessario, il modulo crea anche in modo ricorsivo le cartelle principali.

Se il file esiste già nella cartella specificata, il modulo di azione, per impostazione predefinita, tronca o sovrascrive il file esistente. È possibile ignorare questo comportamento predefinito impostando l'opzione di sovrascrittura su. `false` Quando l'opzione di sovrascrittura è impostata su e nella posizione specificata è già presente un file con il nome specificato, il modulo di azione restituirà un errore. `false`

Se il valore di codifica del file è diverso dal valore di codifica predefinito (`utf-8`), è possibile specificare il valore di codifica del file utilizzando l'opzione. `encoding` Per impostazione predefinita, `utf-16` si presume che utilizzino la `utf-32` codifica little-endian. 

`owner`, e sono ingressi `group` opzionali. `permissions` L'input per `permissions` deve essere un valore di stringa. I file vengono creati con valori predefiniti quando non vengono forniti. Queste opzioni non sono supportate sulle piattaforme Windows. Questo modulo di azione convalida e restituisce un errore se le `permissions` opzioni `owner``group`, e vengono utilizzate sulle piattaforme Windows.

Questo modulo di azione può creare un file con autorizzazioni definite dal `umask` valore predefinito del sistema operativo. È necessario impostare il `umask` valore se si desidera sovrascrivere il valore predefinito.

Il modulo di azione restituisce un errore quando si verifica quanto segue:
+ Non sei autorizzato a creare un file o una cartella nella cartella principale specificata.
+ Il modulo di azione rileva un errore durante l'esecuzione dell'operazione.


**Input**  

| Nome chiave | Description | Tipo | Richiesto | Valore predefinito | Valori accettabili | Supportato su tutte le piattaforme | 
| --- | --- | --- | --- | --- | --- | --- | 
| path | Il percorso del file. | Stringa | Sì | N/D | N/D | Sì | 
| content | Il contenuto testuale del file. | Stringa | No | N/D | N/D | Sì | 
| encoding | Lo standard di codifica. | Stringa | No | utf8 | utf8,utf-8,utf16,utf-16,utf16-LE, utf-16-LE utf16-BEutf-16-BE,utf32,utf-32,utf32-LE, utf-32-LEutf32-BE, e utf-32-BE. Il valore dell'opzione di codifica non fa distinzione tra maiuscole e minuscole. | Sì | 
| owner | Il nome utente o l'ID. | Stringa | No | N/D | N/D | Non supportato su Windows. | 
| group | Il nome o l'ID del gruppo. | Stringa | No | L'utente corrente. | N/D | Non supportato su Windows. | 
| permissions | Le autorizzazioni relative ai file. | Stringa | No | 0666 | N/D | Non supportato su Windows. | 
| overwrite | Se il nome del file specificato esiste già, impostando questo valore per false evitare che il file venga troncato o sovrascritto per impostazione predefinita. | Boolean | No | true | N/D | Sì | 

**Esempio di input: crea un file senza sovrascrivere (Linux)**

```
  - name: CreatingFileWithoutOverwriteLinux
    action: CreateFile
    inputs:
      - path: /home/UserName/Sample.txt
        content: The text content of the sample file.
        overwrite: false
```

**Esempio di input: crea un file senza sovrascrivere (Windows)**

```
  - name: CreatingFileWithoutOverwriteWindows
    action: CreateFile
    inputs:
      - path: C:\Temp\Sample.txt
        content: The text content of the sample file.
        overwrite: false
```

**Esempio di input: creare un file con le proprietà del file**

```
  - name: CreatingFileWithFileProperties
    action: CreateFile
    inputs:
      - path: SampleFolder/Sample.txt
        content: The text content of the sample file.
        encoding: UTF-16
        owner: Ubuntu
        group: UbuntuGroup
        permissions: 0777
     - path: SampleFolder/SampleFile.txt
        permissions: 755
      - path: SampleFolder/TextFile.txt
        encoding: UTF-16
        owner: root
        group: rootUserGroup
```

**Esempio di input: creare un file senza proprietà del file**

```
  - name: CreatingFileWithoutFileProperties
    action: CreateFile
    inputs:
      - path: ./Sample.txt
      - path: Sample1.txt
```

**Esempio di input: crea un file vuoto per saltare una sezione dello script di pulizia di Linux**

```
  - name: CreateSkipCleanupfile
    action: CreateFile
    inputs:
      - path: <skip section file name>
```

Per ulteriori informazioni, consulta [Sostituisci lo script di pulizia di Linux](security-best-practices.md#override-linux-cleanup-script)

**Output**  
Nessuna.

### CreateFolder (Linux, Windows, macOS)
<a name="action-modules-createfolder"></a>

Il modulo di **CreateFolder**azione crea una cartella in una posizione specificata. Per impostazione predefinita, se necessario, il modulo crea anche in modo ricorsivo le cartelle principali.

Se la cartella esiste già nella cartella specificata, il modulo di azione, per impostazione predefinita, tronca o sovrascrive la cartella esistente. È possibile ignorare questo comportamento predefinito impostando l'opzione di sovrascrittura su. `false` Quando l'opzione di sovrascrittura è impostata su e nella posizione specificata è già presente una cartella con il nome specificato, il modulo di azione restituirà un errore. `false`

`owner``group`, e `permissions` sono input opzionali. L'input per `permissions` deve essere un valore di stringa. Queste opzioni non sono supportate sulle piattaforme Windows. Questo modulo di azione convalida e restituisce un errore se le `permissions` opzioni `owner``group`, e vengono utilizzate sulle piattaforme Windows.

Questo modulo di azione può creare una cartella con autorizzazioni definite dal `umask` valore predefinito del sistema operativo. È necessario impostare il `umask` valore se si desidera sovrascrivere il valore predefinito.

Il modulo di azione restituisce un errore quando si verifica quanto segue:
+ Non sei autorizzato a creare una cartella nella posizione specificata.
+ Il modulo di azione rileva un errore durante l'esecuzione dell'operazione.


**Input**  

| Nome chiave | Description | Tipo | Richiesto | Valore predefinito | Valori accettabili | Supportato su tutte le piattaforme | 
| --- | --- | --- | --- | --- | --- | --- | 
| path | Il percorso della cartella. | Stringa | Sì | N/D | N/D | Sì | 
| owner | Il nome utente o l'ID. | Stringa | No | L'utente corrente. | N/D | Non supportato su Windows. | 
| group | Il nome o l'ID del gruppo. | Stringa | No | Il gruppo dell'utente corrente. | N/D | Non supportato su Windows. | 
| permissions | Le autorizzazioni della cartella. | Stringa | No | 0777 | N/D | Non supportato su Windows. | 
| overwrite | Se il nome del file specificato esiste già, impostando questo valore per false evitare che il file venga troncato o sovrascritto per impostazione predefinita. | Boolean | No | true | N/D | Sì | 

**Esempio di input: creare una cartella (Linux)**

```
  - name: CreatingFolderLinux
    action: CreateFolder
    inputs:
      - path: /Sample/MyFolder/
```

**Esempio di input: creare una cartella (Windows)**

```
  - name: CreatingFolderWindows
    action: CreateFolder
    inputs:
      - path: C:\MyFolder
```

**Esempio di input: creare una cartella specificando le proprietà della cartella**

```
  - name: CreatingFolderWithFolderProperties
    action: CreateFolder
    inputs:
      - path: /Sample/MyFolder/Sample/
        owner: SampleOwnerName
        group: SampleGroupName
        permissions: 0777
      - path: /Sample/MyFolder/SampleFoler/
        permissions: 777
```

**Esempio di input: crea una cartella che sovrascriva la cartella esistente, se presente.**

```
  - name: CreatingFolderWithOverwrite
    action: CreateFolder
    inputs:
      - path: /Sample/MyFolder/Sample/
        overwrite: true
```

**Output**  
Nessuna.

### CreateSymlink (Linux, Windows, macOS)
<a name="action-modules-createsymlink"></a>

Il modulo di **CreateSymlink**azione crea collegamenti simbolici o file che contengono un riferimento a un altro file. Questo modulo non è supportato sulle piattaforme Windows. 

L'input per le `target` opzioni `path` and può essere un percorso assoluto o relativo. Se l'input per l'`path`opzione è un percorso relativo, viene sostituito con il percorso assoluto al momento della creazione del collegamento.

Per impostazione predefinita, quando un link con il nome specificato esiste già nella cartella specificata, il modulo di azione restituisce un errore. È possibile ignorare questo comportamento predefinito impostando l'`force`opzione su`true`. Quando l'`force`opzione è impostata su`true`, il modulo sovrascriverà il link esistente.

Se non esiste una cartella principale, il modulo di azione crea la cartella in modo ricorsivo, per impostazione predefinita.

Il modulo di azione restituisce un errore quando si verifica quanto segue:
+ Il file di destinazione non esiste in fase di esecuzione.
+ Esiste già un file di collegamento non simbolico con il nome specificato.
+ Il modulo di azione rileva un errore durante l'esecuzione dell'operazione.


**Input**  

| Nome chiave | Description | Tipo | Richiesto | Valore predefinito | Valori accettabili | Supportato su tutte le piattaforme | 
| --- | --- | --- | --- | --- | --- | --- | 
| path | Il percorso del file. | Stringa | Sì | N/D | N/D | Non supportato su Windows. | 
| target | Il percorso del file di destinazione a cui punta il link simbolico. | Stringa | Sì | N/D | N/D | Non supportato in Windows. | 
| force | Forza la creazione di un collegamento quando esiste già un collegamento con lo stesso nome. | Boolean | No | false | N/D | Non supportato in Windows. | 

**Esempio di input: crea un link simbolico che forza la creazione di un link**

```
  - name: CreatingSymbolicLinkWithForce
    action: CreateSymlink
    inputs:
      - path: /Folder2/Symboliclink.txt
        target: /Folder/Sample.txt
        force: true
```

**Esempio di input: crea un link simbolico che non imponga la creazione di un link**

```
  - name: CreatingSymbolicLinkWithOutForce
    action: CreateSymlink
    inputs:
      - path: Symboliclink.txt
        target: /Folder/Sample.txt
```

**Output**  
Nessuna.

### DeleteFile (Linux, Windows, macOS)
<a name="action-modules-deletefile"></a>

Il modulo di **DeleteFile**azione elimina uno o più file in una posizione specificata.

L'input di `path` deve essere un percorso di file valido o un percorso di file con un carattere wild card (`*`) nel nome del file. Quando nel nome del file vengono specificati caratteri jolly, tutti i file all'interno della stessa cartella che corrispondono al carattere jolly verranno eliminati. 

Il modulo di azione restituisce un errore quando si verifica quanto segue:
+ Non sei autorizzato a eseguire operazioni di eliminazione.
+ Il modulo di azione rileva un errore durante l'esecuzione dell'operazione.


**Input**  

| Nome chiave | Description | Tipo | Richiesto | Valore predefinito | Valori accettabili | Supportato su tutte le piattaforme | 
| --- | --- | --- | --- | --- | --- | --- | 
| path | Il percorso del file. | Stringa | Sì | N/D | N/D | Sì | 

**Esempio di input: eliminare un singolo file (Linux)**

```
  - name: DeletingSingleFileLinux
    action: DeleteFile
    inputs:
      - path: /SampleFolder/MyFolder/Sample.txt
```

**Esempio di input: eliminare un singolo file (Windows)**

```
  - name: DeletingSingleFileWindows
    action: DeleteFile
    inputs:
      - path: C:\SampleFolder\MyFolder\Sample.txt
```

**Esempio di input: elimina un file che termina con «log» (Linux)**

```
  - name: DeletingFileEndingWithLogLinux
    action: DeleteFile
    inputs:
      - path: /SampleFolder/MyFolder/*log
```

**Esempio di input: eliminare un file che termina con «log» (Windows)**

```
  - name: DeletingFileEndingWithLogWindows
    action: DeleteFile
    inputs:
      - path: C:\SampleFolder\MyFolder\*log
```

**Esempio di input: elimina tutti i file in una cartella specificata (Linux)**

```
  - name: DeletingAllFilesInAFolderLinux
    action: DeleteFile
    inputs:
      - path: /SampleFolder/MyFolder/*
```

**Esempio di input: elimina tutti i file in una cartella specificata (Windows)**

```
  - name: DeletingAllFilesInAFolderWindows
    action: DeleteFile
    inputs:
      - path: C:\SampleFolder\MyFolder\*
```

**Output**  
Nessuna.

### DeleteFolder (Linux, Windows, macOS)
<a name="action-modules-deletefolder"></a>

Il modulo di **DeleteFolder**azione elimina le cartelle.

Se la cartella non è vuota, è necessario impostare l'`force`opzione per `true` rimuovere la cartella e il suo contenuto. Se non si imposta l'`force`opzione su e la cartella che si sta tentando di eliminare non è vuota, il modulo di azione restituisce un errore. `true` Il valore predefinito dell'`force`opzione è`false`.

Il modulo di azione restituisce un errore quando si verifica quanto segue:
+ Non sei autorizzato a eseguire operazioni di eliminazione.
+ Il modulo di azione rileva un errore durante l'esecuzione dell'operazione.


**Input**  

| Nome chiave | Description | Tipo | Richiesto | Valore predefinito | Valori accettabili | Supportato su tutte le piattaforme | 
| --- | --- | --- | --- | --- | --- | --- | 
| path | Il percorso della cartella. | Stringa | Sì | N/D | N/D | Sì | 
| force | Rimuove la cartella indipendentemente dal fatto che sia vuota o meno. | Boolean | No | false | N/D | Sì | 

**Esempio di input: elimina una cartella che non è vuota usando l'`force`opzione (Linux)** 

```
  - name: DeletingFolderWithForceOptionLinux
    action: DeleteFolder
    inputs:
      - path: /Sample/MyFolder/Sample/
        force: true
```

**Esempio di input: elimina una cartella che non è vuota usando l'`force`opzione (Windows)** 

```
  - name: DeletingFolderWithForceOptionWindows
    action: DeleteFolder
    inputs:
      - path: C:\Sample\MyFolder\Sample\
        force: true
```

**Esempio di input: eliminare una cartella (Linux)** 

```
  - name: DeletingFolderWithOutForceLinux
    action: DeleteFolder
    inputs:
      - path: /Sample/MyFolder/Sample/
```

**Esempio di input: eliminare una cartella (Windows)** 

```
  - name: DeletingFolderWithOutForce
    action: DeleteFolder
    inputs:
      - path: C:\Sample\MyFolder\Sample\
```

**Output**  
Nessuna.

### ListFiles (Linux, Windows, macOS)
<a name="action-modules-listfiles"></a>

Il modulo di **ListFiles**azione elenca i file in una cartella specificata. Quando l'opzione ricorsiva è impostata su`true`, elenca i file nelle sottocartelle. Per impostazione predefinita, questo modulo non elenca i file nelle sottocartelle.

Per elencare tutti i file con nomi che corrispondono a uno schema specificato, utilizzate l'`fileNamePattern`opzione per fornire il modello. L'`fileNamePattern`opzione accetta il valore wildcard (`*`). Quando `fileNamePattern` viene fornito, vengono restituiti tutti i file che corrispondono al formato del nome file specificato. 

Il modulo di azione restituisce un errore quando si verifica quanto segue:
+ La cartella specificata non esiste in fase di esecuzione.
+ Non sei autorizzato a creare un file o una cartella nella cartella principale specificata.
+ Il modulo di azione rileva un errore durante l'esecuzione dell'operazione.


**Input**  

| Nome chiave | Description | Tipo | Richiesto | Valore predefinito | Valori accettabili | Supportato su tutte le piattaforme | 
| --- | --- | --- | --- | --- | --- | --- | 
| path | Il percorso della cartella. | Stringa | Sì | N/D | N/D | Sì | 
| fileNamePattern | Lo schema a cui abbinare elenca tutti i file con nomi che corrispondono al modello. | Stringa | No | N/D | N/D | Sì | 
| recursive | Elenca i file nella cartella in modo ricorsivo. | Boolean | No | false | N/D | Sì | 

**Esempio di input: elenca i file nella cartella specificata (Linux)**

```
  - name: ListingFilesInSampleFolderLinux
    action: ListFiles
    inputs:
      - path: /Sample/MyFolder/Sample
```

**Esempio di input: elenca i file nella cartella specificata (Windows)**

```
  - name: ListingFilesInSampleFolderWindows
    action: ListFiles
    inputs:
      - path: C:\Sample\MyFolder\Sample
```

**Esempio di input: elenca i file che terminano con «log» (Linux)**

```
  - name: ListingFilesWithEndingWithLogLinux
    action: ListFiles
    inputs:
      - path: /Sample/MyFolder/
        fileNamePattern: *log
```

**Esempio di input: elenca i file che terminano con «log» (Windows)**

```
  - name: ListingFilesWithEndingWithLogWindows
    action: ListFiles
    inputs:
      - path: C:\Sample\MyFolder\
        fileNamePattern: *log
```

**Esempio di input: elenca i file in modo ricorsivo**

```
  - name: ListingFilesRecursively
    action: ListFiles
    inputs:
      - path: /Sample/MyFolder/
        recursive: true
```


**Output**  

| Nome chiave | Description | Tipo | 
| --- | --- | --- | 
| files | L'elenco dei file. | Stringa | 

**Esempio di output**

```
{
	"files": "/sample1.txt,/sample2.txt,/sample3.txt"
}
```

### MoveFile (Linux, Windows, macOS)
<a name="action-modules-movefile"></a>

Il modulo di **MoveFile**azione sposta i file dall'origine specificata alla destinazione specificata.

Se il file esiste già nella cartella specificata, il modulo di azione, per impostazione predefinita, sovrascrive il file esistente. È possibile ignorare questo comportamento predefinito impostando l'opzione di sovrascrittura su. `false` Quando l'opzione di sovrascrittura è impostata su e nella posizione specificata è già presente un file con il nome specificato, il modulo di azione restituirà un errore. `false` Questa opzione funziona come il `mv` comando in Linux, che per impostazione predefinita sovrascrive.

Il nome del file sorgente può includere un wildcard ()`*`. I caratteri jolly sono accettati solo dopo l'ultimo separatore di percorso del file (`/`o). `\` Se nel nome del file di origine sono inclusi caratteri jolly, tutti i file che corrispondono ai caratteri jolly vengono copiati nella cartella di destinazione. Se desiderate spostare più di un file utilizzando un carattere jolly, l'input dell'`destination`opzione deve terminare con un separatore del percorso del file (`/`o`\`), che indica che l'input di destinazione è una cartella.

Se il nome del file di destinazione è diverso dal nome del file di origine, è possibile specificare il nome del file di destinazione utilizzando l'`destination`opzione. Se non si specifica un nome di file di destinazione, il nome del file di origine viene utilizzato per creare il file di destinazione. Qualsiasi testo che segue il separatore (`/`o`\`) dell'ultimo percorso del file viene considerato come nome del file. Se si desidera utilizzare lo stesso nome di file del file di origine, l'input dell'`destination`opzione deve terminare con un separatore di percorso del file (`/`o`\`). 

Il modulo di azione restituisce un errore quando si verifica quanto segue:
+ Non sei autorizzato a creare un file nella cartella specificata.
+ I file di origine non esistono in fase di esecuzione.
+ Esiste già una cartella con il nome di file specificato e l'`overwrite`opzione è impostata su`false`.
+ Il modulo di azione rileva un errore durante l'esecuzione dell'operazione.


**Input**  

| Nome chiave | Description | Tipo | Richiesto | Valore predefinito | Valori accettabili | Supportato su tutte le piattaforme | 
| --- | --- | --- | --- | --- | --- | --- | 
| source | Il percorso del file sorgente. | Stringa | Sì | N/D | N/D | Sì | 
| destination | Il percorso del file di destinazione. | Stringa | Sì | N/D | N/D | Sì | 
| overwrite | Se impostato su false, i file di destinazione non verranno sostituiti quando nella posizione specificata è già presente un file con il nome specificato. | Boolean | No | true | N/D | Sì | 

**Esempio di input: sposta un file (Linux)**

```
  - name: MovingAFileLinux
    action: MoveFile
    inputs:
      - source: /Sample/MyFolder/Sample.txt
        destination: /MyFolder/destinationFile.txt
```

**Esempio di input: sposta un file (Windows)**

```
  - name: MovingAFileWindows
    action: MoveFile
    inputs:
      - source: C:\Sample\MyFolder\Sample.txt
        destination: C:\MyFolder\destinationFile.txt
```

**Esempio di input: sposta un file usando il nome del file sorgente (Linux)**

```
  - name: MovingFileWithSourceFileNameLinux
    action: MoveFile
    inputs:
      - source: /Sample/MyFolder/Sample.txt
        destination: /MyFolder/
```

**Esempio di input: sposta un file usando il nome del file sorgente (Windows)**

```
  - name: MovingFileWithSourceFileNameWindows
    action: MoveFile
    inputs:
      - source: C:\Sample\MyFolder\Sample.txt
        destination: C:\MyFolder
```

**Esempio di input: sposta un file usando un carattere jolly (Linux)**

```
  - name: MovingFilesWithWildCardLinux
    action: MoveFile
    inputs:
      - source: /Sample/MyFolder/Sample*
        destination: /MyFolder/
```

**Esempio di input: sposta un file usando un carattere jolly (Windows)**

```
  - name: MovingFilesWithWildCardWindows
    action: MoveFile
    inputs:
      - source: C:\Sample\MyFolder\Sample*
        destination: C:\MyFolder
```

**Esempio di input: sposta un file senza sovrascriverlo (Linux)**

```
  - name: MovingFilesWithoutOverwriteLinux
    action: MoveFile
    inputs:
      - source: /Sample/MyFolder/Sample.txt
        destination: /MyFolder/destinationFile.txt
        overwrite: false
```

**Esempio di input: sposta un file senza sovrascriverlo (Windows)**

```
  - name: MovingFilesWithoutOverwrite
    action: MoveFile
    inputs:
      - source: C:\Sample\MyFolder\Sample.txt
        destination: C:\MyFolder\destinationFile.txt
        overwrite: false
```

**Output**  
Nessuna.

### MoveFolder (Linux, Windows, macOS)
<a name="action-modules-movefolder"></a>

Il modulo di **MoveFolder**azione sposta le cartelle dall'origine specificata alla destinazione specificata. L'input dell'`source`opzione è la cartella da spostare e l'input dell'`destination`opzione è la cartella in cui viene spostato il contenuto delle cartelle di origine.

Se la cartella principale di destinazione o l'input dell'`destination`opzione non esiste in fase di esecuzione, il comportamento predefinito del modulo consiste nel creare ricorsivamente la cartella nella destinazione specificata.

Se una cartella con la stessa cartella di origine esiste già nella cartella di destinazione, il modulo di azione, per impostazione predefinita, sovrascrive la cartella esistente. È possibile ignorare questo comportamento predefinito impostando l'opzione di sovrascrittura su. `false` Quando l'opzione di sovrascrittura è impostata su e nella posizione specificata è già presente una cartella con il nome specificato, il modulo di azione restituirà un errore. `false`

Il nome della cartella di origine può includere un carattere jolly ()`*`. I caratteri jolly sono accettati solo dopo l'ultimo separatore di percorso del file (`/`o). `\` Se nel nome della cartella di origine sono inclusi caratteri jolly, tutte le cartelle che corrispondono al carattere jolly vengono copiate nella cartella di destinazione. Se desiderate spostare più di una cartella utilizzando un carattere jolly, l'input dell'`destination`opzione deve terminare con un separatore del percorso del file (`/`o`\`), che indica che l'input di destinazione è una cartella.

Se il nome della cartella di destinazione è diverso dal nome della cartella di origine, è possibile specificare il nome della cartella di destinazione utilizzando l'`destination`opzione. Se non si specifica un nome per la cartella di destinazione, per creare la cartella di destinazione viene utilizzato il nome della cartella di origine. Qualsiasi testo che segue il separatore (`/`o`\`) dell'ultimo percorso del file viene considerato come nome della cartella. Se si desidera utilizzare lo stesso nome di cartella della cartella di origine, l'immissione dell'`destination`opzione deve terminare con un separatore del percorso del file (`/`o`\`). 

Il modulo di azione restituisce un errore quando si verifica quanto segue:
+ Non sei autorizzato a creare una cartella nella cartella di destinazione.
+ Le cartelle di origine non esistono in fase di esecuzione.
+ Esiste già una cartella con il nome specificato e l'`overwrite`opzione è impostata su`false`.
+ Il modulo di azione rileva un errore durante l'esecuzione dell'operazione.


**Input**  

| Nome chiave | Description | Tipo | Richiesto | Valore predefinito | Valori accettabili | Supportato su tutte le piattaforme | 
| --- | --- | --- | --- | --- | --- | --- | 
| source | Il percorso della cartella di origine. | Stringa | Sì | N/D | N/D | Sì | 
| destination | Il percorso della cartella di destinazione. | Stringa | Sì | N/D | N/D | Sì | 
| overwrite | Se impostato su false, le cartelle di destinazione non verranno sostituite se nella posizione specificata è già presente una cartella con il nome specificato. | Boolean | No | true | N/D | Sì | 

**Esempio di input: sposta una cartella (Linux)**

```
  - name: MovingAFolderLinux
    action: MoveFolder
    inputs:
      - source: /Sample/MyFolder/SourceFolder
        destination: /MyFolder/destinationFolder
```

**Esempio di input: sposta una cartella (Windows)**

```
  - name: MovingAFolderWindows
    action: MoveFolder
    inputs:
      - source: C:\Sample\MyFolder\SourceFolder
        destination: C:\MyFolder\destinationFolder
```

**Esempio di input: sposta una cartella usando il nome della cartella di origine (Linux)**

```
  - name: MovingFolderWithSourceFolderNameLinux
    action: MoveFolder
    inputs:
      - source: /Sample/MyFolder/SampleFolder
        destination: /MyFolder/
```

**Esempio di input: sposta una cartella usando il nome della cartella di origine (Windows)**

```
  - name: MovingFolderWithSourceFolderNameWindows
    action: MoveFolder
    inputs:
      - source: C:\Sample\MyFolder\SampleFolder
        destination: C:\MyFolder\
```

**Esempio di input: sposta una cartella usando un carattere jolly (Linux)**

```
  - name: MovingFoldersWithWildCardLinux
    action: MoveFolder
    inputs:
      - source: /Sample/MyFolder/Sample*
        destination: /MyFolder/
```

**Esempio di input: sposta una cartella usando un carattere jolly (Windows)**

```
  - name: MovingFoldersWithWildCardWindows
    action: MoveFolder
    inputs:
      - source: C:\Sample\MyFolder\Sample*
        destination: C:\MyFolder\
```

**Esempio di input: sposta una cartella senza sovrascriverla (Linux)**

```
  - name: MovingFoldersWithoutOverwriteLinux
    action: MoveFolder
    inputs:
      - source: /Sample/MyFolder/SampleFolder
    destination: /MyFolder/destinationFolder
    overwrite: false
```

**Esempio di input: sposta una cartella senza sovrascriverla (Windows)**

```
  - name: MovingFoldersWithoutOverwriteWindows
    action: MoveFolder
    inputs:
      - source: C:\Sample\MyFolder\SampleFolder
        destination: C:\MyFolder\destinationFolder
        overwrite: false
```

**Output**  
Nessuna.

### ReadFile (Linux, Windows, macOS)
<a name="action-modules-readfile"></a>

Il modulo di **ReadFile**azione legge il contenuto di un file di testo di tipo string. Questo modulo può essere utilizzato per leggere il contenuto di un file da utilizzare nei passaggi successivi tramite concatenamento o per leggere i dati nel `console.log` file. Se il percorso specificato è un collegamento simbolico, questo modulo restituisce il contenuto del file di destinazione. Questo modulo supporta solo file di testo.

Se il valore di codifica del file è diverso dal valore di codifica predefinito (`utf-8`), è possibile specificare il valore di codifica del file utilizzando l'opzione. `encoding` Per impostazione predefinita, `utf-16` si presume che utilizzino la `utf-32` codifica little-endian. 

Per impostazione predefinita, questo modulo non può stampare il contenuto del file sul file. `console.log` È possibile ignorare questa impostazione impostando la `printFileContent` proprietà su`true`.

Questo modulo può restituire solo il contenuto di un file. Non può analizzare file, come file Excel o JSON.

Il modulo di azione restituisce un errore quando si verifica quanto segue:
+ Il file non esiste in fase di esecuzione.
+ Il modulo di azione rileva un errore durante l'esecuzione dell'operazione.


**Input**  

| Nome chiave | Description | Tipo | Richiesto | Valore predefinito | Valori accettabili | Supportato su tutte le piattaforme | 
| --- | --- | --- | --- | --- | --- | --- | 
| path | Il percorso del file. | Stringa | Sì | N/D | N/D | Sì | 
| encoding | Lo standard di codifica. | Stringa | No | utf8 | utf8,utf-8,utf16,utf-16,utf16-LE, utf-16-LE utf16-BEutf-16-BE,utf32,utf-32,utf32-LE, utf-32-LEutf32-BE, e utf-32-BE. Il valore dell'opzione di codifica non fa distinzione tra maiuscole e minuscole. | Sì | 
| printFileContent | Stampa il contenuto del file sul file. console.log | Boolean | No | false | N/D | Sì. | 

**Esempio di input: lettura di un file (Linux)**

```
  - name: ReadingFileLinux
    action: ReadFile
    inputs:
      - path: /home/UserName/SampleFile.txt
```

**Esempio di input: leggere un file (Windows)**

```
  - name: ReadingFileWindows
    action: ReadFile
    inputs:
      - path: C:\Windows\WindowsUpdate.log
```

**Esempio di input: leggere un file e specificare lo standard di codifica**

```
  - name: ReadingFileWithFileEncoding
    action: ReadFile
    inputs:
      - path: /FolderName/SampleFile.txt
        encoding: UTF-32
```

**Esempio di input: leggere un file e stampare sul `console.log` file**

```
  - name: ReadingFileToConsole
    action: ReadFile
    inputs:
      - path: /home/UserName/SampleFile.txt
        printFileContent: true
```


**Output**  

| Campo | Description | Tipo | 
| --- | --- | --- | 
| content | Il contenuto del file. | stringa | 

**Esempio di output**

```
{
	"content" : "The file content"
}
```

### SetFileEncoding (Linux, Windows, macOS)
<a name="action-modules-setfileencoding"></a>

Il modulo di **SetFileEncoding**azione modifica la proprietà di codifica di un file esistente. Questo modulo può convertire la codifica dei file da uno standard `utf-8` di codifica specificato. Per impostazione predefinita, `utf-16` si presume che sia una codifica little-endian. `utf-32`

Il modulo di azione restituisce un errore quando si verifica quanto segue:
+ Non sei autorizzato a eseguire la modifica specificata.
+ Il file non esiste in fase di esecuzione.
+ Il modulo di azione rileva un errore durante l'esecuzione dell'operazione.


**Input**  

| Nome chiave | Description | Tipo | Richiesto | Valore predefinito | Valori accettabili | Supportato su tutte le piattaforme | 
| --- | --- | --- | --- | --- | --- | --- | 
| path | Il percorso del file. | Stringa | Sì | N/D | N/D | Sì | 
| encoding | Lo standard di codifica. | Stringa | No | utf8 | utf8,utf-8,utf16,utf-16,utf16-LE, utf-16-LE utf16-BEutf-16-BE,utf32,utf-32,utf32-LE, utf-32-LEutf32-BE, e utf-32-BE. Il valore dell'opzione di codifica non fa distinzione tra maiuscole e minuscole. | Sì | 

**Esempio di input: imposta la proprietà di codifica del file**

```
  - name: SettingFileEncodingProperty
    action: SetFileEncoding
    inputs:
      - path: /home/UserName/SampleFile.txt
        encoding: UTF-16
```

**Output**  
Nessuna.

### SetFileOwner (Linux, Windows, macOS)
<a name="action-modules-setfileowner"></a>

Il modulo di **SetFileOwner**azione modifica le proprietà `owner` e il `group` proprietario di un file esistente. Se il file specificato è un collegamento simbolico, il modulo modifica la `owner` proprietà del file sorgente. Questo modulo non è supportato sulle piattaforme Windows. 

Questo modulo accetta nomi di utenti e gruppi come input. Se il nome del gruppo non viene fornito, il modulo assegna il proprietario del gruppo del file al gruppo a cui appartiene l'utente.

Il modulo di azione restituisce un errore quando si verifica quanto segue:
+ Non sei autorizzato a eseguire la modifica specificata.
+ Il nome utente o gruppo specificato non esiste in fase di esecuzione.
+ Il file non esiste in fase di esecuzione.
+ Il modulo di azione rileva un errore durante l'esecuzione dell'operazione.


**Input**  

| Nome chiave | Description | Tipo | Richiesto | Valore predefinito | Valori accettabili | Supportato su tutte le piattaforme | 
| --- | --- | --- | --- | --- | --- | --- | 
| path | Il percorso del file. | Stringa | Sì | N/D | N/D | Non supportato su Windows. | 
| owner | Il nome utente. | stringa | Sì | N/D | N/D | Non supportato su Windows. | 
| group | Il nome del gruppo di utenti. | Stringa | No | Il nome del gruppo a cui appartiene l'utente. | N/D | Non supportato su Windows. | 

**Esempio di input: imposta la proprietà del proprietario del file senza specificare il nome del gruppo di utenti**

```
  - name: SettingFileOwnerPropertyNoGroup
    action: SetFileOwner
    inputs:
      - path: /home/UserName/SampleText.txt
        owner: LinuxUser
```

**Esempio di input: imposta la proprietà del proprietario del file specificando il proprietario e il gruppo di utenti**

```
  - name: SettingFileOwnerProperty
    action: SetFileOwner
    inputs:
      - path: /home/UserName/SampleText.txt
        owner: LinuxUser
        group: LinuxUserGroup
```

**Output**  
Nessuna.

### SetFolderOwner (Linux, Windows, macOS)
<a name="action-modules-setfolderowner"></a>

Il modulo di **SetFolderOwner**azione modifica in modo ricorsivo le proprietà `owner` e il `group` proprietario di una cartella esistente. Per impostazione predefinita, il modulo può modificare la proprietà di tutti i contenuti di una cartella. È possibile impostare l'`recursive`opzione per `false` ignorare questo comportamento. Questo modulo non è supportato sulle piattaforme Windows. 

Questo modulo accetta nomi di utenti e gruppi come input. Se il nome del gruppo non viene fornito, il modulo assegna il proprietario del gruppo del file al gruppo a cui appartiene l'utente.

Il modulo di azione restituisce un errore quando si verifica quanto segue:
+ Non sei autorizzato a eseguire la modifica specificata.
+ Il nome utente o gruppo specificato non esiste in fase di esecuzione.
+ La cartella non esiste in fase di esecuzione.
+ Il modulo di azione rileva un errore durante l'esecuzione dell'operazione.


**Input**  

| Nome chiave | Description | Tipo | Richiesto | Valore predefinito | Valori accettabili | Supportato su tutte le piattaforme | 
| --- | --- | --- | --- | --- | --- | --- | 
| path | Il percorso della cartella. | Stringa | Sì | N/D | N/D | Non supportato su Windows. | 
| owner | Il nome utente. | stringa | Sì | N/D | N/D | Non supportato su Windows. | 
| group | Il nome del gruppo di utenti. | Stringa | No | Il nome del gruppo a cui appartiene l'utente. | N/D | Non supportato su Windows. | 
| recursive | Sostituisce il comportamento predefinito di modifica della proprietà di tutto il contenuto di una cartella quando è impostato su. false | Boolean | No | true | N/D | Non supportato in Windows. | 

**Esempio di input: imposta la proprietà del proprietario della cartella senza specificare il nome del gruppo di utenti**

```
  - name: SettingFolderPropertyWithOutGroup
    action: SetFolderOwner
    inputs:
      - path: /SampleFolder/
        owner: LinuxUser
```

**Esempio di input: imposta la proprietà del proprietario della cartella senza sovrascrivere la proprietà di tutti i contenuti di una cartella**

```
  - name: SettingFolderPropertyWithOutRecursively
    action: SetFolderOwner
    inputs:
      - path: /SampleFolder/
        owner: LinuxUser
        recursive: false
```

**Esempio di input: imposta la proprietà di proprietà del file specificando il nome del gruppo di utenti**

```
  - name: SettingFolderPropertyWithGroup
    action: SetFolderOwner
    inputs:
      - path: /SampleFolder/
        owner: LinuxUser
        group: LinuxUserGroup
```

**Output**  
Nessuna.

### SetFilePermissions (Linux, Windows, macOS)
<a name="action-modules-setfilepermissions"></a>

Il modulo di **SetFilePermissions**azione modifica un `permissions` file esistente. Questo modulo non è supportato sulle piattaforme Windows. 

L'input per `permissions` deve essere un valore di stringa.

Questo modulo di azione può creare un file con i permessi definiti dal valore umask predefinito del sistema operativo. È necessario impostare il `umask` valore se si desidera sovrascrivere il valore predefinito.

Il modulo di azione restituisce un errore quando si verifica quanto segue:
+ Non sei autorizzato a eseguire la modifica specificata.
+ Il file non esiste in fase di esecuzione.
+ Il modulo di azione rileva un errore durante l'esecuzione dell'operazione.


**Input**  

| Nome chiave | Description | Tipo | Richiesto | Valore predefinito | Valori accettabili | Supportato su tutte le piattaforme | 
| --- | --- | --- | --- | --- | --- | --- | 
| path | Il percorso del file. | Stringa | Sì | N/D | N/D | Non supportato su Windows. | 
| permissions | Le autorizzazioni relative ai file. | Stringa | Sì | N/D | N/D | Non supportato su Windows. | 

**Esempio di input: modifica delle autorizzazioni dei file**

```
  - name: ModifyingFilePermissions
    action: SetFilePermissions
    inputs:
      - path: /home/UserName/SampleFile.txt
        permissions: 766
```

**Output**  
Nessuna.

### SetFolderPermissions (Linux, Windows, macOS)
<a name="action-modules-setfolderpermissions"></a>

Il modulo di **SetFolderPermissions**azione modifica in modo ricorsivo una cartella esistente e tutti i relativi sottofile e sottocartelle. `permissions` Per impostazione predefinita, questo modulo può modificare le autorizzazioni per tutti i contenuti della cartella specificata. È possibile impostare l'`recursive`opzione per `false` ignorare questo comportamento. Questo modulo non è supportato sulle piattaforme Windows. 

L'input per `permissions` deve essere un valore di stringa. 

Questo modulo di azione può modificare le autorizzazioni in base al valore umask predefinito del sistema operativo. È necessario impostare il `umask` valore se si desidera sovrascrivere il valore predefinito.

Il modulo di azione restituisce un errore quando si verifica quanto segue:
+ Non sei autorizzato a eseguire la modifica specificata.
+ La cartella non esiste in fase di esecuzione.
+ Il modulo di azione rileva un errore durante l'esecuzione dell'operazione.


**Input**  

| Nome chiave | Description | Tipo | Richiesto | Valore predefinito | Valori accettabili | Supportato su tutte le piattaforme | 
| --- | --- | --- | --- | --- | --- | --- | 
| path | Il percorso della cartella. | Stringa | Sì | N/D | N/D | Non supportato su Windows. | 
| permissions | Le autorizzazioni della cartella. | Stringa | Sì | N/D | N/D | Non supportato su Windows. | 
| recursive | Sostituisce il comportamento predefinito di modifica delle autorizzazioni per tutto il contenuto di una cartella quando è impostato su. false | Boolean | No | true | N/D | Non supportato in Windows. | 

**Esempio di input: imposta le autorizzazioni per le cartelle**

```
  - name: SettingFolderPermissions
    action: SetFolderPermissions
    inputs:
      - path: SampleFolder/
        permissions: 0777
```

**Esempio di input: imposta le autorizzazioni per le cartelle senza modificare le autorizzazioni per tutto il contenuto di una cartella**

```
  - name: SettingFolderPermissionsNoRecursive
    action: SetFolderPermissions
    inputs:
      - path: /home/UserName/SampleFolder/
        permissions: 777
        recursive: false
```

**Output**  
Nessuna.

## Azioni di installazione del software
<a name="action-modules-software-install-actions"></a>

La sezione seguente descrive i moduli di azione che installano o disinstallano il software.

**Requisiti IAM**  
Se il percorso di download dell'installazione è un URI S3, il ruolo IAM associato al profilo dell'istanza deve disporre dell'autorizzazione per eseguire il modulo di `S3Download` azione. Per concedere l'autorizzazione richiesta, collega la policy `S3:GetObject` IAM al ruolo IAM associato al profilo dell'istanza e specifica il percorso del bucket. Ad esempio, `arn:aws:s3:::BucketName/*`.

**Ingressi MSI complessi**  
Se le stringhe di input contengono virgolette doppie (`"`), è necessario utilizzare uno dei seguenti metodi per garantire che vengano interpretate correttamente:
+ È possibile utilizzare virgolette singole (') all'esterno della stringa, per contenerla, e virgolette doppie («) all'interno della stringa, come illustrato nell'esempio seguente.

  ```
  properties:
    COMPANYNAME: '"Acme ""Widgets"" and ""Gizmos."""'
  ```

  In questo caso, se devi usare un apostrofo all'interno della tua stringa, devi evitarlo. Ciò significa usare un'altra virgoletta singola (') prima dell'apostrofo.
+ Puoi usare le virgolette doppie («) all'esterno della stringa per contenerla. E puoi evitare le virgolette doppie all'interno della stringa, usando il carattere barra rovesciata (`\`), come mostrato nell'esempio seguente.

  ```
  properties:
    COMPANYNAME: "\"Acme \"\"Widgets\"\" and \"\"Gizmos.\"\"\""
  ```

Entrambi questi metodi passano il valore `COMPANYNAME="Acme ""Widgets"" and ""Gizmos."""` al **msiexec** comando.

**Topics**
+ [Installa MSI (Windows)](#action-modules-install-msi)
+ [Disinstalla MSI (Windows)](#action-modules-uninstall-msi)

### Installa MSI (Windows)
<a name="action-modules-install-msi"></a>

Il modulo di `InstallMSI` azione installa un'applicazione Windows utilizzando un file MSI. È possibile specificare il file MSI utilizzando un percorso locale, un URI di oggetto S3 o un URL Web. L'opzione di riavvio configura il comportamento di riavvio del sistema.

AWSTOE genera il **msiexec** comando in base ai parametri di input per il modulo di azione. I valori per i parametri di input `path` (posizione del file MSI) e `logFile` (posizione del file di registro) devono essere racchiusi tra virgolette («).

I seguenti codici di uscita MSI sono considerati corretti:
+ 0 (Successo)
+ 1614 (ERROR\$1PRODUCT\$1UNINSTALLED)
+ 1641 (riavvio avviato)
+ 3010 (riavvio richiesto)


**Input**  

| Nome chiave | Description | Tipo | Richiesto | Valore predefinito | Valori accettabili | 
| --- | --- | --- | --- | --- | --- | 
| path |  Specificate la posizione del file MSI utilizzando uno dei seguenti metodi: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/imagebuilder/latest/userguide/toe-action-modules.html) Le espressioni concatenate sono consentite.  | Stringa | Sì | N/D | N/D | 
| reboot |  Configura il comportamento di riavvio del sistema dopo l'esecuzione corretta del modulo di azione. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/imagebuilder/latest/userguide/toe-action-modules.html)  | Stringa | No | Allow | Allow, Force, Skip | 
| logOptions |  Specificare le opzioni da utilizzare per la registrazione dell'installazione MSI. I flag specificati vengono passati al programma di installazione MSI, insieme al parametro della riga di `/L` comando per abilitare la registrazione. Se non viene specificato alcun flag, AWSTOE utilizza il valore predefinito. Per ulteriori informazioni sulle opzioni di registro per MSI, vedere [Opzioni della riga di comando](https://learn.microsoft.com/en-us/windows/win32/msi/command-line-options) nella documentazione del prodotto Microsoft *Windows Installer*.  | Stringa | No | \$1VX | i,w,e,a,r,u,c,m,o,p,v,x,\$1,\$1,\$1 | 
| logFile |  Un percorso assoluto o relativo alla posizione del file di registro. Se il percorso del file di registro non esiste, viene creato. Se il percorso del file di registro non viene fornito, AWSTOE non memorizza il registro di installazione MSI.  | Stringa | No | N/D | N/D | 
| properties |  Coppie chiave-valore della proprietà di registrazione MSI, ad esempio: `TARGETDIR: "C:\target\location"`   Nota: non è consentita la modifica delle seguenti proprietà: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/imagebuilder/latest/userguide/toe-action-modules.html)  | Mappa [Stringa] Stringa | No | N/D | N/D | 
| ignoreAuthenticodeSignatureErrors |  Contrassegna per ignorare gli errori di convalida della firma authenticode per l'installatore specificato nel percorso. Il **Get-AuthenticodeSignature** comando viene utilizzato per convalidare gli installatori. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/imagebuilder/latest/userguide/toe-action-modules.html)  | Boolean | No | false | true, false | 
| allowUnsignedInstaller |  Contrassegno per consentire l'esecuzione del programma di installazione non firmato specificato nel percorso. Il **Get-AuthenticodeSignature** comando viene utilizzato per convalidare gli installatori. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/imagebuilder/latest/userguide/toe-action-modules.html)  | Boolean | No | false | true, false | 

**Esempi**  
Gli esempi seguenti mostrano le variazioni della sezione di input per il documento del componente, a seconda del percorso di installazione.

**Esempio di input: installazione del percorso del documento locale**

```
- name: local-path-install
  steps:
    - name: LocalPathInstaller
      action: InstallMSI
      inputs:
        path: C:\sample.msi
        logFile: C:\msilogs\local-path-install.log
        logOptions: '*VX'
        reboot: Allow
        properties:
          COMPANYNAME: '"Amazon Web Services"'
        ignoreAuthenticodeSignatureErrors: true
        allowUnsignedInstaller: true
```

**Esempio di input: installazione del percorso Amazon S3**

```
- name: s3-path-install
  steps:
    - name: S3PathInstaller
      action: InstallMSI
      inputs:
        path: s3://<bucket-name>/sample.msi
        logFile: s3-path-install.log
        reboot: Force
        ignoreAuthenticodeSignatureErrors: false
        allowUnsignedInstaller: true
```

**Esempio di input: installazione di percorsi web**

```
- name: web-path-install
  steps:
    - name: WebPathInstaller
      action: InstallMSI
      inputs:
        path: https://<some-path>/sample.msi
        logFile: web-path-install.log
        reboot: Skip
        ignoreAuthenticodeSignatureErrors: true
        allowUnsignedInstaller: false
```

**Output**  
Di seguito è riportato un esempio dell'output del modulo di `InstallMSI` azione.

```
{
	"logFile": "web-path-install.log",
	"msiExitCode": 0,
	"stdout": ""
}
```

### Disinstalla MSI (Windows)
<a name="action-modules-uninstall-msi"></a>

Il modulo di `UninstallMSI` azione consente di rimuovere un'applicazione Windows utilizzando un file MSI. È possibile specificare la posizione del file MSI utilizzando un percorso di file locale, un URI di oggetto S3 o un URL Web. L'opzione di riavvio configura il comportamento di riavvio del sistema.

AWSTOE genera il **msiexec** comando in base ai parametri di input per il modulo di azione. La posizione del file MSI (`path`) e la posizione del file di registro (`logFile`) sono esplicitamente racchiuse tra virgolette doppie («) durante la generazione del comando. **msiexec**

I seguenti codici di uscita MSI sono considerati validi:
+ 0 (Successo)
+ 1605 (ERROR\$1UNKNOWN\$1PRODUCT)
+ 1614 (ERROR\$1PRODUCT\$1UNINSTALLED)
+ 1641 (riavvio avviato)
+ 3010 (riavvio richiesto)


**Input**  

| Nome chiave | Description | Tipo | Richiesto | Valore predefinito | Valori accettabili | 
| --- | --- | --- | --- | --- | --- | 
| path |  Specificate la posizione del file MSI utilizzando uno dei seguenti metodi: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/imagebuilder/latest/userguide/toe-action-modules.html) Le espressioni concatenate sono consentite.  | Stringa | Sì | N/D | N/D | 
| reboot |  Configura il comportamento di riavvio del sistema dopo l'esecuzione corretta del modulo di azione. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/imagebuilder/latest/userguide/toe-action-modules.html)  | Stringa | No | Allow | Allow, Force, Skip | 
| logOptions |  Specificare le opzioni da utilizzare per la registrazione dell'installazione MSI. I flag specificati vengono passati al programma di installazione MSI, insieme al parametro della riga di `/L` comando per abilitare la registrazione. Se non viene specificato alcun flag, AWSTOE utilizza il valore predefinito. Per ulteriori informazioni sulle opzioni di registro per MSI, vedere [Opzioni della riga di comando](https://docs.microsoft.com/en-us/windows/win32/msi/command-line-options) nella documentazione del prodotto Microsoft *Windows Installer*.  | Stringa | No | \$1VX | i,w,e,a,r,u,c,m,o,p,v,x,\$1,\$1,\$1 | 
| logFile |  Un percorso assoluto o relativo alla posizione del file di registro. Se il percorso del file di registro non esiste, viene creato. Se il percorso del file di registro non viene fornito, AWSTOE non memorizza il registro di installazione MSI.  | Stringa | No | N/D | N/D | 
| properties |  Coppie chiave-valore della proprietà di registrazione MSI, ad esempio: `TARGETDIR: "C:\target\location"`   Nota: non è consentita la modifica delle seguenti proprietà: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/imagebuilder/latest/userguide/toe-action-modules.html)  | Mappa [Stringa] Stringa | No | N/D | N/D | 
| ignoreAuthenticodeSignatureErrors |  Contrassegna per ignorare gli errori di convalida della firma authenticode per l'installatore specificato nel percorso. Il **Get-AuthenticodeSignature** comando viene utilizzato per convalidare gli installatori. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/imagebuilder/latest/userguide/toe-action-modules.html)  | Boolean | No | false | true, false | 
| allowUnsignedInstaller |  Contrassegno per consentire l'esecuzione del programma di installazione non firmato specificato nel percorso. Il **Get-AuthenticodeSignature** comando viene utilizzato per convalidare gli installatori. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/imagebuilder/latest/userguide/toe-action-modules.html)  | Boolean | No | false | true, false | 

**Esempi**  
Gli esempi seguenti mostrano le variazioni della sezione di input per il documento del componente, a seconda del percorso di installazione.

**Esempio di input: rimuovere l'installazione del percorso del documento locale**

```
- name: local-path-uninstall
  steps:
    - name: LocalPathUninstaller
      action: UninstallMSI
      inputs:
        path: C:\sample.msi
        logFile: C:\msilogs\local-path-uninstall.log
        logOptions: '*VX'
        reboot: Allow
        properties:
          COMPANYNAME: '"Amazon Web Services"'
        ignoreAuthenticodeSignatureErrors: true
        allowUnsignedInstaller: true
```

**Esempio di input: rimuovere l'installazione del percorso di Amazon S3**

```
- name: s3-path-uninstall
  steps:
    - name: S3PathUninstaller
      action: UninstallMSI
      inputs:
        path: s3://<bucket-name>/sample.msi
        logFile: s3-path-uninstall.log
        reboot: Force
        ignoreAuthenticodeSignatureErrors: false
        allowUnsignedInstaller: true
```

**Esempio di input: rimuovere l'installazione del percorso web**

```
- name: web-path-uninstall
  steps:
    - name: WebPathUninstaller
      action: UninstallMSI
      inputs:
        path: https://<some-path>/sample.msi
        logFile: web-path-uninstall.log
        reboot: Skip
        ignoreAuthenticodeSignatureErrors: true
        allowUnsignedInstaller: false
```

**Output**  
Di seguito è riportato un esempio dell'output del modulo di `UninstallMSI` azione.

```
{
	"logFile": "web-path-uninstall.log",
	"msiExitCode": 0,
	"stdout": ""
}
```

## Moduli di azione del sistema
<a name="action-modules-system-actions"></a>

La sezione seguente descrive i moduli di azione che eseguono azioni di sistema o aggiornano le impostazioni di sistema.

**Topics**
+ [Riavvio (Linux, Windows)](#action-modules-reboot)
+ [SetRegistry (Windows)](#action-modules-setregistry)
+ [UpdateOS (Linux, Windows)](#action-modules-updateos)

### Riavvio (Linux, Windows)
<a name="action-modules-reboot"></a>

Il modulo di azione **Reboot riavvia** l'istanza. Ha un'opzione configurabile per ritardare l'inizio del riavvio. Per impostazione predefinita, `delaySeconds` è impostato su`0`, il che significa che non vi è alcun ritardo. Il timeout degli step non è supportato per il modulo di azione Reboot, in quanto non si applica al riavvio dell'istanza.

Se l'applicazione viene richiamata dall'agente Systems Manager, consegna il codice di uscita (`3010`per Windows, `194` per Linux) all'agente Systems Manager. Systems Manager Agent gestisce il riavvio del sistema come descritto in [Riavvio di un'istanza gestita dagli script](https://docs.aws.amazon.com/systems-manager/latest/userguide/send-commands-reboot.html).

Se l'applicazione viene richiamata sull'host come processo autonomo, salva lo stato di esecuzione corrente, configura un trigger di esecuzione automatica post-riavvio per rieseguire l'applicazione dopo il riavvio e quindi riavvia il sistema.

**Trigger di esecuzione automatica dopo il riavvio:**
+ **Windows**. AWSTOE crea una voce di Windows Task Scheduler con un trigger che viene eseguito automaticamente su `SystemStartup`
+ **Linux**. AWSTOE aggiunge un job in crontab che viene eseguito automaticamente dopo il riavvio del sistema.

```
@reboot /download/path/awstoe run --document s3://bucket/key/doc.yaml
```

Questo trigger viene eliminato all'avvio dell'applicazione.

**Tentativi**  
Per impostazione predefinita, il numero massimo di tentativi è impostato su Systems Manager`CommandRetryLimit`. Se il numero di riavvii supera il limite di tentativi, l'automazione fallisce. È possibile modificare il limite modificando il file di configurazione dell'agente Systems Manager (`Mds.CommandRetryLimit`). Vedere [Runtime Configuration](https://github.com/aws/amazon-ssm-agent/blob/mainline/README.md#runtime-configuration) nell'agente Systems Manager open source.

Per utilizzare il modulo di azione **Reboot**, per le fasi che contengono il riavvio `exitcode` (ad esempio,`3010`), è necessario eseguire il file binario dell'applicazione come. `sudo user`


**Input**  

| Nome chiave | Description | Tipo | Obbligatorio | Predefinita | 
| --- | --- | --- | --- | --- | 
| delaySeconds | Ritarda un determinato periodo di tempo prima di iniziare il riavvio. | Numero intero |  No  |  `0`  | 

**Esempio di input: fase di riavvio**

```
  - name: RebootStep
    action: Reboot
    onFailure: Abort
    maxAttempts: 2
    inputs:
      delaySeconds: 60
```

**Output**

Nessuna.

Una volta completato il modulo **Reboot**, Image Builder passa alla fase successiva della compilazione.

### SetRegistry (Windows)
<a name="action-modules-setregistry"></a>

Il modulo di **SetRegistry**azione accetta un elenco di input e consente di impostare il valore per la chiave di registro specificata. Se una chiave di registro non esiste, viene creata nel percorso definito. Questa funzionalità si applica solo a Windows.


**Input**  

| Nome chiave | Description | Tipo | Richiesto | 
| --- | --- | --- | --- | 
| path | Percorso della chiave di registro. | Stringa | Sì | 
| name | Nome della chiave di registro. | Stringa | Sì | 
| value | Valore della chiave di registro. | String/Number/Array | Sì | 
| type | Tipo di valore della chiave di registro. | Stringa | Sì | 

**Prefissi di percorso supportati**
+ `HKEY_CLASSES_ROOT / HKCR:`
+ `HKEY_USERS / HKU:`
+ `HKEY_LOCAL_MACHINE / HKLM:`
+ `HKEY_CURRENT_CONFIG / HKCC:`
+ `HKEY_CURRENT_USER / HKCU:`

**Tipi supportati **
+ `BINARY`
+ `DWORD`
+ `QWORD`
+ `SZ`
+ `EXPAND_SZ`
+ `MULTI_SZ`

**Esempio di input: imposta i valori delle chiavi di registro**

```
  - name: SetRegistryKeyValues
    action: SetRegistry
    maxAttempts: 3
    inputs:
      - path: HKLM:\SOFTWARE\MySoftWare
        name: MyName
        value: FirstVersionSoftware
        type: SZ
      - path: HKEY_CURRENT_USER\Software\Test
        name: Version
        value: 1.1
        type: DWORD
```

**Output**

Nessuna.

### UpdateOS (Linux, Windows)
<a name="action-modules-updateos"></a>

Il modulo di azione **UpdateOS** aggiunge il supporto per l'installazione degli aggiornamenti di Windows e Linux. Installa tutti gli aggiornamenti disponibili per impostazione predefinita. In alternativa, è possibile configurare un elenco di uno o più aggiornamenti specifici per l'installazione del modulo di azione. È inoltre possibile specificare gli aggiornamenti da escludere dall'installazione.

Se vengono forniti entrambi gli elenchi «includi» ed «escludi», l'elenco di aggiornamenti risultante può includere solo quelli elencati nell'elenco «include» che non sono elencati nell'elenco «escludi».

**Nota**  
**UpdateOS** non supporta Amazon Linux 2023 ()AL2023. Ti consigliamo di aggiornare l'AMI di base alla nuova versione fornita con ogni versione. Per altre alternative, consulta [Controllare gli aggiornamenti ricevuti dalle versioni principali e secondarie](https://docs.aws.amazon.com/linux/al2023/ug/deterministic-upgrades.html#controlling-release-updates) nella *Guida per l'utente di Amazon Linux 2023*.
+ **Windows**. Gli aggiornamenti vengono installati dalla fonte degli aggiornamenti configurata sul computer di destinazione.
+ **Linux**. L'applicazione verifica la presenza del gestore di pacchetti supportato nella piattaforma Linux e utilizza uno dei due `yum` o il gestore di `apt-get` pacchetti. Se nessuno dei due è supportato, viene restituito un errore. È necessario disporre `sudo` delle autorizzazioni per eseguire il modulo di azione **UpdateOS**. Se non si dispone delle `sudo` autorizzazioni, viene restituito. `error.Input`


**Input**  

| Nome chiave | Description | Tipo | Richiesto | 
| --- | --- | --- | --- | 
| include |  Per Windows, è possibile specificare quanto segue: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/imagebuilder/latest/userguide/toe-action-modules.html) Per Linux, è possibile specificare uno o più pacchetti da includere nell'elenco degli aggiornamenti per l'installazione.  | Elenco di stringhe | No | 
| exclude |  Per Windows, è possibile specificare quanto segue: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/imagebuilder/latest/userguide/toe-action-modules.html) Per Linux, è possibile specificare uno o più pacchetti da escludere dall'elenco degli aggiornamenti per l'installazione.  | Elenco di stringhe | No | 

**Esempio di input: aggiungi il supporto per l'installazione degli aggiornamenti Linux**

```
  - name: UpdateMyLinux
    action: UpdateOS
    onFailure: Abort
    maxAttempts: 3
    inputs:
      exclude:
        - ec2-hibinit-agent
```

**Esempio di input: aggiungere il supporto per l'installazione degli aggiornamenti di Windows**

```
  - name: UpdateWindowsOperatingSystem
    action: UpdateOS
    onFailure: Abort
    maxAttempts: 3
    inputs:
      include:
        - KB1234567
        - '*Security*'
```

**Output**

Nessuna.

# Configurare l'input per il comando AWSTOE run
<a name="toe-run-config-input"></a>

Per semplificare l'input da riga di comando per il AWSTOE **run** comando, è possibile includere le impostazioni per i parametri e le opzioni del comando in un file di configurazione di input in formato JSON con estensione di file. `.json` AWSTOE può leggere il file da una delle seguenti posizioni:
+ Un percorso di file locale (*./config.json*).
+ Un bucket S3 ()*s3://<bucket-path>/<bucket-name>/config.json*.

Quando si immette il **run** comando, è possibile specificare il file di configurazione di input utilizzando il **--config** parametro. Per esempio:

```
awstoe run --config <file-path>/config.json
```

**File di configurazione di input**  
Il file JSON di configurazione di input include coppie chiave-valore per tutte le impostazioni che è possibile fornire direttamente tramite parametri e opzioni di **run** comando. Se specificate un'impostazione sia nel file di configurazione di input che nel **run** comando, come parametro o opzione, si applicano le seguenti regole di precedenza:

**Regole di precedenza**

1. Un'impostazione fornita direttamente al **run** comando in AWS CLI, tramite un parametro o un'opzione, sovrascrive qualsiasi valore definito nel file di configurazione di input per la stessa impostazione.

1. Un'impostazione nel file di configurazione di input sovrascrive il valore predefinito di un componente.

1. Se non vengono passate altre impostazioni nel documento del componente, è possibile applicare un valore predefinito, se esistente.

Esistono due eccezioni a questa regola: documenti e parametri. Queste impostazioni funzionano in modo diverso nella configurazione di input e come parametri di comando. Se utilizzate il file di configurazione di input, non dovete specificare questi parametri direttamente nel **run** comando. Questa operazione genererà un errore.

**Impostazioni dei componenti**  
Il file di configurazione di input contiene le seguenti impostazioni. Per semplificare il file, puoi omettere tutte le impostazioni opzionali che non sono necessarie. Tutte le impostazioni sono opzionali se non diversamente specificato.
+ **cwIgnoreFailures**(Boolean) — Ignora gli errori di registrazione nei log. CloudWatch 
+ **cwLogGroup**(String) — Il nome dei log. `LogGroup` CloudWatch 
+ **cwLogRegion**(String) — La AWS regione che si applica ai CloudWatch registri.
+ **cwLogStream**(String) — Il `LogStream` nome dei CloudWatch log, che indica AWSTOE dove trasmettere il file. `console.log`
+ **Documents3 BucketOwner** (String): l'ID dell'account del proprietario del bucket per i documenti basati su URI S3.
+ **documents** (array di oggetti, obbligatorio) — Un array di oggetti JSON che rappresentano i documenti del componente YAML su cui il comando è in esecuzione. AWSTOE **run** È necessario specificare almeno un documento componente.

  Ogni oggetto è composto dai seguenti campi:
  + **path** (String, required) — La posizione del file del documento del componente YAML. Deve essere uno dei seguenti:
    + Un percorso di file locale (*./component-doc-example.yaml*).
    + Un URI S3 (`s3://bucket/key`).
    + Una versione di build del componente Image Builder ARN (arn:aws:imagebuilder:us-west-th//2021.12.02/1). *2:123456789012* *my-example-component*
  + **parameters** (array di oggetti) — Una matrice di oggetti a coppie chiave-valore, ciascuno dei quali rappresenta un parametro specifico del componente che il comando trasmette quando esegue il documento del componente. **run** I parametri sono facoltativi per i componenti. Il documento del componente può avere o meno dei parametri definiti.

    Ogni oggetto è composto dai seguenti campi:
    + **name** (String, required) — Il nome del parametro del componente.
    + **value** (String, required) — Il valore da passare al documento del componente per il parametro denominato.

    Per ulteriori informazioni sui parametri del componente, consulta la sezione **Parametri** della [Usa le variabili nel tuo documento componente personalizzato](toe-user-defined-variables.md) pagina.
+ **ExecutonID** (String) — Questo è l'ID univoco che si applica all'esecuzione del comando corrente**run**. Questo ID è incluso nei nomi dei file di output e di registro, per identificare in modo univoco tali file e collegarli all'esecuzione corrente del comando. Se questa impostazione viene omessa, AWSTOE genera un GUID.
+ **LogDirectory** (String) — La directory di destinazione in cui vengono AWSTOE archiviati tutti i file di registro dell'esecuzione di questo comando. Per impostazione predefinita, questa directory si trova all'interno della seguente directory principale:`TOE_<DATETIME>_<EXECUTIONID>`. Se non si specifica la directory di registro, AWSTOE utilizza la directory di lavoro corrente (`.`).
+ **LogS3 BucketName** (String) — Se i log dei componenti sono archiviati in Amazon S3 (consigliato), AWSTOE carica i log delle applicazioni dei componenti nel bucket S3 denominato in questo parametro.
+ **LogS3 BucketOwner** (String): se i log dei componenti sono archiviati in Amazon S3 (consigliato), questo è l'ID dell'account proprietario per il bucket in cui vengono scritti i file di registro. AWSTOE 
+ **LogS3 KeyPrefix** (String): se i log dei componenti sono archiviati in Amazon S3 (consigliato), questo è il prefisso della chiave dell'oggetto S3 per la posizione del registro nel bucket.
+ **parameters** (array di oggetti) — Un array di oggetti a coppie chiave-valore che rappresentano parametri che si applicano globalmente a tutti i componenti inclusi nell'esecuzione corrente del comando. **run**
  + **name** (String, required) — Il nome del parametro globale.
  + **value** (String, required) — Il valore da passare a tutti i documenti componenti per il parametro denominato.
+ **phases** (String) — Un elenco separato da virgole che specifica quali fasi eseguire dai documenti dei componenti YAML. Se un documento componente include fasi aggiuntive, queste non verranno eseguite.
+ **stateDirectory** (String) — Il percorso del file in cui sono archiviati i file di tracciamento dello stato.
+ **trace** (Boolean) — Abilita la registrazione dettagliata sulla console.

**Esempi**  
L'esempio seguente mostra un file di configurazione di input che esegue le `test` fasi `build` and per due documenti componenti:, e. `sampledoc.yaml` `conversation-intro.yaml` Ogni documento componente ha un parametro che si applica solo a se stesso ed entrambi utilizzano un parametro condiviso. Il `project` parametro si applica a entrambi i documenti componenti.

```
{
   "documents": [
     {
       "path": "<file path>/awstoe/sampledoc.yaml>",
       "parameters": [
         {
           "name": "dayofweek",
           "value": "Monday"
         }
       ]
     },
     {
       "path": "<file path>/awstoe/conversation-intro.yaml>",
       "parameters": [
         {
           "name": "greeting",
           "value": "Hello, HAL."
         }
       ]
     }
   ],
   "phases": "build,test",
   "parameters": [
     {
       "name": "project",
       "value": "examples"
     }
   ],
   "cwLogGroup": "<log_group_name>",
   "cwLogStream": "<log_stream_name>",
   "documentS3BucketOwner": "<owner_aws_account_number>",
   "executionId": "<id_number>",
   "logDirectory": "<local_directory_path>",
   "logS3BucketName": "<bucket_name_for_log_files>",
   "logS3KeyPrefix": "<key_prefix_for_log_files>",
   "logS3BucketOwner": "<owner_aws_account_number>"
 }
```