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

# Lavorare con i CloudFormation modelli
<a name="template-guide"></a>

Un AWS CloudFormation modello definisce le AWS risorse che desideri creare, aggiornare o eliminare come parte di uno stack. Consiste in diverse sezioni, ma l’unica sezione richiesta è la sezione [Resources](resources-section-structure.md), che deve dichiarare almeno una risorsa. 

Puoi creare dei modelli utilizzando i metodi seguenti:
+ **AWS Infrastructure Composer**: un’interfaccia visiva per la progettazione di modelli.
+ **Editor di testo**: per scrivere modelli direttamente nella sintassi JSON o YAML.
+ **Generatore IaC**: genera modelli a partire dalle risorse fornite nel tuo account che attualmente non sono gestite da. CloudFormation Il generatore di IaC funziona con un’ampia gamma di tipi di risorse supportati da Cloud Control API nella tua Regione.

Questa sezione fornisce una guida completa su come utilizzare le diverse sezioni di un CloudFormation modello e su come iniziare a creare modelli di stack. Comprende i seguenti argomenti:

**Topics**
+ [Dove vengono archiviati i modelli](#where-they-get-stored)
+ [Convalida dei modelli](#template-validation)
+ [Nozioni di base sui modelli](#getting-started)
+ [Modelli di esempio](#sample-templates)
+ [Formato del modello](template-formats.md)
+ [Sezioni del modello](template-anatomy.md)
+ [Infrastructure Composer](infrastructure-composer-for-cloudformation.md)
+ [AWS CloudFormation Server linguistico](ide-extension.md)
+ [Generatore IaC](generate-IaC.md)
+ [Ottenimento di valori archiviati in altri servizi](dynamic-references.md)
+ [Ottieni valori AWS](pseudo-parameter-reference.md)
+ [Ottieni l’output dello stack](using-cfn-stack-exports.md)
+ [Specifica delle risorse esistenti in fase di runtime](cloudformation-supplied-parameter-types.md)
+ [Procedure guidate](walkthroughs.md)
+ [Frammenti di modello](template-snippets.md)
+ [Stack basati su Windows](cfn-windows-stacks.md)
+ [Usa i tipi CloudFormation di risorse forniti da](cloudformation-supplied-resource-types.md)
+ [Creazione di configurazioni di risorse riutilizzabili con i moduli](modules.md)

## Dove vengono archiviati i modelli
<a name="where-they-get-stored"></a>

**Bucket Amazon S3**  
Puoi archiviare CloudFormation i modelli in un bucket Amazon S3. Quando crei o aggiorni uno stack, puoi specificare l’URL S3 del modello anziché caricarlo direttamente.

Se carichi i modelli direttamente tramite la sala Console di gestione AWS operatoria AWS CLI, viene creato automaticamente un bucket S3. Per ulteriori informazioni, consulta [Crea uno stack dalla console CloudFormation](cfn-console-create-stack.md).

**Repository Git**  
Con la [sincronizzazione Git](git-sync.md), puoi archiviare i modelli in un repository Git. Quando crei o aggiorni uno stack, puoi specificare la posizione del repository Git e il ramo contenente il modello invece di caricarlo direttamente o fare riferimento a un URL S3. CloudFormation monitora automaticamente il repository e il ramo specificati per le modifiche al modello. Per ulteriori informazioni, consulta [Creazione di uno stack dal codice sorgente del repository con la sincronizzazione Git](git-sync-create-stack-from-repository-source-code.md).

## Convalida dei modelli
<a name="template-validation"></a>

**Convalida della sintassi**  
Puoi verificare la sintassi JSON o YAML del modello utilizzando il comando CLI [validate-template](service_code_examples.md#validate-template-sdk) o specificando il modello nella console. La console esegue la convalida automaticamente. Per ulteriori informazioni, consulta [Crea uno stack dalla console CloudFormation](cfn-console-create-stack.md). 

Tuttavia, questi metodi verificano solamente la sintassi del modello e non convalidano i valori delle proprietà specificati per una risorsa.

**Strumenti di convalida aggiuntivi**  
Per convalide più complesse e controlli basati sulle best practice, puoi utilizzare strumenti aggiuntivi come:
+ [CloudFormation Linter (cfn-lint)](https://github.com/aws-cloudformation/cfn-lint) [— Convalida i modelli rispetto agli schemi dei provider di risorse. CloudFormation ](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/resource-type-schemas.html) Questo include la verifica di valori validi per le proprietà delle risorse e le best practice.
+ [CloudFormation Rain (rain fmt)](https://github.com/aws-cloudformation/rain): formatta i tuoi CloudFormation modelli secondo uno standard coerente o riformatta un modello da JSON a YAML (o da YAML a JSON). Conserva i commenti quando utilizzi YAML e, ove possibile, passa dall’utilizzo delle funzioni intrinseche alla sintassi breve.

## Nozioni di base sui modelli
<a name="getting-started"></a>

Per iniziare a creare un modello, segui questi passaggi: CloudFormation 

1. **Scegli le risorse**: identifica le AWS risorse che desideri includere nel tuo stack, come EC2 istanze VPCs, gruppi di sicurezza e altro.

1. **Scrivi il modello**: scrivi il modello in formato JSON o YAML definendo le risorse e le relative proprietà.

1. **Salva il modello**: salva il modello localmente con un’estensione di file come `.json`, `.yaml` o `.txt`.

1. **Convalida il modello**: convalida il modello utilizzando i metodi descritti nella sezione [Convalida dei modelli](#template-validation).

1. **Crea uno stack**: crea uno stack utilizzando il modello convalidato. 

### Pianifica di utilizzare il modello di riferimento CloudFormation
<a name="additional-resources"></a>

Mentre scrivi i modelli, puoi trovare la documentazione sulla sintassi dettagliata per i diversi tipi di risorse nella [documentazione di riferimento ai tipi di risorse e proprietàAWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-template-resource-type-ref.html).

Spesso, i modelli di stack richiedono funzioni intrinseche per assegnare valori di proprietà che non sono disponibili fino al runtime e attributi speciali per controllare il comportamento delle risorse. Durante la scrittura del modello, consulta le seguenti risorse come guida:
+ [Documentazione di riferimento sulla funzione intrinseca](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference.html): tra le funzioni intrinseche di uso comune ci sono:
  + `Ref`: recupera il valore di un parametro o l’ID fisico di una risorsa.
  + `Sub`: sostituisce i segnaposto nelle stringhe con valori effettivi.
  + `GetAtt`: restituisce il valore di un attributo da una risorsa nel modello.
  + `Join`: unisce un set di valori in un’unica stringa.
+ [Documentazione di riferimento sugli attributi della risorsa](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-product-attribute-reference.html): tra gli attributi speciali di uso comune ci sono:
  + `DependsOn`: per specificare che una risorsa deve essere creata dopo un’altra.
  + `DeletionPolicy`— Utilizzate questo attributo per CloudFormation specificare come gestire l'eliminazione di una risorsa.

## Modelli di esempio
<a name="sample-templates"></a>

CloudFormation fornisce modelli di stack open source che è possibile utilizzare per iniziare. Per ulteriori informazioni, consulta [Modelli CloudFormation di esempio](https://github.com/aws-cloudformation/aws-cloudformation-templates) sul GitHub sito Web.

Tieni presente che questi modelli non sono pensati per essere pronti per la produzione. Prenditi il tempo necessario per imparare come funzionano, adattarli alle tue esigenze e assicurarti che soddisfino gli standard di conformità della tua azienda.

Ogni modello di questo repository supera i controlli di [CloudFormation Linter](https://github.com/aws-cloudformation/cfn-lint) (cfn-lint) e anche un set di AWS CloudFormation Guard regole di base basato sulla Center for Internet Security (CIS) Top 20, con eccezioni per alcune regole in cui era opportuno mantenere l'esempio concentrato su un singolo caso d'uso.

# CloudFormation formato modello
<a name="template-formats"></a>

È possibile creare CloudFormation modelli nei formati JSON o YAML. Entrambi i formati hanno lo stesso scopo ma offrono vantaggi distinti in termini di leggibilità e complessità.
+ **JSON**: JSON è un formato di interscambio di dati leggero che le macchine riescono ad analizzare e generare facilmente. Tuttavia, può diventare complicato per gli esseri umani da leggere e scrivere, specialmente per configurazioni complesse. In JSON, il modello è strutturato utilizzando parentesi graffe `{}` e parentesi quadre `[]` annidate per definire risorse, parametri e altri componenti. La sua sintassi richiede una dichiarazione esplicita di ogni elemento, il che può rendere il modello prolisso ma garantisce la stretta aderenza a un formato strutturato. 
+ **YAML**: YAML è progettato per essere più leggibile dall’uomo e meno prolisso rispetto a JSON. Utilizza l’indentazione anziché parentesi quadre e graffe per indicare l’annidamento, il che può semplificare la visualizzazione della gerarchia di risorse e parametri. YAML è spesso preferito per la sua chiarezza e la sua facilità d’uso, specialmente quando si tratta di modelli più complessi. Tuttavia, la dipendenza di YAML dall’indentazione può portare a errori se la spaziatura non è coerente, il che richiede molta attenzione per mantenere la precisione.

## Struttura del modello
<a name="template-structure"></a>

CloudFormation i modelli sono suddivisi in diverse sezioni e ogni sezione è progettata per contenere un tipo specifico di informazioni. Alcune sezioni devono essere dichiarate in un ordine specifico, mentre per altre l’ordine non ha importanza. Tuttavia, durante la creazione di un modello, può risultare utile adottare l’ordine logico dei seguenti esempi, in quanto i valori di una sezione potrebbero fare riferimento ai valori di una sezione precedente. 

Durante la creazione di modelli, non utilizzare sezioni principali duplicate, come la sezione `Resources`. Sebbene CloudFormation possa accettare il modello, quest'ultimo avrà un comportamento indefinito durante l'elaborazione del modello e potrebbe fornire risorse in modo errato o restituire errori inspiegabili.

### JSON
<a name="template-structure.json"></a>

Il seguente esempio illustra la struttura di un modello in formato JSON con tutte le sezioni disponibili.

```
{
  "AWSTemplateFormatVersion" : "version date",

  "Description" : "JSON string",

  "Metadata" : {
    template metadata
  },

  "Parameters" : {
    set of parameters
  },
  
  "Rules" : {
    set of rules
  },

  "Mappings" : {
    set of mappings
  },

  "Conditions" : {
    set of conditions
  },

  "Transform" : {
    set of transforms
  },

  "Resources" : {
    set of resources
  },
  
  "Outputs" : {
    set of outputs
  }
}
```

### YAML
<a name="template-structure.yaml"></a>

Il seguente esempio illustra la struttura di un modello in formato YAML con tutte le sezioni disponibili.

```
---
AWSTemplateFormatVersion: version date

Description:
  String

Metadata:
  template metadata

Parameters:
  set of parameters

Rules:
  set of rules

Mappings:
  set of mappings

Conditions:
  set of conditions

Transform:
  set of transforms

Resources:
  set of resources

Outputs:
  set of outputs
```

## Commenti
<a name="template-comments"></a>

Nei modelli in formato JSON, i commenti non sono supportati. JSON, per impostazione predefinita, non include una sintassi per i commenti, il che significa che non è possibile aggiungere commenti direttamente all’interno della sua struttura. Tuttavia, se devi includere note esplicative o documentazione, puoi prendere in considerazione l’aggiunta di metadati. Per ulteriori informazioni, consulta [Attributo Metadata](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-metadata.html).

Nei modelli in formato YAML, puoi includere commenti in linea utilizzando il simbolo `#`.

L'esempio seguente mostra un modello YAML con i commenti inline.

```
AWSTemplateFormatVersion: 2010-09-09
Description: A sample CloudFormation template with YAML comments.
# Resources section
Resources:
  MyEC2Instance: 
    Type: AWS::EC2::Instance
    Properties: 
      # Linux AMI
      ImageId: ami-1234567890abcdef0 
      InstanceType: t2.micro
      KeyName: MyKey
      BlockDeviceMappings:
        - DeviceName: /dev/sdm
          Ebs:
            VolumeType: io1
            Iops: 200
            DeleteOnTermination: false
            VolumeSize: 20
```

## Specifiche
<a name="template-formats.supported-specifications"></a>

CloudFormation supporta le seguenti specifiche JSON e YAML:

JSON  
CloudFormation segue lo standard JSON ECMA-404. Per ulteriori informazioni sul formato JSON, consulta [http://www.json.org](http://www.json.org).

YAML  
CloudFormation supporta la specifica YAML versione 1.1 con alcune eccezioni. CloudFormation non supporta le seguenti funzionalità:  
+ I tag `binary`, `omap`, `pairs`, `set` e `timestamp`
+ Alias
+ Unioni di hash
Per ulteriori informazioni su YAML, visita il sito [https://www.yaml.org/](https://yaml.org/).

## Ulteriori informazioni
<a name="template-formats.learnmore"></a>

Per ogni risorsa specificata nel modello, definiscine le proprietà e i valori utilizzando le regole di sintassi specifiche di JSON o YAML. Per ulteriori informazioni sulla sintassi del modello per ogni formato, consulta [CloudFormation sezioni modello](template-anatomy.md).

# Uso delle espressioni regolari nei CloudFormation modelli
<a name="cfn-regexes"></a>

[È possibile utilizzare le espressioni regolari (comunemente note come espressioni regolari) in diversi punti all'interno dei CloudFormation modelli, ad esempio per la proprietà durante la creazione di un parametro del `AllowedPattern` modello.](parameters-section-structure.md)

Tutte le espressioni regolari sono CloudFormation conformi alla sintassi regex di Java. Per una descrizione completa della sintassi regex di Java e dei suoi costrutti, consulta [java.util.regex.Pattern.](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/regex/Pattern.html)

Se scrivi il tuo CloudFormation modello in sintassi JSON, devi evitare qualsiasi carattere di barra rovesciata (\$1) nell'espressione regolare aggiungendo una barra rovesciata aggiuntiva. Questo perché JSON interpreta le barre rovesciate come caratteri di escape, e devi eseguire l’escape per assicurarti che vengano trattate come barre rovesciate letterali nell’espressione regolare.

Ad esempio, se si include una `\d` nell’espressione regolare per individuare un carattere cifra, nel modello JSON è necessario scrivere `\\d`.

Nell’esempio seguente, la proprietà `AllowedPattern` specifica un’espressione regolare che corrisponde a quattro caratteri consecutivi (`\d{4}`). Tuttavia, poiché l’espressione regolare è definita in un modello JSON, è necessario eseguire l’escape del carattere barra rovesciata con una barra rovesciata aggiuntiva (`\\d`).

```
{
  "Parameters": {
    "MyParameter": {
      "Type": "String",
      "AllowedPattern": "\\d{4}"
    }
  }
}
```

Se scrivi il CloudFormation modello con la sintassi YAML, devi racchiudere l'espressione regolare tra virgolette singole («). Non è necessario eseguire ulteriori escape.

```
Parameters:
  MyParameter:
    Type: String
    AllowedPattern: '\d{4}'
```

**Nota**  
Le espressioni regolari in CloudFormation sono supportate solo per scopi di convalida in contesti specifici come. `AllowedPattern` Non sono supportate come operazioni di pattern matching in funzioni CloudFormation intrinseche, ad esempio, che eseguono solo il confronto esatto delle stringhe`Fn::Equals`, non la corrispondenza dei pattern.

# CloudFormation sezioni modello
<a name="template-anatomy"></a>

Ogni CloudFormation modello è composto da una o più sezioni, ognuna delle quali ha uno scopo specifico. 

La sezione **Risorse** è obbligatoria in ogni CloudFormation modello e costituisce il nucleo del modello. Questa sezione specifica le risorse dello stack e le relative proprietà, ad esempio un' EC2 istanza Amazon o un bucket Amazon S3. Ogni risorsa è definita con un ID logico, un tipo e dettagli di configurazione specifici univoci. 

La sezione **Parametri**, sebbene facoltativa, svolge un ruolo importante per rendere i modelli più flessibili. Consente infatti agli utenti di passare valori in runtime durante la creazione o l’aggiornamento di uno stack. Puoi fare riferimento a questi parametri nelle sezioni `Resources` e `Outputs`, abilitando la personalizzazione senza alterare il modello stesso. Ad esempio, puoi utilizzare i parametri per specificare tipi di istanze o impostazioni di ambiente che variano tra le implementazioni.

La sezione **Output**, anch’essa facoltativa, definisce i valori restituiti durante la visualizzazione delle proprietà di uno stack. Gli output forniscono informazioni utili, ad esempio identificatori di risorse URLs, che possono essere utilizzate per scopi operativi o per l'integrazione con altri stack. Questa sezione aiuta gli utenti a recuperare e utilizzare dettagli importanti sulle risorse create dal modello.

Altre sezioni opzionali includono le **Mappature**, che funzionano come tabelle di ricerca per gestire i valori condizionali. Con le mappature, è possibile definire coppie chiave-valore e utilizzarle con la funzione intrinseca `Fn::FindInMap` nelle sezioni `Resources` e `Outputs`. Ciò è utile per scenari in cui è necessario modificare le configurazioni in base a condizioni come l'ambiente. Regione AWS 

Le sezioni **Metadati** e **Regole**, sebbene utilizzate meno frequentemente, forniscono funzionalità aggiuntive. `Metadata` può includere informazioni aggiuntive sul modello, mentre `Rules` convalida un parametro o una combinazione di parametri durante la creazione o l’aggiornamento dello stack, assicurandosi che soddisfino criteri specifici. La sezione **Condizioni** migliora ulteriormente la flessibilità, perché controlla se alcune risorse sono state creati o se alle proprietà è stato assegnato un valore in base a condizioni come il tipo di ambiente.

Infine, la sezione **Trasforma** viene utilizzata per applicare le macro durante l’elaborazione del modello. Per le applicazioni serverless (chiamate anche applicazioni Lambda), specifica la versione del [Serverless Application AWS Model AWS (](https://github.com/awslabs/serverless-application-specification)SAM) da utilizzare. Quando si specifica una trasformazione, è possibile utilizzare la AWS SAM sintassi per dichiarare le risorse nel modello. Il modello definisce la sintassi che puoi utilizzare e la relativa modalità di elaborazione. È inoltre possibile utilizzare la `AWS::Include` trasformazione per includere frammenti di modello archiviati separatamente dal modello principale. CloudFormation 

I seguenti argomenti forniscono ulteriori informazioni ed esempi per l’utilizzo di ciascuna sezione.

**Topics**
+ [Resources](resources-section-structure.md)
+ [Parameters](parameters-section-structure.md)
+ [Outputs](outputs-section-structure.md)
+ [Mappings](mappings-section-structure.md)
+ [Metadata](metadata-section-structure.md)
+ [Rules](rules-section-structure.md)
+ [Conditions](conditions-section-structure.md)
+ [Transform](transform-section-structure.md)
+ [Versione del formato](format-version-structure.md)
+ [Description](template-description-structure.md)

# CloudFormation Resourcessintassi del modello
<a name="resources-section-structure"></a>

La `Resources` sezione è una sezione obbligatoria di primo livello in un CloudFormation modello. Dichiara le AWS risorse che desideri CloudFormation fornire e configurare come parte del tuo stack.

## Sintassi
<a name="resources-section-structure-syntax"></a>

La sezione `Resources` utilizza la sintassi seguente:

### JSON
<a name="resources-section-structure-syntax.json"></a>

```
"Resources" : {
    "LogicalResourceName1" : {
        "Type" : "AWS::ServiceName::ResourceType",
        "Properties" : {
            "PropertyName1" : "PropertyValue1",
            ...
        }
    },

    "LogicalResourceName2" : {
        "Type" : "AWS::ServiceName::ResourceType",
        "Properties" : {
            "PropertyName1" : "PropertyValue1",
            ...
        }
    }
}
```

### YAML
<a name="resources-section-structure-syntax.yaml"></a>

```
Resources:
  LogicalResourceName1:
    Type: AWS::ServiceName::ResourceType
    Properties:
      PropertyName1: PropertyValue1
      ...

  LogicalResourceName2:
    Type: AWS::ServiceName::ResourceType
    Properties:
      PropertyName1: PropertyValue1
      ...
```

## ID logico (chiamato anche *nome logico*)
<a name="resources-section-logical-id"></a>

All'interno di un CloudFormation modello, le risorse sono identificate in base ai rispettivi nomi di risorse logiche. Questi nomi devono essere un valore alfanumerico (A-Z, a-z, 0-9) univoco all’interno del modello. I nomi logici vengono utilizzati per fare riferimento alle risorse di altre sezioni del modello. 

## Tipo di risorsa
<a name="resources-section-resource-type"></a>

Ogni risorsa deve avere un attributo `Type` che definisce il tipo di risorsa AWS . L’attributo `Type` ha il formato `AWS::ServiceName::ResourceType`. Ad esempio, l’attributo `Type` per un bucket Amazon S3 è `AWS::S3::Bucket`. 

Per un elenco completo dei tipi di risorse supportati, consulta [le informazioni di riferimento sui tipi di proprietà e di risorse AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-template-resource-type-ref.html).

## Proprietà delle risorse
<a name="resources-section-resource-properties"></a>

Le proprietà delle risorse sono opzioni aggiuntive che puoi specificare per definire i dettagli di configurazione per il tipo di risorsa specifico. Alcune proprietà sono obbligatorie, mentre altre sono opzionali. Alcune proprietà hanno valori predefiniti, pertanto la loro specificazione è facoltativa.

Per i dettagli sulle proprietà supportate per ogni tipo di risorsa, consulta gli argomenti nella [documentazione di riferimento dei tipi di proprietà e risorse AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-template-resource-type-ref.html).

I valori delle proprietà possono essere stringhe letterali, elenchi di stringhe, valori booleani, riferimenti dinamici, riferimenti a parametri, pseudoriferimenti oppure il valore restituito da una funzione. Gli esempi seguenti mostrano come dichiarare diversi tipi di valori di proprietà:

### JSON
<a name="resource-properties-example.json"></a>

```
"Properties" : {
    "String" : "A string value",
    "Number" : 123,
    "LiteralList" : [ "first-value", "second-value" ],
    "Boolean" : true
}
```

### YAML
<a name="resource-properties-example.yaml"></a>

```
Properties:
  String: A string value 
  Number: 123
  LiteralList:
    - first-value
    - second-value
  Boolean: true
```

## ID fisico
<a name="resources-section-physical-id"></a>

Oltre agli ID logici, alcune risorse dispongono anche di un ID fisico, che è l'effettivo nome assegnato alla risorsa, ad esempio un ID dell'istanza EC2 o un nome di bucket S3. Utilizza gli ID fisici per identificare le risorse esterne ai CloudFormation modelli, ma solo dopo che le risorse sono state create. Ad esempio, supponiamo di assegnare l'ID logico `MyEC2Instance` a una risorsa dell'istanza EC2. Quando CloudFormation crea l'istanza, genera e assegna CloudFormation automaticamente un ID fisico (ad esempio`i-1234567890abcdef0`) all'istanza. Puoi usare questo ID fisico per identificare l'istanza e visualizzare le relative proprietà (ad esempio, il nome DNS) tramite la console Amazon EC2. 

Per i bucket Amazon S3 e molte altre risorse, genera CloudFormation automaticamente un nome fisico univoco per la risorsa se non ne specifichi uno esplicitamente. Questo nome fisico si basa su una combinazione del nome dello CloudFormation stack, del nome logico della risorsa specificato nel CloudFormation modello e di un ID univoco. Ad esempio, se hai un bucket Amazon S3 con il nome logico `MyBucket` in uno stack denominato`MyStack`, CloudFormation potresti denominare il bucket con il seguente nome fisico. `MyStack-MyBucket-abcdefghijk1`

Per le risorse che supportano nomi personalizzati, puoi assegnare i nomi fisici per semplificare e velocizzare l’individuazione delle risorse. Ad esempio, puoi denominare un bucket S3 che memorizza i log con il nome `MyPerformanceLogs`. Per ulteriori informazioni, consulta [Tipo di nome](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-name.html).

## Riferimento delle risorse
<a name="using-cross-resource-references"></a>

Spesso, è necessario impostare le proprietà su una risorsa in base al nome o alla proprietà di un’altra risorsa. Ad esempio, potresti creare un'istanza EC2 che utilizza gruppi di sicurezza EC2 o una CloudFront distribuzione supportata da un bucket S3. Tutte queste risorse possono essere create nello stesso modello. CloudFormation 

CloudFormation fornisce funzioni intrinseche che è possibile utilizzare per fare riferimento ad altre risorse e alle relative proprietà. Queste funzioni consentono di creare dipendenze tra le risorse e di passare valori da una risorsa all’altra.

### La funzione `Ref`
<a name="resource-properties-ref"></a>

La `Ref` funzione viene comunemente utilizzata per recuperare una proprietà identificativa delle risorse definite all'interno dello stesso modello. CloudFormation Quello che restituisce dipende dal tipo di risorsa. Per la maggior parte delle risorse, restituisce il nome fisico della risorsa. Tuttavia, per alcuni tipi di risorse, può restituire un valore diverso, ad esempio un indirizzo IP per una risorsa `AWS::EC2::EIP` o un nome della risorsa Amazon (ARN) per un argomento Amazon SNS. 

I seguenti esempi illustrano come utilizzare la funzione `Ref` nelle proprietà. In ognuno di questi esempi, la funzione `Ref` restituirà il nome effettivo della risorsa `LogicalResourceName` dichiarata altrove nel modello. L’esempio di sintassi `!Ref` nell’esempio YAML è solo un modo più breve per scrivere la funzione `Ref`.

#### JSON
<a name="resource-properties-ref-example.json"></a>

```
"Properties" : {
    "PropertyName" : { "Ref" : "LogicalResourceName" }
}
```

#### YAML
<a name="resource-properties-ref-example.yaml"></a>

```
Properties:
  PropertyName1:
    Ref: LogicalResourceName
  PropertyName2: !Ref LogicalResourceName
```

Per ulteriori informazioni dettagliate sulla funzione `Ref`, consulta [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-ref.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-ref.html). 

### La funzione `Fn::GetAtt`
<a name="resource-properties-getatt"></a>

La funzione `Ref` è utile se il parametro o il valore restituito per una risorsa è esattamente quello che desideri. Tuttavia, possono essere necessari altri attributi di una risorsa. Ad esempio, se desideri creare una CloudFront distribuzione con un'origine S3, devi specificare la posizione del bucket utilizzando un indirizzo in stile DNS. Una serie di risorse dispongono di attributi aggiuntivi i cui valori possono essere utilizzati nel modello. Per ottenere questi attributi, utilizza la funzione `Fn::GetAtt`.

I seguenti esempi illustrano come utilizzare la funzione `GetAtt` nelle proprietà. La funzione `Fn::GetAtt` utilizza due parametri, il nome logico della risorsa e il nome dell’attributo da recuperare. L’esempio di sintassi `!GetAtt` nell’esempio YAML è solo un modo più breve per scrivere la funzione `GetAtt`.

#### JSON
<a name="resource-properties-getatt-example.json"></a>

```
"Properties" : {
    "PropertyName" : {
        "Fn::GetAtt" : [ "LogicalResourceName", "AttributeName" ]
    }
}
```

#### YAML
<a name="resource-properties-getatt-example.yaml"></a>

```
Properties:
  PropertyName1:
    Fn::GetAtt:
      - LogicalResourceName
      - AttributeName
  PropertyName2: !GetAtt LogicalResourceName.AttributeName
```

Per ulteriori informazioni dettagliate sulla funzione `GetAtt`, consulta [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-getatt.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-getatt.html).

## Esempi
<a name="resources-section-structure-examples"></a>

Gli esempi seguenti illustrano come dichiarare le risorse e come i CloudFormation modelli possono fare riferimento ad altre risorse definite all'interno dello stesso modello e delle risorse esistenti. AWS 

**Topics**
+ [Dichiarazione di una singola risorsa con un nome personalizzato](#resources-section-structure-examples-single-resource)
+ [Riferimento ad altre risorse con la funzione `Ref`](#resources-section-structure-examples-ref)
+ [Riferimento agli attributi delle risorse utilizzando la funzione `Fn::GetAtt`](#resources-section-structure-examples-getatt)

### Dichiarazione di una singola risorsa con un nome personalizzato
<a name="resources-section-structure-examples-single-resource"></a>

Gli esempi seguenti dichiarano una singola risorsa di tipo `AWS::S3::Bucket` con il nome logico `MyBucket`. La proprietà `BucketName` è impostata su *amzn-s3-demo-bucket*, che deve essere sostituita con il nome desiderato per il bucket S3.

Se utilizzi questa dichiarazione di risorse per creare uno stack, CloudFormation creerà un bucket Amazon S3 con impostazioni predefinite. Per altre risorse, come un'istanza Amazon EC2 o un gruppo Auto Scaling CloudFormation , sono necessarie ulteriori informazioni.

#### JSON
<a name="resources-section-structure-examples-single-resource.json"></a>

```
{
    "Resources": {
        "MyBucket": {
            "Type": "AWS::S3::Bucket",
            "Properties": {
                "BucketName": "amzn-s3-demo-bucket"
            }
        }
    }
}
```

#### YAML
<a name="resources-section-structure-examples-single-resource.yaml"></a>

```
Resources:
  MyBucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: amzn-s3-demo-bucket
```

### Riferimento ad altre risorse con la funzione `Ref`
<a name="resources-section-structure-examples-ref"></a>

Gli esempi seguenti mostrano una dichiarazione di risorse che definisce un’istanza EC2 e un gruppo di sicurezza. La risorsa `Ec2Instance` fa riferimento alla risorsa `InstanceSecurityGroup` come parte della proprietà `SecurityGroupIds` utilizzando la funzione `Ref`. Include anche un gruppo di sicurezza esistente (`sg-12a4c434`) che non è dichiarato nel modello. Utilizza stringhe letterali per fare riferimento alle risorse AWS esistenti.

#### JSON
<a name="resources-section-structure-examples-ref.json"></a>

```
{
    "Resources": {
        "Ec2Instance": {
            "Type": "AWS::EC2::Instance",
            "Properties": {
                "SecurityGroupIds": [
                    {
                        "Ref": "InstanceSecurityGroup"
                    },
                    "sg-12a4c434"
                ],
                "KeyName": "MyKey",
                "ImageId": "ami-1234567890abcdef0"
            }
        },
        "InstanceSecurityGroup": {
            "Type": "AWS::EC2::SecurityGroup",
            "Properties": {
                "GroupDescription": "Enable SSH access via port 22",
                "SecurityGroupIngress": [
                    {
                        "IpProtocol": "tcp",
                        "FromPort": 22,
                        "ToPort": 22,
                        "CidrIp": "0.0.0.0/0"
                    }
                ]
            }
        }
    }
}
```

#### YAML
<a name="resources-section-structure-examples-ref.yaml"></a>

```
Resources:
  Ec2Instance:
    Type: AWS::EC2::Instance
    Properties:
      SecurityGroupIds:
        - !Ref InstanceSecurityGroup
        - sg-12a4c434
      KeyName: MyKey
      ImageId: ami-1234567890abcdef0
  InstanceSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Enable SSH access via port 22
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: 22
          ToPort: 22
          CidrIp: 0.0.0.0/0
```

### Riferimento agli attributi delle risorse utilizzando la funzione `Fn::GetAtt`
<a name="resources-section-structure-examples-getatt"></a>

Gli esempi seguenti mostrano una dichiarazione di risorsa che definisce una risorsa di CloudFront distribuzione e un bucket S3. La risorsa `MyDistribution` specifica il nome DNS della risorsa `MyBucket` utilizzando la funzione `Fn::GetAtt` per ottenere l’attributo del bucket `DomainName`. Noterai che la funzione `Fn::GetAtt` elenca i suoi due parametri in un array. Per le funzioni che richiedono più parametri, puoi utilizzare un array per specificare i parametri.

#### JSON
<a name="resources-section-structure-examples-getatt.json"></a>

```
{
  "Resources": {
    "MyBucket": {
      "Type": "AWS::S3::Bucket"
    },
    "MyDistribution": {
      "Type": "AWS::CloudFront::Distribution",
      "Properties": {
        "DistributionConfig": {
          "Origins": [
            {
              "DomainName": {
                "Fn::GetAtt": [
                  "MyBucket",
                  "DomainName"
                ]
              },
              "Id": "MyS3Origin",
              "S3OriginConfig": {}
            }
          ],
          "Enabled": "true",
          "DefaultCacheBehavior": {
            "TargetOriginId": "MyS3Origin",
            "ForwardedValues": {
              "QueryString": "false"
            },
            "ViewerProtocolPolicy": "allow-all"
          }
        }
      }
    }
  }
}
```

#### YAML
<a name="resources-section-structure-examples-getatt.yaml"></a>

```
Resources:
  MyBucket:
    Type: AWS::S3::Bucket
  MyDistribution:
    Type: AWS::CloudFront::Distribution
    Properties:
      DistributionConfig:
        Origins:
          - DomainName: !GetAtt 
              - MyBucket
              - DomainName
            Id: MyS3Origin
            S3OriginConfig: {}
        Enabled: 'true'
        DefaultCacheBehavior:
          TargetOriginId: MyS3Origin
          ForwardedValues:
            QueryString: 'false'
          ViewerProtocolPolicy: allow-all
```

# CloudFormation Parameterssintassi del modello
<a name="parameters-section-structure"></a>

Utilizza la sezione `Parameters` opzionale per personalizzare i modelli. Con i parametri, puoi immettere valori personalizzati nel modello ogni volta che crei o aggiorni uno stack. Utilizzando i parametri nei modelli puoi creare modelli riutilizzabili e flessibili che possono essere adattati a scenari specifici. 

Definendo i parametri del tipo appropriato, puoi scegliere da un elenco di identificatori di risorse esistenti quando utilizzi la console per creare il tuo stack. Per ulteriori informazioni, consulta [Specificare le risorse esistenti in fase di esecuzione con i CloudFormation tipi di parametri forniti da](cloudformation-supplied-parameter-types.md).

I parametri sono un metodo comune per specificare i valori delle proprietà delle risorse dello stack. Tuttavia, potrebbero esservi impostazioni dipendenti dalla regione o che gli utenti trovano complessi da individuare a causa di altre condizioni o dipendenze. In questi casi, potresti aggiungere la logica nel modello stesso, in modo che gli utenti possano specificare valori più semplici (o nessuno) per ottenere i risultati desiderati. Per ulteriori informazioni, consulta [CloudFormation Mappingssintassi del modello](mappings-section-structure.md).

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

Puoi dichiarare i parametri nella sezione `Parameters` di un modello, che utilizza la seguente sintassi generale:

### JSON
<a name="parameters-section-structure-syntax.json"></a>

```
"Parameters" : {
  "ParameterLogicalID" : {
    "Description": "Information about the parameter",
    "Type" : "DataType",
    "Default" : "value",
    "AllowedValues" : ["value1", "value2"]
  }
}
```

### YAML
<a name="parameters-section-structure-syntax.yaml"></a>

```
Parameters:
  ParameterLogicalID:
    Description: Information about the parameter
    Type: DataType
    Default: value
    AllowedValues:
      - value1
      - value2
```

Un parametro contiene un elenco di attributi che definiscono il valore e i vincoli rispetto al valore. L'unico attributo richiesto è`Type`, che può essere `String``Number`, o un tipo CloudFormation di parametro fornito. Puoi anche aggiungere un attributo `Description` che descrive il tipo di valore che devi specificare. Il nome e la descrizione del parametro appaiono nella pagina **Specifica parametri** quando utilizzi il modello nella procedura guidata **Creazione di stack**.

**Nota**  
Per impostazione predefinita, la CloudFormation console elenca i parametri di input in ordine alfabetico in base al relativo ID logico. Per ignorare questo ordinamento predefinito e raggruppare i parametri correlati, puoi utilizzare la chiave `AWS::CloudFormation::Interface` dei metadati nel tuo modello. Per ulteriori informazioni, consulta [Organizzazione CloudFormation dei parametri con `AWS::CloudFormation::Interface` metadati](aws-cloudformation-interface.md).

Per i parametri con valori predefiniti, CloudFormation utilizza i valori predefiniti a meno che gli utenti non specifichino un altro valore. Se ometti l’attributo predefinito, gli utenti devono specificare un valore per il parametro. Tuttavia, richiedere all’utente di immettere un valore non garantisce che il valore sia valido. Per convalidare il valore di un parametro, potete dichiarare vincoli o specificare un AWS tipo di parametro specifico.

Per i parametri senza valori predefiniti, gli utenti devono specificare un valore del nome della chiave al momento della creazione dello stack. In caso contrario, non CloudFormation riesce a creare lo stack e genera un'eccezione:

```
Parameters: [KeyName] must have values
```

## Properties
<a name="parameters-section-structure-properties"></a>

`AllowedPattern`  
Una espressione regolare che rappresenta i modelli da consentire per i tipi `String` o `CommaDelimitedList`. Se applicato su un parametro di tipo `String`, lo schema deve corrispondere all’intero valore del parametro fornito. Quando viene applicato a un parametro di tipo `CommaDelimitedList`, il modello deve corrispondere a ciascun valore nell’elenco.  
*Obbligatorio:* no

`AllowedValues`  
Matrice contenente l’elenco dei valori consentiti per il parametro. Quando viene applicato a un parametro di tipo `String`, il valore del parametro deve essere uno dei valori consentiti. Quando viene applicato a un parametro di tipo `CommaDelimitedList`, ogni valore nell’elenco deve essere uno dei valori consentiti.  
*Obbligatorio:* no  
Se utilizzi YAML e desideri utilizzare le stringhe `Yes` e `No` per `AllowedValues`, utilizza le virgolette singole per evitare che il parser YAML consideri questi valori booleani.

`ConstraintDescription`  
Stringa che illustra un vincolo in caso di violazione del vincolo. Ad esempio, senza una descrizione del vincolo, un parametro associato al modello consentito `[A-Za-z0-9]+` restituisce il seguente messaggio di errore quando l’utente specifica un valore non valido:  
`Malformed input-Parameter MyParameter must match pattern [A-Za-z0-9]+`  
Se aggiungi una descrizione del vincolo, ad esempio *must only contain letters (uppercase and lowercase) and number (solo lettere (maiuscole e minuscole) e numeri)*, puoi visualizzare il seguente messaggio di errore personalizzato:  
`Malformed input-Parameter MyParameter must only contain uppercase and lowercase letters and numbers`  
*Obbligatorio:* no

`Default`  
Valore del tipo appropriato per il modello da utilizzare se non viene specificato alcun valore al momento della creazione di uno stack. Se per il parametro definisci vincoli, devi specificare un valore conforme a tali vincoli.  
*Obbligatorio:* no

`Description`  
Stringa contenente un massimo di 4.000 caratteri che descrive il parametro.  
*Obbligatorio:* no

`MaxLength`  
Valore intero che determina il numero massimo di caratteri consentiti per i tipi `String`.  
*Obbligatorio:* no

`MaxValue`  
Valore numerico che determina il valore numerico massimo consentito per i tipi `Number`.  
*Obbligatorio:* no

`MinLength`  
Valore intero che determina il numero minimo di caratteri consentiti per i tipi `String`.  
*Obbligatorio:* no

`MinValue`  
Valore numerico che determina il valore numerico minimo consentito per i tipi `Number`.  
*Obbligatorio:* no

`NoEcho`  
Indica se mascherare il valore del parametro per impedirne la visualizzazione nella console, negli strumenti a riga di comando o nell’API. Se impostate l'`NoEcho`attributo su`true`, CloudFormation restituisce il valore del parametro mascherato da asterischi (\$1\$1\$1\$1\$1) per tutte le chiamate che descrivono lo stack o gli eventi dello stack, ad eccezione delle informazioni memorizzate nelle posizioni specificate di seguito.  
*Obbligatorio:* no  
L’utilizzo dell’attributo `NoEcho` non maschera le informazioni memorizzate nei seguenti elementi:  
+ La sezione dei modelli. `Metadata` CloudFormation non trasforma, modifica o oscura le informazioni incluse nella `Metadata` sezione. Per ulteriori informazioni, vedere [Metadati](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/metadata-section-structure.html).
+ Sezione dei modelli `Outputs`. Per ulteriori informazioni, consulta [Output](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/outputs-section-structure.html).
+ Attributo `Metadata` di una definizione di risorsa. Per ulteriori informazioni, consulta [Attributo `Metadata`](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-metadata.html).
Si consiglia vivamente di non utilizzare questi meccanismi per includere informazioni sensibili, come password o segreti.
Anziché incorporare informazioni riservate direttamente nei CloudFormation modelli, consigliamo di utilizzare parametri dinamici nel modello di pila per fare riferimento a informazioni sensibili archiviate e gestite all'esterno CloudFormation, ad esempio nel AWS Systems Manager Parameter Store o. Gestione dei segreti AWS  
Per ulteriori informazioni, consulta la best practice [Non incorporare le credenziali nei modelli](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/security-best-practices.html#creds).
Consigliamo vivamente di non includere parametri `NoEcho` o dati sensibili, nelle proprietà delle risorse che fanno parte dell’identificatore principale di una risorsa.  
Quando un `NoEcho` parametro è incluso in una proprietà che costituisce un identificatore di risorsa principale, CloudFormation può utilizzare il *valore effettivo in chiaro nell'identificatore* della risorsa principale. Questo ID risorsa può apparire in qualsiasi output o destinazione derivata.  
Per determinare quali proprietà delle risorse comprendono l’identificatore principale di un tipo di risorsa, consulta la documentazione di riferimento delle risorse per la risorsa in questione in [AWS resource and property types reference](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-template-resource-type-ref.html). Nella sezione **Return values** (Valori restituiti), il valore restituito della funzione `Ref` rappresenta le proprietà delle risorse che comprendono l’identificatore principale del tipo di risorsa.

`Type`  <a name="parameters-section-structure-properties-type"></a>
Tipo di dati per il parametro (`DataType`).  
*Obbligatorio:* sì  
CloudFormation supporta i seguenti tipi di parametri:    
`String`  
Stringa letterale. Puoi utilizzare i seguenti attributi per dichiarare i vincoli: `MinLength`, `MaxLength`, `Default`, `AllowedValues` e `AllowedPattern`.   
Ad esempio, gli utenti possono specificare `"MyUserName"`.  
`Number`  
Un numero intero o float. CloudFormation convalida il valore del parametro come numero; tuttavia, quando si utilizza il parametro altrove nel modello (ad esempio, utilizzando la funzione `Ref` intrinseca), il valore del parametro diventa una stringa.  
Puoi utilizzare i seguenti attributi per dichiarare i vincoli: `MinValue`, `MaxValue`, `Default` e `AllowedValues`.  
Ad esempio, gli utenti possono specificare `"8888"`.  
`List<Number>`  
Matrice di numeri interi o float separati da virgole. CloudFormation convalida il valore del parametro come numeri. Tuttavia, quando utilizzi il parametro in una posizione diversa nel modello (ad esempio, utilizzando la funzione intrinseca `Ref`), il valore del parametro diventa un elenco di stringhe.  
Ad esempio, gli utenti possono specificare `"80,20"` e `Ref` restituisce `["80","20"]`.  
`CommaDelimitedList`  
Matrice di stringhe letterali separate da virgole. Il numero totale di stringhe deve corrispondere al numero totale di virgole più uno. Ogni stringa membro non deve includere spazi.  
Ad esempio, gli utenti possono specificare `"test,dev,prod"` e `Ref` restituisce `["test","dev","prod"]`.  
Tipi di parametri specifici per AWS  
AWS valori come i nomi delle coppie di chiavi Amazon EC2 e il VPC. IDs Per ulteriori informazioni, consulta [Specifica delle risorse esistenti in fase di runtime](cloudformation-supplied-parameter-types.md).  
Tipi di parametro di Systems Manager  
Parametri che corrispondono ai parametri esistenti in Archivio parametri Systems Manager. Si specifica una chiave del parametro Systems Manager come valore del tipo di parametro Systems Manager e si CloudFormation recupera il valore più recente da Parameter Store da utilizzare per lo stack. Per ulteriori informazioni, consulta [Specifica delle risorse esistenti in fase di runtime](cloudformation-supplied-parameter-types.md).

## Requisiti generali per i parametri
<a name="parameters-section-structure-requirements"></a>

Per l’utilizzo dei parametri sono validi i seguenti requisiti:
+ È possibile avere un massimo di 200 parametri in un CloudFormation modello.
+ A ogni parametro deve essere assegnato un nome logico (definito anche ID logico), che deve essere alfanumerico e univoco rispetto a tutti i nomi logici all’interno del modello.
+ A ogni parametro deve essere assegnato un tipo di parametro supportato da CloudFormation. Per ulteriori informazioni, consulta la sezione [Type](#parameters-section-structure-properties-type).
+ A ogni parametro deve essere assegnato un valore in fase di esecuzione per CloudFormation effettuare correttamente il provisioning dello stack. Facoltativamente, è possibile specificare un valore predefinito CloudFormation da utilizzare a meno che non venga fornito un altro valore.
+ I parametri e i relativi riferimenti a essi devono essere dichiarati dall’interno dello stesso modello. Puoi fare riferimento ai parametri dalle sezioni `Resources` e `Outputs` del modello.

## Esempi
<a name="parameters-section-examples"></a>

**Topics**
+ [Parametro stringa semplice](#parameters-section-structure-example-1)
+ [Parametro password](#parameters-section-structure-example-2)
+ [Riferimento dei parametri](#parameters-section-structure-example-3)
+ [Parametro elenco definito da virgole](#parameters-section-structure-example-4)
+ [Restituzione un valore da un parametro CommaDelimitedList](#parameters-section-structure-example-5)

### Parametro stringa semplice
<a name="parameters-section-structure-example-1"></a>

L’esempio seguente dichiara un parametro denominato `InstanceTypeParameter` di tipo `String`. Questo parametro consente di specificare il tipo di istanza Amazon EC2 per lo stack. Se non viene fornito alcun valore durante la creazione o l'aggiornamento dello stack, CloudFormation utilizza il valore predefinito di. `t2.micro`

#### JSON
<a name="parameters-section-structure-example-1.json"></a>

```
"Parameters" : {
  "InstanceTypeParameter" : {
    "Description" : "Enter t2.micro, m1.small, or m1.large. Default is t2.micro.",
    "Type" : "String",
    "Default" : "t2.micro",
    "AllowedValues" : ["t2.micro", "m1.small", "m1.large"]
  }
}
```

#### YAML
<a name="parameters-section-structure-example-1.yaml"></a>

```
Parameters:
  InstanceTypeParameter:
    Description: Enter t2.micro, m1.small, or m1.large. Default is t2.micro.
    Type: String
    Default: t2.micro
    AllowedValues:
      - t2.micro
      - m1.small
      - m1.large
```

### Parametro password
<a name="parameters-section-structure-example-2"></a>

L’esempio seguente dichiara un parametro denominato `DBPwd` di tipo `String` senza valore predefinito. La proprietà `NoEcho` è impostata su `true` per impedire che il valore del parametro venga visualizzato nelle descrizioni degli stack. La lunghezza minima che può essere specificata è `1`e la lunghezza massima che può essere specificata è `41`. Il modello consente l’uso di caratteri alfabetici in maiuscolo e minuscolo e di numeri. Questo esempio illustra anche l’uso di un’espressione regolare per la proprietà `AllowedPattern`.

#### JSON
<a name="parameters-section-structure-example-2.json"></a>

```
"Parameters" : {
  "DBPwd" : {
    "NoEcho" : "true",
    "Description" : "The database admin account password",
    "Type" : "String",
    "MinLength" : "1",
    "MaxLength" : "41",
    "AllowedPattern" : "^[a-zA-Z0-9]*$"
  }
}
```

#### YAML
<a name="parameters-section-structure-example-2.yaml"></a>

```
Parameters: 
  DBPwd: 
    NoEcho: true
    Description: The database admin account password
    Type: String
    MinLength: 1
    MaxLength: 41
    AllowedPattern: ^[a-zA-Z0-9]*$
```

### Riferimento dei parametri
<a name="parameters-section-structure-example-3"></a>

Puoi utilizzare la funzione intrinseca `Ref` per fare riferimento a un parametro. CloudFormation utilizza il valore del parametro per effettuare il provisioning dello stack. Puoi fare riferimento ai parametri dalle sezioni `Resources` e `Outputs` dello stesso modello.

In questo esempio, la proprietà `InstanceType` della risorsa dell’istanza EC2 fa riferimento al valore del parametro `InstanceTypeParameter`:

#### JSON
<a name="parameters-section-structure-example-3.json"></a>

```
"Ec2Instance" : {
  "Type" : "AWS::EC2::Instance",
  "Properties" : {
    "InstanceType" : { "Ref" : "InstanceTypeParameter" },
    "ImageId" : "ami-0ff8a91507f77f867"
  }
}
```

#### YAML
<a name="parameters-section-structure-example-3.yaml"></a>

```
Ec2Instance:
  Type: AWS::EC2::Instance
  Properties:
    InstanceType:
      Ref: InstanceTypeParameter
    ImageId: ami-0ff8a91507f77f867
```

### Parametro elenco definito da virgole
<a name="parameters-section-structure-example-4"></a>

Il parametro di tipo `CommaDelimitedList` può essere utile quando è necessario fornire più valori per una singola proprietà. L’esempio seguente dichiara un parametro denominato `DbSubnetIpBlocks` con un valore predefinito di tre intervalli CIDR separati da virgole.

#### JSON
<a name="parameters-section-structure-example-4.json"></a>

```
"Parameters" : {
  "DbSubnetIpBlocks": {
    "Description": "Comma-delimited list of three CIDR blocks",
    "Type": "CommaDelimitedList",
    "Default": "10.0.48.0/24, 10.0.112.0/24, 10.0.176.0/24"
  }
}
```

#### YAML
<a name="parameters-section-structure-example-4.yaml"></a>

```
Parameters: 
  DbSubnetIpBlocks: 
    Description: "Comma-delimited list of three CIDR blocks"
    Type: CommaDelimitedList
    Default: "10.0.48.0/24, 10.0.112.0/24, 10.0.176.0/24"
```

### Restituzione un valore da un parametro CommaDelimitedList
<a name="parameters-section-structure-example-5"></a>

Per fare riferimento a un valore specifico in un elenco, utilizza la funzione intrinseca `Fn::Select` nella sezione `Resources` del modello. Puoi trasmettere il valore di indice dell’oggetto desiderato e un elenco di oggetti, come mostrato nell’esempio seguente.

#### JSON
<a name="parameters-section-structure-example-5.json"></a>

```
{
    "Parameters": {
        "VPC": {
            "Type": "String",
            "Default": "vpc-123456"
        },
        "VpcAzs": {
            "Type": "CommaDelimitedList",
            "Default": "us-west-2a, us-west-2b, us-west-2c"
        },
        "DbSubnetIpBlocks": {
            "Type": "CommaDelimitedList",
            "Default": "172.16.0.0/26, 172.16.0.64/26, 172.16.0.128/26"
        }
    },
    "Resources": {
        "DbSubnet1": {
            "Type": "AWS::EC2::Subnet",
            "Properties": {
                "AvailabilityZone": {
                    "Fn::Select": [
                      0,
                      { 
                        "Ref": "VpcAzs" 
                      }
                   ]
                },
                "VpcId": {
                    "Ref": "VPC"
                },
                "CidrBlock": {
                    "Fn::Select": [
                        0,
                        { "Ref": "DbSubnetIpBlocks" }
                    ]
                }
            }
        },
        "DbSubnet2": {
            "Type": "AWS::EC2::Subnet",
            "Properties": {
                "AvailabilityZone": {
                    "Fn::Sub": [
                        "${AWS::Region}${AZ}",
                        {
                            "AZ": {
                                "Fn::Select": [
                                    1,
                                    { "Ref": "VpcAzs" }
                                ]
                            }
                        }
                    ]
                },
                "VpcId": {
                    "Ref": "VPC"
                },
                "CidrBlock": {
                    "Fn::Select": [
                        1,
                        { "Ref": "DbSubnetIpBlocks" }
                    ]
                }
            }
        },
        "DbSubnet3": {
            "Type": "AWS::EC2::Subnet",
            "Properties": {
                "AvailabilityZone": {
                    "Fn::Sub": [
                        "${AWS::Region}${AZ}",
                        {
                            "AZ": {
                                "Fn::Select": [
                                    2,
                                    { "Ref": "VpcAzs" }
                                ]
                            }
                        }
                    ]
                },
                "VpcId": {
                    "Ref": "VPC"
                },
                "CidrBlock": {
                    "Fn::Select": [
                        2,
                        { "Ref": "DbSubnetIpBlocks" }
                    ]
                }
            }
        }
    }
}
```

#### YAML
<a name="parameters-section-structure-example-5.yaml"></a>

```
Parameters:
  VPC:
    Type: String
    Default: vpc-123456
  VpcAzs:
    Type: CommaDelimitedList
    Default: us-west-2a, us-west-2b, us-west-2c
  DbSubnetIpBlocks:
    Type: CommaDelimitedList
    Default: 172.16.0.0/26, 172.16.0.64/26, 172.16.0.128/26
Resources:
  DbSubnet1:
    Type: AWS::EC2::Subnet
    Properties:
      AvailabilityZone: !Select
        - 0 
        - !Ref VpcAzs
      VpcId: !Ref VPC
      CidrBlock: !Select
        - 0
        - !Ref DbSubnetIpBlocks
  DbSubnet2:
    Type: AWS::EC2::Subnet
    Properties:
      AvailabilityZone: !Sub
        - ${AWS::Region}${AZ}
        - AZ: !Select
            - 1
            - !Ref VpcAzs
      VpcId: !Ref VPC
      CidrBlock: !Select
        - 1
        - !Ref DbSubnetIpBlocks
  DbSubnet3:
    Type: AWS::EC2::Subnet
    Properties:
      AvailabilityZone: !Sub
        - ${AWS::Region}${AZ}
        - AZ: !Select
            - 2
            - !Ref VpcAzs
      VpcId: !Ref VPC
      CidrBlock: !Select
        - 2
        - !Ref DbSubnetIpBlocks
```

## Risorse correlate
<a name="parameters-section-structure-related-resources"></a>

CloudFormation supporta anche l'uso di riferimenti dinamici per specificare dinamicamente i valori delle proprietà. Ad esempio, potrebbe essere necessario fare riferimento di stringhe sicure archiviate in Systems Manager Parameter Store. Per ulteriori informazioni, consulta [Ottenimento di valori archiviati in altri servizi utilizzando riferimenti dinamici](dynamic-references.md).

Puoi inoltre utilizzare gli pseudo parametri all’interno di una funzione `Ref` o `Sub` per compilare dinamicamente i valori. Per ulteriori informazioni, consulta [Ottieni AWS valori usando pseudo parametri](pseudo-parameter-reference.md). 

# CloudFormation Outputssintassi del modello
<a name="outputs-section-structure"></a>

La sezione `Outputs` facoltativa dichiara i valori di output per lo stack. Questi valori di output possono essere utilizzati in vari modi:
+ **Acquisizione di informazioni importanti sulle risorse**: un output è un modo pratico di acquisire informazioni importanti sulle risorse. Ad esempio, è puoi restituire l’output di un nome di bucket S3 per uno stack per semplificare la ricerca del bucket. È possibile visualizzare i valori di output nella scheda **Output** della CloudFormation console o utilizzando il comando [describe-stacks](service_code_examples.md#describe-stacks-sdk)CLI. 
+ **Riferimenti tra stack**: puoi importare valori di output in altri stack per [creare riferimenti tra stack](using-cfn-stack-exports.md). Questa funzione è utile quando devi condividere risorse o configurazioni su più stack.

**Importante**  
CloudFormation non oscura o offusca le informazioni incluse nella sezione. `Outputs` Ti consigliamo vivamente di non utilizzare questa sezione per generare informazioni riservate, ad esempio password o segreti.  
I valori di output sono disponibili al termine dell’operazione dello stack. I valori di output dello stack non sono disponibili quando lo stato dello stesso è in uno degli [stati](view-stack-events.md#cfn-console-view-stack-data-resources-status-codes) `IN_PROGRESS`. Si sconsiglia di stabilire dipendenze tra un runtime del servizio e il valore di output dello stack, poiché i valori di output potrebbero non essere sempre disponibili.

## Sintassi
<a name="outputs-section-syntax"></a>

La sezione `Outputs` è composta dal nome di chiave `Outputs`. Puoi dichiarare un massimo di 200 output in un modello.

L’esempio seguente mostra la struttura della sezione `Outputs`.

### JSON
<a name="outputs-section-structure-syntax.json"></a>

Usa le parentesi graffe per racchiudere tutte le dichiarazioni degli output. Delimita più output con virgole.

```
"Outputs" : {
  "OutputLogicalID" : {
    "Description" : "Information about the value",
    "Value" : "Value to return",
    "Export" : {
      "Name" : "Name of resource to export"
    }
  }
}
```

### YAML
<a name="outputs-section-structure-syntax.yaml"></a>

```
Outputs:
  OutputLogicalID:
    Description: Information about the value
    Value: Value to return
    Export:
      Name: Name of resource to export
```

### Campi di output
<a name="outputs-section-structure-output-fields"></a>

La sezione `Outputs` può includere i seguenti campi.

**ID logico (chiamato anche *nome logico*)**  
Identificatore per l’output corrente. L’ID logico deve essere un valore alfanumerico (`a–z`, `A–Z`, `0–9`) univoco all’interno del modello.

**`Description` (facoltativo)**  
Tipo `String` che descrive il valore di output. Il valore della dichiarazione della descrizione deve essere una stringa letterale con una lunghezza compresa tra 0 e 1024 byte. Per specificare la descrizione non è possibile utilizzare un parametro o una funzione. 

**`Value`(richiesto)**  
Valore della proprietà restituita dal comando [describe-stacks](service_code_examples.md#describe-stacks-sdk). Il valore di un output può includere valori letterali, riferimenti a parametri, pseudo parametri, un valore di mappatura o funzioni intrinseche.

**`Export` (facoltativo)**  
Nome dell’output della risorsa da esportare in un riferimento tra stack.  
Puoi utilizzare le funzioni intrinseche per personalizzare il valore `Name` di un’esportazione.  
Per ulteriori informazioni, consulta [Ottieni gli output esportati da uno stack distribuito CloudFormation](using-cfn-stack-exports.md).

Per associare una condizione a un output, definisci la condizione nella sezione [Conditions](conditions-section-structure.md) del modello.

## Esempi
<a name="outputs-section-structure-examples"></a>

Negli esempi seguenti viene illustrato il funzionamento dell’output dello stack.

**Topics**
+ [Output dello stack](#outputs-section-structure-examples-stack-output)
+ [Personalizzazione del nome di esportazione con l’utilizzo di `Fn::Sub`](#outputs-section-structure-examples-cross-stack)
+ [Personalizzazione del nome di esportazione con l’utilizzo di `Fn::Join`](#outputs-section-structure-examples-join-export-name)
+ [Restituzione di un URL costruito utilizzando `Fn::Join`](#outputs-section-structure-examples-join-export-url)

### Output dello stack
<a name="outputs-section-structure-examples-stack-output"></a>

In questo esempio, l’output denominato `BackupLoadBalancerDNSName` restituisce il nome DNS della risorsa con l’ID logico `BackupLoadBalancer` solo quando la condizione `CreateProdResources` è vera. L’output denominato `InstanceID` restituisce l’ID dell’istanza EC2 con l’ID logico `EC2Instance`.

#### JSON
<a name="outputs-section-structure-example.json"></a>

```
"Outputs" : {
  "BackupLoadBalancerDNSName" : {
    "Description": "The DNSName of the backup load balancer",  
    "Value" : { "Fn::GetAtt" : [ "BackupLoadBalancer", "DNSName" ]},
    "Condition" : "CreateProdResources"
  },
  "InstanceID" : {
    "Description": "The Instance ID",  
    "Value" : { "Ref" : "EC2Instance" }
  }
}
```

#### YAML
<a name="outputs-section-structure-example.yaml"></a>

```
Outputs:
  BackupLoadBalancerDNSName:
    Description: The DNSName of the backup load balancer
    Value: !GetAtt BackupLoadBalancer.DNSName
    Condition: CreateProdResources
  InstanceID:
    Description: The Instance ID
    Value: !Ref EC2Instance
```

### Personalizzazione del nome di esportazione con l’utilizzo di `Fn::Sub`
<a name="outputs-section-structure-examples-cross-stack"></a>

In questo esempio, l’output denominato `StackVPC` restituisce l’ID di un VPC, quindi esporta il valore dei riferimenti tra stack con il nome `VPCID` aggiunto alla fine del nome dello stack.

#### JSON
<a name="outputs-section-structure-cross-stack-example.json"></a>

```
"Outputs" : {
  "StackVPC" : {
    "Description" : "The ID of the VPC",
    "Value" : { "Ref" : "MyVPC" },
    "Export" : {
      "Name" : {"Fn::Sub": "${AWS::StackName}-VPCID" }
    }
  }
}
```

#### YAML
<a name="outputs-section-structure-cross-stack-example.yaml"></a>

```
Outputs:
  StackVPC:
    Description: The ID of the VPC
    Value: !Ref MyVPC
    Export:
      Name: !Sub "${AWS::StackName}-VPCID"
```

Per ulteriori informazioni sulla funzione `Fn::Sub`, consulta [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-sub.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-sub.html).

### Personalizzazione del nome di esportazione con l’utilizzo di `Fn::Join`
<a name="outputs-section-structure-examples-join-export-name"></a>

Puoi anche utilizzare la funzione `Fn::Join` per creare valori in base a parametri, attributi delle risorse e altre stringhe.

Gli esempi seguenti utilizzano la funzione `Fn::Join` per personalizzare il nome di esportazione anziché la funzione `Fn::Sub`. La funzione `Fn::Join` di esempio concatena il nome dello stack con il nome `VPCID` utilizzando i due punti come separatore.

#### JSON
<a name="outputs-section-structure-join-export-name-example.json"></a>

```
"Outputs" : {
  "StackVPC" : {
    "Description" : "The ID of the VPC",
    "Value" : { "Ref" : "MyVPC" },
    "Export" : {
      "Name" : { "Fn::Join" : [ ":", [ { "Ref" : "AWS::StackName" }, "VPCID" ] ] }
    }
  }
}
```

#### YAML
<a name="outputs-section-structure-join-export-name-example.yaml"></a>

```
Outputs:
  StackVPC:
    Description: The ID of the VPC
    Value: !Ref MyVPC
    Export:
      Name: !Join [ ":", [ !Ref "AWS::StackName", VPCID ] ]
```

Per ulteriori informazioni sulla funzione `Fn::Join`, consulta [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-join.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-join.html).

### Restituzione di un URL costruito utilizzando `Fn::Join`
<a name="outputs-section-structure-examples-join-export-url"></a>

Nell'esempio seguente, per un modello che crea un WordPress sito, `InstallURL` è la stringa restituita da una chiamata di `Fn::Join` funzione che concatena`http://`, il nome DNS della risorsa e. `ElasticLoadBalancer` `/wp-admin/install.php` Il valore di output dovrebbe essere simile al seguente:

```
http://mywptests-elasticl-1gb51l6sl8y5v-206169572.aws-region.elb.amazonaws.com/wp-admin/install.php
```

#### JSON
<a name="outputs-section-structure-examples-join-export-url.json"></a>

```
{
    "Outputs": {
        "InstallURL": {
            "Value": {
                "Fn::Join": [
                    "",
                    [
                        "http://",
                        {
                            "Fn::GetAtt": [
                                "ElasticLoadBalancer",
                                "DNSName"
                            ]
                        },
                        "/wp-admin/install.php"
                    ]
                ]
            },
            "Description": "Installation URL of the WordPress website"
        }
    }
}
```

#### YAML
<a name="outputs-section-structure-examples-join-export-url.yaml"></a>

```
Outputs:
  InstallURL:
    Value: !Join 
      - ''
      - - 'http://'
        - !GetAtt 
          - ElasticLoadBalancer
          - DNSName
        - /wp-admin/install.php
    Description: Installation URL of the WordPress website
```

Per ulteriori informazioni sulla funzione `Fn::Join`, consulta [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-join.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-join.html).

# CloudFormation Mappingssintassi del modello
<a name="mappings-section-structure"></a>

La sezione opzionale `Mappings` consente di creare coppie chiave-valore che possono essere utilizzate per specificare valori in base a determinate condizioni o dipendenze. 

Un caso d’uso comune della sezione `Mappings` consiste nell’impostare i valori in base alla Regione AWS in cui viene distribuito lo stack. Ciò può essere ottenuto utilizzando lo pseudo parametro `AWS::Region`. Lo `AWS::Region` pseudo parametro è un valore che si CloudFormation risolve nella regione in cui viene creato lo stack. Gli pseudo parametri vengono risolti entro quando si crea lo stack. CloudFormation 

Per recuperare i valori in una mappa, puoi utilizzare la funzione intrinseca `Fn::FindInMap` all’interno della sezione `Resources` del modello. 

## Sintassi
<a name="mappings-section-structure-syntax"></a>

La sezione `Mappings` utilizza la sintassi seguente:

### JSON
<a name="mappings-section-structure-syntax.json"></a>

```
"Mappings" : {
  "MappingLogicalName" : {
    "Key1" : {
      "Name" : "Value1"
    },
    "Key2" : {
      "Name" : "Value2"
    },
    "Key3" : {
      "Name" : "Value3"
    }
  }
}
```

### YAML
<a name="mappings-section-structure-syntax.yaml"></a>

```
Mappings: 
  MappingLogicalName: 
    Key1: 
      Name: Value1
    Key2: 
      Name: Value2
    Key3: 
      Name: Value3
```
+ `MappingLogicalName` è il nome logico per la mappatura.
+ All’interno della mappatura, ogni mappa è una chiave seguita da un’altra mappatura.
+ La chiave deve essere una mappa di coppie nome-valore e univoca all’interno della mappatura.
+ La coppia nome-valore è un’etichetta e il valore da mappare. Se definisci i valori, puoi mappare più di un set di valori a una chiave.
+ Le chiavi nelle mappature devono essere stringhe letterali.
+ I valori possono essere di tipo `String` o `List`.

**Nota**  
Non puoi includere parametri, pseudo parametri o funzioni intrinseche nella sezione `Mappings`.   
Se i valori in una mappatura non vengono attualmente utilizzati dal proprio stack, non è possibile aggiornare la sola mappatura. Devi includere cambiamenti che comportano l’aggiunta, la modifica o l’eliminazione delle risorse.

## Esempi
<a name="mappings-section-structure-examples"></a>

**Topics**
+ [Mappatura di base](#mappings-section-structure-basic-example)
+ [Mappatura con più valori](#mappings-section-structure-multiple-values-example)
+ [Restituzione di un valore da una mappatura](#mappings-section-structure-return-value-example)
+ [Parametro di input e `Fn::FindInMap`](#mappings-section-structure-input-parameter-example)

### Mappatura di base
<a name="mappings-section-structure-basic-example"></a>

L’esempio seguente mostra una sezione `Mappings` con una mappa `RegionToInstanceType`, che contiene cinque chiavi mappate a coppie nome-valore contenenti singoli valori stringa. Le chiavi sono i nomi di Regione. Ogni coppia nome-valore è un tipo di istanza della famiglia T disponibile nella regione rappresentata dalla chiave. Le coppie nome-valore dispongono di un nome (`InstanceType` nell’esempio) e un valore. 

#### JSON
<a name="mappings-section-structure-basic-example.json"></a>

```
"Mappings" : {
  "RegionToInstanceType" : {
    "us-east-1"      : { "InstanceType" : "t2.micro" },
    "us-west-1"      : { "InstanceType" : "t2.micro" },
    "eu-west-1"      : { "InstanceType" : "t2.micro" },
    "eu-north-1"     : { "InstanceType" : "t3.micro" },
    "me-south-1"     : { "InstanceType" : "t3.micro" }
  }
}
```

#### YAML
<a name="mappings-section-structure-basic-example.yaml"></a>

```
Mappings:
  RegionToInstanceType:
    us-east-1:
      InstanceType: t2.micro
    us-west-1:
      InstanceType: t2.micro
    eu-west-1:
      InstanceType: t2.micro
    eu-north-1:
      InstanceType: t3.micro
    me-south-1:
      InstanceType: t3.micro
```

### Mappatura con più valori
<a name="mappings-section-structure-multiple-values-example"></a>

L’esempio seguente fa riferimento a chiavi di regione mappate a due set di valori: uno denominato `MyAMI1` e l’altro `MyAMI2`.

**Nota**  
Gli AMI IDs mostrati in questi esempi sono segnaposto a scopo dimostrativo. Quando possibile, prendi in considerazione l’utilizzo di riferimenti dinamici ai parametri AWS Systems Manager come alternativa alla sezione `Mappings`. Per evitare di aggiornare tutti i modelli con un nuovo ID ogni volta che l'AMI che desideri utilizzare cambia, utilizza un AWS Systems Manager parametro per recuperare l'ID AMI più recente quando lo stack viene creato o aggiornato. Le versioni più recenti di quelle comunemente utilizzate AMIs sono disponibili anche come parametri pubblici in Systems Manager. Per ulteriori informazioni, consulta [Get values stored in other services using dynamic references](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/dynamic-references.html). 

#### JSON
<a name="mappings-section-structure-multiple-values-example"></a>

```
"Mappings" : {
  "RegionToAMI" : {
    "us-east-1"        : { "MyAMI1" : "ami-12345678901234567", "MyAMI2" : "ami-23456789012345678" },
    "us-west-1"        : { "MyAMI1" : "ami-34567890123456789", "MyAMI2" : "ami-45678901234567890" },
    "eu-west-1"        : { "MyAMI1" : "ami-56789012345678901", "MyAMI2" : "ami-67890123456789012" },
    "ap-southeast-1"   : { "MyAMI1" : "ami-78901234567890123", "MyAMI2" : "ami-89012345678901234" },
    "ap-northeast-1"   : { "MyAMI1" : "ami-90123456789012345", "MyAMI2" : "ami-01234567890123456" }
  }
}
```

#### YAML
<a name="mappings-section-structure-multiple-values-example.yaml"></a>

```
Mappings:
  RegionToAMI:
    us-east-1:
      MyAMI1: ami-12345678901234567
      MyAMI2: ami-23456789012345678
    us-west-1:
      MyAMI1: ami-34567890123456789
      MyAMI2: ami-45678901234567890
    eu-west-1:
      MyAMI1: ami-56789012345678901
      MyAMI2: ami-67890123456789012
    ap-southeast-1:
      MyAMI1: ami-78901234567890123
      MyAMI2: ami-89012345678901234
    ap-northeast-1:
      MyAMI1: ami-90123456789012345
      MyAMI2: ami-01234567890123456
```

### Restituzione di un valore da una mappatura
<a name="mappings-section-structure-return-value-example"></a>

Puoi utilizzare la funzione `Fn::FindInMap` per restituire un valore denominato in base a una chiave specificata. Il modello di esempio seguente contiene una risorsa Amazon EC2 la cui proprietà `InstanceType` viene assegnata dalla funzione `FindInMap`. La `FindInMap` funzione specifica key come Regione AWS punto in cui viene creato lo stack (utilizzando lo `AWS::Region` pseudo parametro) e `InstanceType` come nome del valore a cui mappare. `ImageId` utilizza un parametro Systems Manager per recuperare dinamicamente l’ultima AMI Amazon Linux 2. Per ulteriori informazioni sugli pseudoparametri, consulta [Ottieni AWS valori usando pseudo parametri](pseudo-parameter-reference.md).

#### JSON
<a name="mappings-section-structure-return-value-example.json"></a>

```
{
  "AWSTemplateFormatVersion" : "2010-09-09",
  "Mappings" : {
    "RegionToInstanceType" : {
      "us-east-1"      : { "InstanceType" : "t2.micro" },
      "us-west-1"      : { "InstanceType" : "t2.micro" },
      "eu-west-1"      : { "InstanceType" : "t2.micro" },
      "eu-north-1"     : { "InstanceType" : "t3.micro" },
      "me-south-1"     : { "InstanceType" : "t3.micro" }
    }
  },
  "Resources" : {
    "myEC2Instance" : {
      "Type" : "AWS::EC2::Instance",
      "Properties" : {
        "ImageId" : "{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}",
        "InstanceType" : { "Fn::FindInMap" : [ "RegionToInstanceType", { "Ref" : "AWS::Region" }, "InstanceType" ]}
      }
    }
  }
}
```

#### YAML
<a name="mappings-section-structure-return-value-example.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
Mappings: 
  RegionToInstanceType: 
    us-east-1:
      InstanceType: t2.micro
    us-west-1:
      InstanceType: t2.micro
    eu-west-1:
      InstanceType: t2.micro
    eu-north-1:
      InstanceType: t3.micro
    me-south-1:
      InstanceType: t3.micro
Resources: 
  myEC2Instance: 
    Type: AWS::EC2::Instance
    Properties: 
      ImageId: '{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}'
      InstanceType: !FindInMap [RegionToInstanceType, !Ref 'AWS::Region', InstanceType]
```

### Parametro di input e `Fn::FindInMap`
<a name="mappings-section-structure-input-parameter-example"></a>

Il seguente modello di esempio mostra come creare un’istanza EC2 utilizzando più mappature. Il modello utilizza mappature annidate per selezionare automaticamente il tipo di istanza e il gruppo di sicurezza appropriati in base alla destinazione Regione AWS e al tipo di ambiente (o). `Dev` `Prod` Utilizza anche un parametro Systems Manager per recuperare dinamicamente l’ultima AMI Amazon Linux 2.

#### JSON
<a name="mappings-section-structure-input-parameter-example.json"></a>

```
{
  "AWSTemplateFormatVersion" : "2010-09-09",
  "Parameters" : {
    "EnvironmentType" : {
      "Description" : "The environment type (Dev or Prod)",
      "Type" : "String",
      "Default" : "Dev",
      "AllowedValues" : [ "Dev", "Prod" ]
    }
  },
  "Mappings" : {
    "RegionAndEnvironmentToInstanceType" : {
      "us-east-1"        : { "Dev" : "t3.micro", "Prod" : "c5.large" },
      "us-west-1"        : { "Dev" : "t2.micro", "Prod" : "m5.large" }
    },
    "RegionAndEnvironmentToSecurityGroup" : {
      "us-east-1"        : { "Dev" : "sg-12345678", "Prod" : "sg-abcdef01" },
      "us-west-1"        : { "Dev" : "sg-ghijkl23", "Prod" : "sg-45678abc" }
    }
  },
  "Resources" : {
    "Ec2Instance" : {
      "Type" : "AWS::EC2::Instance",
      "Properties" : {
        "ImageId" : "{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}",
        "InstanceType" : { "Fn::FindInMap": [ "RegionAndEnvironmentToInstanceType", { "Ref": "AWS::Region" }, { "Ref": "EnvironmentType" } ]},
        "SecurityGroupIds" : [{ "Fn::FindInMap" : [ "RegionAndEnvironmentToSecurityGroup", { "Ref" : "AWS::Region" }, { "Ref" : "EnvironmentType" } ]}]
      }
    }
  }
}
```

#### YAML
<a name="mappings-section-structure-input-parameter-example.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
Parameters:
  EnvironmentType: 
    Description: The environment type (Dev or Prod)
    Type: String
    Default: Dev
    AllowedValues: 
      - Dev
      - Prod
Mappings:
  RegionAndEnvironmentToInstanceType:
    us-east-1: 
      Dev: t3.micro
      Prod: c5.large
    us-west-1: 
      Dev: t2.micro
      Prod: m5.large
  RegionAndEnvironmentToSecurityGroup: 
    us-east-1: 
      Dev: sg-12345678
      Prod: sg-abcdef01
    us-west-1: 
      Dev: sg-ghijkl23
      Prod: sg-45678abc
Resources:
  Ec2Instance:
    Type: AWS::EC2::Instance
    Properties:
      ImageId: '{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}'
      InstanceType: !FindInMap [RegionAndEnvironmentToInstanceType, !Ref 'AWS::Region', !Ref EnvironmentType]
      SecurityGroupIds:
        - !FindInMap [RegionAndEnvironmentToSecurityGroup, !Ref 'AWS::Region', !Ref EnvironmentType]
```

## Risorse correlate
<a name="mappings-section-related-resources"></a>

Questi argomenti correlati possono essere utili per sviluppare modelli che utilizzano la funzione `Fn::FindInMap`.
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-findinmap.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-findinmap.html)
+ [Fn::FindInMap miglioramenti](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-findinmap-enhancements.html)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-sub.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-sub.html)

# CloudFormation Metadatasintassi del modello
<a name="metadata-section-structure"></a>

`Metadata` archivia informazioni aggiuntive utilizzando oggetti JSON o YAML. I tipi di metadati a livello di modello che puoi utilizzare nel modello includono:

Metadati personalizzati  
Coppie chiave-valore definite dall’utente di archivi Ad esempio, puoi fornire informazioni aggiuntive che non influiscono sulla creazione di risorse ma offrono un contesto aggiuntivo sulle specifiche dell’infrastruttura, del team o dell’implementazione.

`AWS::CloudFormation::Interface`  
Definisce il raggruppamento e l'ordine dei parametri di input quando vengono visualizzati nella console. CloudFormation Per impostazione predefinita, la CloudFormation console ordina alfabeticamente i parametri in base al relativo ID logico. 

`AWS::CloudFormation::Designer`  
CloudFormation Designer (Designer) ha raggiunto la fine del ciclo di vita il 5 febbraio 2025.



**Importante**  
Durante l’aggiornamento di uno stack non puoi aggiornare solo la sezione `Metadata`. Puoi aggiornarla solo quando includi modifiche che prevedono l’aggiunta, la modifica o l’eliminazione di risorse.  
CloudFormation non trasforma, modifica o oscura le informazioni incluse nella `Metadata` sezione. Per questo motivo, si consiglia vivamente di non utilizzare questa sezione per archiviare informazioni riservate, ad esempio password o segreti.

## Sintassi
<a name="metadata-section-structure-syntax"></a>

Per dichiarare metadati personalizzati nel CloudFormation modello, utilizzate la seguente sintassi:

### JSON
<a name="metadata-section-structure-syntax.json"></a>

```
"Metadata" : {
  "Instances" : {"Description" : "Information about the instances"},
  "Databases" : {"Description" : "Information about the databases"}
}
```

### YAML
<a name="metadata-section-structure-syntax.yaml"></a>

```
Metadata:
  Instances:
    Description: "Information about the instances"
  Databases: 
    Description: "Information about the databases"
```

Per la sintassi di `AWS::CloudFormation::Interface`, consulta [Organizzazione CloudFormation dei parametri con `AWS::CloudFormation::Interface` metadati](aws-cloudformation-interface.md).

# Organizzazione CloudFormation dei parametri con `AWS::CloudFormation::Interface` metadati
<a name="aws-cloudformation-interface"></a>

`AWS::CloudFormation::Interface`è una chiave di metadati che definisce il modo in cui i parametri vengono raggruppati e ordinati nella console. CloudFormation Per impostazione predefinita, la console elenca i parametri di input in ordine alfabetico in base ai relativi ID logici quando crei o aggiorni stack nella stessa. Utilizzando questa chiave, è possibile definire il raggruppamento e l’ordine dei parametri in modo che gli utenti possano specificare i valori dei parametri in modo efficace. Ad esempio, è possibile raggruppare tutti i parametri relativi a EC2 in un gruppo e tutti i parametri relativi a VPC in un altro gruppo.

Nel chiave di metadati puoi specificare i gruppi da creare, i parametri da includere in ciascun gruppo e l’ordine in base al quale la console mostra ciascun parametro all’interno del relativo gruppo. 

Puoi anche definire le etichette dei parametri. Un’etichetta è un nome semplice o una descrizione che la console visualizza invece di visualizzare un ID logico del parametro. Le etichette sono utili per aiutare gli utenti a comprendere i valori da specificare per ciascun parametro. Ad esempio, è possibile creare un’etichetta per un parametro `KeyPair` `Select an EC2 key pair`.

Tutti i parametri a cui fai riferimento nella chiave di metadati devono essere dichiarati nella sezione `Parameters` del modello.

**Nota**  
Solo la CloudFormation console utilizza la chiave dei metadati. `AWS::CloudFormation::Interface` AWS CLI e le chiamate API non utilizzano questa chiave.

## Sintassi
<a name="aws-resource-cloudformation-interface-syntax"></a>

Per dichiarare questa entità nel tuo CloudFormation modello, usa la seguente sintassi:

### JSON
<a name="aws-resource-cloudformation-interface-syntax.json"></a>

```
"Metadata" : {
  "AWS::CloudFormation::Interface" : {
    "ParameterGroups": [
      {
        "Label": {
          "default": "Group Label"
        },
        "Parameters": [
          "Parameter1",
          "Parameter2"
        ]
      }
    ],
    "ParameterLabels": {
      "Parameter1": {
        "default": "Friendly Name for Parameter1"
      }
    }
  }
}
```

### YAML
<a name="aws-resource-cloudformation-interface-syntax.yaml"></a>

```
Metadata:
  AWS::CloudFormation::Interface:
    ParameterGroups:
      - Label:
          default: Group Label
        Parameters:
          - Parameter1
          - Parameter2
    ParameterLabels:
      Parameter1:
        default: Friendly Name for Parameter1
```

## Properties
<a name="w2aac11c23c29c17c17"></a>

`ParameterGroups`  
Un elenco dei tipi di gruppo di parametri dove è possibile specificare i nomi di gruppo, i parametri di ciascun gruppo e l’ordine in cui i parametri sono visualizzati.  
*Obbligatorio:* no    
`Label`  
Un nome per il gruppo di parametri.  
*Obbligatorio:* no  
`default`  
L'etichetta predefinita utilizzata dalla CloudFormation console per denominare un gruppo di parametri.  
*Required*: No  
▬*Tipo:* stringa  
`Parameters`  
Un elenco di parametri logici con distinzione tra maiuscole e minuscole IDs da includere nel gruppo. I parametri devono essere stati già definiti nella sezione `Parameters` del modello. Un parametro può essere incluso in un solo gruppo di parametri.  
La console elenca i parametri che non puoi associare a un gruppo di parametri in ordine alfabetico nel gruppo `Other parameters`.  
*Obbligatorio:* no  
*Tipo*: elenco di valori stringa

`ParameterLabels`  
Una mappatura dei parametri e dei relativi nomi descrittivi che la CloudFormation console mostra quando uno stack viene creato o aggiornato.  
*Obbligatorio:* no    
Etichetta del parametro  
Un’etichetta per un parametro. L'etichetta definisce un nome o una descrizione descrittiva che la CloudFormation console mostra nella pagina **Specificare i parametri** quando uno stack viene creato o aggiornato. L’etichetta del parametro deve essere l’ID logico, che distingue tra maiuscole e minuscole, di un parametro valido dichiarato nella sezione `Parameters` del modello.  
*Obbligatorio:* no  
`default`  
L'etichetta predefinita utilizzata dalla CloudFormation console per denominare un parametro.  
*Required*: No  
▬*Tipo:* stringa

## Esempio
<a name="w2aac11c23c29c17c19"></a>

L’esempio seguente definisce due gruppi di parametri: `Network Configuration` e `Amazon EC2 Configuration`. Il gruppo `Network Configuration` include i parametri `VPCID`, `SubnetId` e `SecurityGroupID`, che sono definiti nella sezione `Parameters` del modello (non mostrato). L’ordine in cui la console mostra questi parametri viene definito dall’ordine in cui i parametri sono elencati, a partire dal parametro `VPCID`. L’esempio analogamente raggruppa e ordina i parametri `Amazon EC2 Configuration`.

L’esempio definisce anche un’etichetta per il parametro `VPCID`. La console mostrerà **Which VPC should this be deployed to? (In quali VPC deve essere distribuito?)** anziché l’ID logico del parametro (`VPCID`).

### JSON
<a name="aws-cloudformation-interface-example.json"></a>

```
"Metadata" : {
  "AWS::CloudFormation::Interface" : {
    "ParameterGroups" : [
      {
        "Label" : { "default" : "Network Configuration" },
        "Parameters" : [ "VPCID", "SubnetId", "SecurityGroupID" ]
      },
      {
        "Label" : { "default":"Amazon EC2 Configuration" },
        "Parameters" : [ "InstanceType", "KeyName" ]
      }
    ],
    "ParameterLabels" : {
      "VPCID" : { "default" : "Which VPC should this be deployed to?" }
    }
  }
}
```

### YAML
<a name="aws-cloudformation-interface-example.yaml"></a>

```
Metadata: 
  AWS::CloudFormation::Interface: 
    ParameterGroups: 
      - Label: 
          default: "Network Configuration"
        Parameters: 
          - VPCID
          - SubnetId
          - SecurityGroupID
      - Label: 
          default: "Amazon EC2 Configuration"
        Parameters: 
          - InstanceType
          - KeyName
    ParameterLabels: 
      VPCID: 
        default: "Which VPC should this be deployed to?"
```

### Gruppi di parametri nella console
<a name="w2aac11c23c29c17c19c11"></a>

Utilizzando la chiave di metadati di questo esempio, la figura riportata di seguito mostra il modo in cui la console visualizza i gruppi di parametri al momento della creazione o dell’aggiornamento di uno stack: **i gruppi di parametri nella console** 

![\[La console mostra i gruppi di parametri per questo esempio.\]](http://docs.aws.amazon.com/it_it/AWSCloudFormation/latest/UserGuide/images/console-create-stack-parameter-groups.png)


# CloudFormation Rulessintassi del modello
<a name="rules-section-structure"></a>

La `Rules` sezione è una parte facoltativa di un CloudFormation modello che abilita la logica di convalida personalizzata. Se inclusa, questa sezione contiene le funzioni delle regole che convalidano i valori dei parametri prima di CloudFormation creare o aggiornare qualsiasi risorsa.

Le regole sono utili quando i vincoli dei parametri standard sono insufficienti. Ad esempio, quando SSL è abilitato, devono essere forniti sia un certificato che un nome di dominio. Una regola può garantire il rispetto di queste dipendenze.

## Sintassi
<a name="template-constraint-rules-syntax"></a>

La sezione `Rules` utilizza la sintassi seguente:

### JSON
<a name="rules-section-structure-syntax.json"></a>

La sezione `Rules` di un modello comporta il nome di chiave `Rules`, seguito da un segno di due punti. Usa le parentesi graffe per racchiudere tutte le dichiarazioni degli output di regola. Se dichiari più regole, queste sono delimitate da virgole. Per ogni regola, dichiari un nome logico tra virgolette seguito da un segno di due punti e parentesi graffe che racchiudono la condizione e le asserzioni di regola.

```
{
    "Rules": {
        "LogicalRuleName1": {
            "RuleCondition": {
                "rule-specific intrinsic function": "Value"
            },
            "Assertions": [
                {
                    "Assert": {
                        "rule-specific intrinsic function": "Value"
                    },
                    "AssertDescription": "Information about this assert"
                },
                {
                    "Assert": {
                        "rule-specific intrinsic function": "Value"
                    },
                    "AssertDescription": "Information about this assert"
                }
            ]
        },
        "LogicalRuleName2": {
            "Assertions": [
                {
                    "Assert": {
                        "rule-specific intrinsic function": "Value"
                    },
                    "AssertDescription": "Information about this assert"
                }
            ]
        }
    }
}
```

### YAML
<a name="rules-section-structure-syntax.yaml"></a>

```
Rules:
  LogicalRuleName1:
    RuleCondition:
      rule-specific intrinsic function: Value
    Assertions:
      - Assert:
          rule-specific intrinsic function: Value
        AssertDescription: Information about this assert
      - Assert:
          rule-specific intrinsic function: Value
        AssertDescription: Information about this assert
  LogicalRuleName2:
    Assertions:
      - Assert:
          rule-specific intrinsic function: Value
        AssertDescription: Information about this assert
```

### Campi delle regole
<a name="rules-section-fields"></a>

La sezione `Rules` può includere i seguenti campi.

**ID logico (chiamato anche *nome logico*)**  
Un identificatore univoco per ogni regola.

**`RuleCondition` (facoltativo)**  
Una proprietà che determina quando una regola viene attivata. Se non definisci una condizione di regola, le asserzioni della regola sono sempre attivate. Per ogni regola, è possibile definire una sola condizione della regola. 

**`Assertions`(obbligatorio)**  
Una o più istruzioni che specificano i valori accettabili per un particolare parametro.

**`Assert`**  
Una condizione che corrisponde a `true`.

**`AssertDescription`**  
Un messaggio visualizzato quando un’asserzione fallisce.

## Funzioni intrinseche specifiche delle regole
<a name="rules-specific-intrinsic-section-structure"></a>

Per definire le regole, devi utilizzare *funzioni intrinseche specifiche delle regole*, ovvero funzioni che possono essere utilizzate solo nella sezione `Rules` di un modello. È possibile nidificare queste funzioni, ma il risultato finale della condizione o dell’asserzione di una regola deve essere `true` o `false`.

Sono ora disponibili le seguenti funzioni delle regole:
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-and](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-and)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-rules.html#fn-contains](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-rules.html#fn-contains)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-rules.html#fn-eachmemberequals](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-rules.html#fn-eachmemberequals)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-rules.html#fn-eachmemberin](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-rules.html#fn-eachmemberin)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-equals](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-equals)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-if](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-if)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-not](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-not)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-or](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-or)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-rules.html#fn-refall](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-rules.html#fn-refall)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-rules.html#fn-valueof](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-rules.html#fn-valueof)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-rules.html#fn-valueofall](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-rules.html#fn-valueofall)

Queste funzioni vengono utilizzate nella condizione o nelle asserzioni di una regola. La proprietà condition determina se CloudFormation applicare le asserzioni. Se la condizione restituisce a`true`, CloudFormation valuta le asserzioni per verificare se il valore di un parametro è valido quando un prodotto fornito viene creato o aggiornato. Se il valore di un parametro non è valido, CloudFormation non crea né aggiorna lo stack. Se la condizione restituisce un risultato positivo`false`, CloudFormation non verifica il valore del parametro e procede con l'operazione di stack.

## Esempi
<a name="template-constraint-rules-example"></a>

**Topics**
+ [Verifica condizionale di un valore di parametro](#template-constraint-rules-example-verify)
+ [Convalida multi-parametro](#template-cross-parameter-rules-example)

### Verifica condizionale di un valore di parametro
<a name="template-constraint-rules-example-verify"></a>

Nell'esempio seguente, le due regole verificano il valore del parametro `InstanceType`. A seconda del valore del parametro Environment (`test` o `prod`), l'utente deve specificare `t3.medium` o `t3.large` per il parametro `InstanceType`. I parametri `InstanceType` e `Environment` devono essere dichiarati nella sezione `Parameters` dello stesso modello.

#### JSON
<a name="rules-section-example-conditionally-verify.json"></a>

```
{
  "Rules": {
    "testInstanceType": {
      "RuleCondition": {
        "Fn::Equals": [
          {"Ref": "Environment"},
          "test"
        ]
      },
      "Assertions": [
        {
          "Assert": {
            "Fn::Contains": [
              ["t3.medium"],
              {"Ref": "InstanceType"}
            ]
          },
          "AssertDescription": "For a test environment, the instance type must be t3.medium"
        }
      ]
    },
    "prodInstanceType": {
      "RuleCondition": {
        "Fn::Equals": [
          {"Ref": "Environment"},
          "prod"
        ]
      },
      "Assertions": [
        {
          "Assert": {
            "Fn::Contains": [
              ["t3.large"],
              {"Ref": "InstanceType"}
            ]
          },
          "AssertDescription": "For a production environment, the instance type must be t3.large"
        }
      ]
    }
  }
}
```

#### YAML
<a name="rules-section-example-conditionally-verify.yaml"></a>

```
Rules:
  testInstanceType:
    RuleCondition: !Equals 
      - !Ref Environment
      - test
    Assertions:
      - Assert:
          'Fn::Contains':
            - - t3.medium
            - !Ref InstanceType
        AssertDescription: 'For a test environment, the instance type must be t3.medium'
  prodInstanceType:
    RuleCondition: !Equals 
      - !Ref Environment
      - prod
    Assertions:
      - Assert:
          'Fn::Contains':
            - - t3.large
            - !Ref InstanceType
        AssertDescription: 'For a production environment, the instance type must be t3.large'
```

### Convalida multi-parametro
<a name="template-cross-parameter-rules-example"></a>

I seguenti modelli di esempio dimostrano l’uso di regole per le convalide tra parametri. Creano un sito web di esempio in esecuzione su un gruppo Auto Scaling con un sistema di bilanciatore del carico. Il sito web è disponibile sulla porta 80 o 443 a seconda dei parametri di input. Le istanze del gruppo Auto Scaling possono essere configurate per l’ascolto su qualsiasi porta (con 8888 come impostazione predefinita).

Le regole di questo modello convalidano i parametri di input prima della creazione dello stack. Verificano quindi che tutte le sottoreti appartengano al VPC specificato e assicurano che, quando il parametro `UseSSL` è impostato su `Yes`, vengano forniti sia l’ARN del certificato SSL che il nome della zona ospitata.

**Nota**  
Se crei uno stack da questo modello, ti verranno addebitate AWS le risorse utilizzate.

#### JSON
<a name="rules-section-example-cross-parameter-validation.json"></a>

```
{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Parameters": {
    "VpcId": {
      "Type": "AWS::EC2::VPC::Id",
      "Description": "VpcId of your existing Virtual Private Cloud (VPC)",
      "ConstraintDescription": "must be the VPC Id of an existing Virtual Private Cloud."
    },
    "Subnets": {
      "Type": "List<AWS::EC2::Subnet::Id>",
      "Description": "The list of SubnetIds in your Virtual Private Cloud (VPC)",
      "ConstraintDescription": "must be a list of at least two existing subnets associated with at least two different availability zones."
    },
    "InstanceType": {
      "Description": "WebServer EC2 instance type",
      "Type": "String",
      "Default": "t2.micro",
      "AllowedValues": ["t2.micro", "t3.micro"],
      "ConstraintDescription": "must be a valid EC2 instance type."
    },
    "KeyName": {
      "Description": "Name of an existing EC2 KeyPair to enable SSH access to the instances",
      "Type": "AWS::EC2::KeyPair::KeyName",
      "ConstraintDescription": "must be the name of an existing EC2 KeyPair."
    },
    "SSHLocation": {
      "Description": "The IP address range that can be used to SSH to the EC2 instances",
      "Type": "String",
      "MinLength": "9",
      "MaxLength": "18",
      "Default": "0.0.0.0/0",
      "AllowedPattern": "(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})/(\\d{1,2})",
      "ConstraintDescription": "must be a valid IP CIDR range of the form x.x.x.x/x."
    },
    "UseSSL": {
      "AllowedValues": ["Yes", "No"],
      "Default": "No",
      "Description": "Select \"Yes\" to implement SSL, \"No\" to skip (default).",
      "Type": "String"
    },
    "ALBSSLCertificateARN": {
      "Default": "",
      "Description": "[Optional] The ARN of the SSL certificate to be used for the Application Load Balancer",
      "Type": "String"
    },
    "HostedZoneName": {
      "AllowedPattern": "^$|(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\\-]*[a-zA-Z0-9])\\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\\-]*[A-Za-z0-9])$",
      "Default": "",
      "Description": "[Optional] The domain name of a valid Hosted Zone on AWS.",
      "Type": "String"
    }
  },
  "Conditions": {
    "UseALBSSL": {"Fn::Equals": [{"Ref": "UseSSL"}, "Yes"]}
  },
  "Rules": {
    "SubnetsInVPC": {
      "Assertions": [
        {
          "Assert": {"Fn::EachMemberEquals": [{"Fn::ValueOf": ["Subnets", "VpcId"]}, {"Ref": "VpcId"}]},
          "AssertDescription": "All subnets must be in the VPC"
        }
      ]
    },
    "ValidateHostedZone": {
      "RuleCondition": {"Fn::Equals": [{"Ref": "UseSSL"}, "Yes"]},
      "Assertions": [
        {
          "Assert": {"Fn::Not": [{"Fn::Equals": [{"Ref": "ALBSSLCertificateARN"}, ""]}]},
          "AssertDescription": "ACM Certificate value cannot be empty if SSL is required"
        },
        {
          "Assert": {"Fn::Not": [{"Fn::Equals": [{"Ref": "HostedZoneName"}, ""]}]},
          "AssertDescription": "Route53 Hosted Zone Name is mandatory when SSL is required"
        }
      ]
    }
  },
  "Resources": {
    "WebServerGroup": {
      "Type": "AWS::AutoScaling::AutoScalingGroup",
      "Properties": {
        "VPCZoneIdentifier": {"Ref": "Subnets"},
        "LaunchTemplate": {
          "LaunchTemplateId": {"Ref": "LaunchTemplate"},
          "Version": {"Fn::GetAtt": ["LaunchTemplate","LatestVersionNumber"]}
        },
        "MinSize": "2",
        "MaxSize": "2",
        "TargetGroupARNs": [{"Ref": "ALBTargetGroup"}]
      },
      "CreationPolicy": {
        "ResourceSignal": {"Timeout": "PT15M"}
      },
      "UpdatePolicy": {
        "AutoScalingRollingUpdate": {
          "MinInstancesInService": "1",
          "MaxBatchSize": "1",
          "PauseTime": "PT15M",
          "WaitOnResourceSignals": true
        }
      }
    },
    "LaunchTemplate": {
      "Type": "AWS::EC2::LaunchTemplate",
      "Metadata": {
        "Comment": "Install a simple application",
        "AWS::CloudFormation::Init": {
          "config": {
            "packages": {"yum": {"httpd": []}},
            "files": {
              "/var/www/html/index.html": {
                "content": {"Fn::Join": ["\n", ["<h1>Congratulations, you have successfully launched the AWS CloudFormation sample.</h1>"]]},
                "mode": "000644",
                "owner": "root",
                "group": "root"
              },
              "/etc/cfn/cfn-hup.conf": {
                "content": {"Fn::Join": ["", [
                  "[main]\n",
                  "stack=", {"Ref": "AWS::StackId"}, "\n",
                  "region=", {"Ref": "AWS::Region"}, "\n"
                ]]},
                "mode": "000400",
                "owner": "root",
                "group": "root"
              },
              "/etc/cfn/hooks.d/cfn-auto-reloader.conf": {
                "content": {"Fn::Join": ["", [
                  "[cfn-auto-reloader-hook]\n",
                  "triggers=post.update\n",
                  "path=Resources.LaunchTemplate.Metadata.AWS::CloudFormation::Init\n",
                  "action=/opt/aws/bin/cfn-init -v ",
                  "         --stack ", {"Ref": "AWS::StackName"},
                  "         --resource LaunchTemplate ",
                  "         --region ", {"Ref": "AWS::Region"}, "\n",
                  "runas=root\n"
                ]]},
                "mode": "000400",
                "owner": "root",
                "group": "root"
              }
            },
            "services": {
              "sysvinit": {
                "httpd": {
                  "enabled": "true",
                  "ensureRunning": "true"
                },
                "cfn-hup": {
                  "enabled": "true",
                  "ensureRunning": "true",
                  "files": [
                    "/etc/cfn/cfn-hup.conf",
                    "/etc/cfn/hooks.d/cfn-auto-reloader.conf"
                  ]
                }
              }
            }
          }
        }
      },
      "Properties": {
        "LaunchTemplateName": {"Fn::Sub": "${AWS::StackName}-launch-template"},
        "LaunchTemplateData": {
          "ImageId": "{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}",
          "SecurityGroupIds": [{"Ref": "InstanceSecurityGroup"}],
          "InstanceType": {"Ref": "InstanceType"},
          "KeyName": {"Ref": "KeyName"},
          "UserData": {
            "Fn::Base64": {"Fn::Join": ["", [
              "#!/bin/bash\n",
              "yum install -y aws-cfn-bootstrap\n",
              "/opt/aws/bin/cfn-init -v ",
              "         --stack ", {"Ref": "AWS::StackName"},
              "         --resource LaunchTemplate ",
              "         --region ", {"Ref": "AWS::Region"}, "\n",
              "/opt/aws/bin/cfn-signal -e $? ",
              "         --stack ", {"Ref": "AWS::StackName"},
              "         --resource WebServerGroup ",
              "         --region ", {"Ref": "AWS::Region"}, "\n"
            ]]}
          }
        }
      }
    },
    "ELBSecurityGroup": {
      "Type": "AWS::EC2::SecurityGroup",
      "Properties": {
        "GroupDescription": "Allow access to the ELB",
        "VpcId": {"Ref": "VpcId"},
        "SecurityGroupIngress": [{
          "Fn::If": [
            "UseALBSSL",
            {
              "IpProtocol": "tcp",
              "FromPort": 443,
              "ToPort": 443,
              "CidrIp": "0.0.0.0/0"
            },
            {
              "IpProtocol": "tcp",
              "FromPort": 80,
              "ToPort": 80,
              "CidrIp": "0.0.0.0/0"
            }
          ]
        }]
      }
    },
    "ApplicationLoadBalancer": {
      "Type": "AWS::ElasticLoadBalancingV2::LoadBalancer",
      "Properties": {
        "Subnets": {"Ref": "Subnets"},
        "SecurityGroups": [{"Ref": "ELBSecurityGroup"}]
      }
    },
    "ALBListener": {
      "Type": "AWS::ElasticLoadBalancingV2::Listener",
      "Properties": {
        "DefaultActions": [{
          "Type": "forward",
          "TargetGroupArn": {"Ref": "ALBTargetGroup"}
        }],
        "LoadBalancerArn": {"Ref": "ApplicationLoadBalancer"},
        "Port": {"Fn::If": ["UseALBSSL", 443, 80]},
        "Protocol": {"Fn::If": ["UseALBSSL", "HTTPS", "HTTP"]},
        "Certificates": [{
          "Fn::If": [
            "UseALBSSL",
            {"CertificateArn": {"Ref": "ALBSSLCertificateARN"}},
            {"Ref": "AWS::NoValue"}
          ]
        }]
      }
    },
    "ALBTargetGroup": {
      "Type": "AWS::ElasticLoadBalancingV2::TargetGroup",
      "Properties": {
        "HealthCheckIntervalSeconds": 30,
        "HealthCheckTimeoutSeconds": 5,
        "HealthyThresholdCount": 3,
        "Port": 80,
        "Protocol": "HTTP",
        "UnhealthyThresholdCount": 5,
        "VpcId": {"Ref": "VpcId"}
      }
    },
    "InstanceSecurityGroup": {
      "Type": "AWS::EC2::SecurityGroup",
      "Properties": {
        "GroupDescription": "Enable SSH access and HTTP access on the inbound port",
        "SecurityGroupIngress": [
          {
            "IpProtocol": "tcp",
            "FromPort": 80,
            "ToPort": 80,
            "SourceSecurityGroupId": {"Fn::Select": [0, {"Fn::GetAtt": ["ApplicationLoadBalancer", "SecurityGroups"]}]}
          },
          {
            "IpProtocol": "tcp",
            "FromPort": 22,
            "ToPort": 22,
            "CidrIp": {"Ref": "SSHLocation"}
          }
        ],
        "VpcId": {"Ref": "VpcId"}
      }
    },
    "RecordSet": {
      "Type": "AWS::Route53::RecordSetGroup",
      "Condition": "UseALBSSL",
      "Properties": {
        "HostedZoneName": {"Fn::Join": ["", [{"Ref": "HostedZoneName"}, "."]]},
        "RecordSets": [{
          "Name": {"Fn::Join": ["", [
            {"Fn::Select": ["0", {"Fn::Split": [".", {"Fn::GetAtt": ["ApplicationLoadBalancer", "DNSName"]}]}]},
            ".",
            {"Ref": "HostedZoneName"},
            "."
          ]]},
          "Type": "A",
          "AliasTarget": {
            "DNSName": {"Fn::GetAtt": ["ApplicationLoadBalancer", "DNSName"]},
            "EvaluateTargetHealth": true,
            "HostedZoneId": {"Fn::GetAtt": ["ApplicationLoadBalancer", "CanonicalHostedZoneID"]}
          }
        }]
      }
    }
  },
  "Outputs": {
    "URL": {
      "Description": "URL of the website",
      "Value": {"Fn::Join": ["", [
        {"Fn::If": [
          "UseALBSSL",
          {"Fn::Join": ["", [
            "https://",
            {"Fn::Join": ["", [
              {"Fn::Select": ["0", {"Fn::Split": [".", {"Fn::GetAtt": ["ApplicationLoadBalancer", "DNSName"]}]}]},
              ".",
              {"Ref": "HostedZoneName"},
              "."
            ]]}
          ]]},
          {"Fn::Join": ["", [
            "http://",
            {"Fn::GetAtt": ["ApplicationLoadBalancer", "DNSName"]}
          ]]}
        ]}
      ]]}
    }
  }
}
```

#### YAML
<a name="rules-section-example-syntax.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
Parameters:
  VpcId:
    Type: AWS::EC2::VPC::Id
    Description: VpcId of your existing Virtual Private Cloud (VPC)
    ConstraintDescription: must be the VPC Id of an existing Virtual Private Cloud.
  Subnets:
    Type: List<AWS::EC2::Subnet::Id>
    Description: The list of SubnetIds in your Virtual Private Cloud (VPC)
    ConstraintDescription: >-
      must be a list of at least two existing subnets associated with at least
      two different availability zones. They should be residing in the selected
      Virtual Private Cloud.
  InstanceType:
    Description: WebServer EC2 instance type
    Type: String
    Default: t2.micro
    AllowedValues:
      - t2.micro
      - t3.micro
    ConstraintDescription: must be a valid EC2 instance type.
  KeyName:
    Description: Name of an existing EC2 KeyPair to enable SSH access to the instances
    Type: AWS::EC2::KeyPair::KeyName
    ConstraintDescription: must be the name of an existing EC2 KeyPair.
  SSHLocation:
    Description: The IP address range that can be used to SSH to the EC2 instances
    Type: String
    MinLength: '9'
    MaxLength: '18'
    Default: 0.0.0.0/0
    AllowedPattern: '(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})/(\d{1,2})'
    ConstraintDescription: must be a valid IP CIDR range of the form x.x.x.x/x.
  UseSSL:
    AllowedValues:
      - 'Yes'
      - 'No'
    ConstraintDescription: Select Yes to create a HTTPS Listener
    Default: 'No'
    Description: 'Select "Yes" to implement SSL, "No" to skip (default).'
    Type: String
  ALBSSLCertificateARN:
    Default: ''
    Description: >-
      [Optional] The ARN of the SSL certificate to be used for the Application
      Load Balancer
    Type: String
  HostedZoneName:
    AllowedPattern: >-
      ^$|(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$
    Default: ''
    Description: '[Optional] The domain name of a valid Hosted Zone on AWS.'
    Type: String
Conditions:
  UseALBSSL: !Equals 
    - !Ref UseSSL
    - 'Yes'
Rules:
  SubnetsInVPC:
    Assertions:
      - Assert:
          'Fn::EachMemberEquals':
            - 'Fn::ValueOf':
                - Subnets
                - VpcId
            - Ref: VpcId
        AssertDescription: All subnets must be in the VPC
  ValidateHostedZone:
    RuleCondition: !Equals 
      - !Ref UseSSL
      - 'Yes'
    Assertions:
      - Assert: !Not 
          - !Equals 
            - !Ref ALBSSLCertificateARN
            - ''
        AssertDescription: ACM Certificate value cannot be empty if SSL is required
      - Assert: !Not 
          - !Equals 
            - !Ref HostedZoneName
            - ''
        AssertDescription: Route53 Hosted Zone Name is mandatory when SSL is required
Resources:
  WebServerGroup:
    Type: AWS::AutoScaling::AutoScalingGroup
    Properties:
      VPCZoneIdentifier: !Ref Subnets
      LaunchTemplate:
        LaunchTemplateId: !Ref LaunchTemplate
        Version: !GetAtt LaunchTemplate.LatestVersionNumber
      MinSize: '2'
      MaxSize: '2'
      TargetGroupARNs:
        - !Ref ALBTargetGroup
    CreationPolicy:
      ResourceSignal:
        Timeout: PT15M
    UpdatePolicy:
      AutoScalingRollingUpdate:
        MinInstancesInService: '1'
        MaxBatchSize: '1'
        PauseTime: PT15M
        WaitOnResourceSignals: 'true'
  LaunchTemplate:
    Type: AWS::EC2::LaunchTemplate
    Metadata:
      Comment: Install a simple application
      AWS::CloudFormation::Init:
        config:
          packages:
            yum:
              httpd: []
          files:
            /var/www/html/index.html:
              content: !Join 
                - |+
                - - >-
                    <h1>Congratulations, you have successfully launched the AWS
                    CloudFormation sample.</h1>
              mode: '000644'
              owner: root
              group: root
            /etc/cfn/cfn-hup.conf:
              content: !Sub |
                [main]
                stack=${AWS::StackId}
                region=${AWS::Region}
              mode: '000400'
              owner: root
              group: root
            /etc/cfn/hooks.d/cfn-auto-reloader.conf:
              content: !Sub |-
                [cfn-auto-reloader-hook]
                triggers=post.update
                path=Resources.LaunchTemplate.Metadata.AWS::CloudFormation::Init
                action=/opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource LaunchTemplate --region ${AWS::Region}
                runas=root
              mode: '000400'
              owner: root
              group: root
          services:
            sysvinit:
              httpd:
                enabled: 'true'
                ensureRunning: 'true'
              cfn-hup:
                enabled: 'true'
                ensureRunning: 'true'
                files:
                  - /etc/cfn/cfn-hup.conf
                  - /etc/cfn/hooks.d/cfn-auto-reloader.conf
    Properties:
      LaunchTemplateName: !Sub ${AWS::StackName}-launch-template
      LaunchTemplateData:
        ImageId: '{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}'
        SecurityGroupIds:
        - !Ref InstanceSecurityGroup
        InstanceType: !Ref InstanceType
        KeyName: !Ref KeyName
        UserData: !Base64
          Fn::Sub: |
            #!/bin/bash
            yum install -y aws-cfn-bootstrap
            /opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource LaunchTemplate --region ${AWS::Region}
            /opt/aws/bin/cfn-signal -e $? --stack ${AWS::StackName} --resource WebServerGroup --region ${AWS::Region}
  ELBSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Allow access to the ELB
      VpcId: !Ref VpcId
      SecurityGroupIngress:
        - !If 
          - UseALBSSL
          - IpProtocol: tcp
            FromPort: 443
            ToPort: 443
            CidrIp: 0.0.0.0/0
          - IpProtocol: tcp
            FromPort: 80
            ToPort: 80
            CidrIp: 0.0.0.0/0
  ApplicationLoadBalancer:
    Type: AWS::ElasticLoadBalancingV2::LoadBalancer
    Properties:
      Subnets: !Ref Subnets
      SecurityGroups:
        - !Ref ELBSecurityGroup
  ALBListener:
    Type: AWS::ElasticLoadBalancingV2::Listener
    Properties:
      DefaultActions:
        - Type: forward
          TargetGroupArn: !Ref ALBTargetGroup
      LoadBalancerArn: !Ref ApplicationLoadBalancer
      Port: !If
        - UseALBSSL
        - 443
        - 80
      Protocol: !If 
        - UseALBSSL
        - HTTPS
        - HTTP
      Certificates:
        - !If 
          - UseALBSSL
          - CertificateArn: !Ref ALBSSLCertificateARN
          - !Ref 'AWS::NoValue'
  ALBTargetGroup:
    Type: AWS::ElasticLoadBalancingV2::TargetGroup
    Properties:
      HealthCheckIntervalSeconds: 30
      HealthCheckTimeoutSeconds: 5
      HealthyThresholdCount: 3
      Port: 80
      Protocol: HTTP
      UnhealthyThresholdCount: 5
      VpcId: !Ref VpcId
  InstanceSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Enable SSH access and HTTP access on the inbound port
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: 80
          ToPort: 80
          SourceSecurityGroupId: !Select 
            - 0
            - !GetAtt 
              - ApplicationLoadBalancer
              - SecurityGroups
        - IpProtocol: tcp
          FromPort: 22
          ToPort: 22
          CidrIp: !Ref SSHLocation
      VpcId: !Ref VpcId
  RecordSet:
    Type: AWS::Route53::RecordSetGroup
    Condition: UseALBSSL
    Properties:
      HostedZoneName: !Join 
        - ''
        - - !Ref HostedZoneName
          - .
      RecordSets:
        - Name: !Join 
            - ''
            - - !Select 
                - '0'
                - !Split 
                  - .
                  - !GetAtt 
                    - ApplicationLoadBalancer
                    - DNSName
              - .
              - !Ref HostedZoneName
              - .
          Type: A
          AliasTarget:
            DNSName: !GetAtt 
              - ApplicationLoadBalancer
              - DNSName
            EvaluateTargetHealth: true
            HostedZoneId: !GetAtt 
              - ApplicationLoadBalancer
              - CanonicalHostedZoneID
Outputs:
  URL:
    Description: URL of the website
    Value: !Join 
      - ''
      - - !If 
          - UseALBSSL
          - !Join 
            - ''
            - - 'https://'
              - !Join 
                - ''
                - - !Select 
                    - '0'
                    - !Split 
                      - .
                      - !GetAtt 
                        - ApplicationLoadBalancer
                        - DNSName
                  - .
                  - !Ref HostedZoneName
                  - .
          - !Join 
            - ''
            - - 'http://'
              - !GetAtt 
                - ApplicationLoadBalancer
                - DNSName
```

# CloudFormation Conditionssintassi del modello
<a name="conditions-section-structure"></a>

La sezione `Conditions` facoltativa contiene istruzioni che definiscono le circostanze nelle quali le entità vengono create o configurate. Ad esempio, è possibile creare una condizione e associarla a una risorsa o a un output in modo da CloudFormation creare la risorsa o l'output solo se la condizione è vera. Analogamente, è possibile associare una condizione a una proprietà in modo da CloudFormation impostare la proprietà su un valore specifico solo se la condizione è vera. Se la condizione è falsa, CloudFormation imposta la proprietà su un valore alternativo specificato dall'utente.

Puoi utilizzare le condizioni quando vuoi riutilizzare un modello per creare risorse in diversi contesti, ad esempio ambienti di test rispetto ad ambienti di produzione. Ad esempio, nel modello puoi aggiungere un parametro di input `EnvironmentType`, che accetta `prod` o `test` come input. Per l’ambiente di `prod`, puoi includere istanze EC2 con alcune funzionalità, mentre per l’ambiente di `test`, puoi utilizzare le funzionalità ridotte per risparmiare denaro. Questa definizione della condizione ti permette di definire quali risorse vengono create e come vengono configurate per ciascun tipo di ambiente.

## Sintassi
<a name="conditions-section-structure-syntax"></a>

La sezione `Conditions` è composta dal nome di chiave `Conditions`. Ogni dichiarazione della condizione include un ID logico e una o più funzioni intrinseche. 

### JSON
<a name="conditions-section-structure-syntax.json"></a>

```
"Conditions": {
  "LogicalConditionName1": {
    "Intrinsic function": ...[
  },

  "LogicalConditionName2": {
    "Intrinsic function": ...
  }
}
```

### YAML
<a name="conditions-section-structure-syntax.yaml"></a>

```
Conditions:
  LogicalConditionName1:
    Intrinsic function:
      ...

  LogicalConditionName2:
    Intrinsic function:
      ...
```

## Come funzionano le condizioni
<a name="conditions-section-structure-overview"></a>

Per utilizzare le condizioni, procedi come segue:

1. **Aggiungi una definizione di parametro**: definisci gli input che le tue condizioni valuteranno nella sezione `Parameters` del modello. Le condizioni restituiscono true o false in base ai valori di questi parametri di input. Tieni presente che gli pseudo parametri sono disponibili automaticamente e non richiedono una definizione esplicita nella sezione `Parameters`. Per ulteriori informazioni sugli pseudoparametri, consulta [Ottieni AWS valori usando pseudo parametri](pseudo-parameter-reference.md).

1. **Aggiungi una definizione della condizione**: definisci le condizioni nella sezione `Conditions` utilizzando funzioni intrinseche come `Fn::If` o `Fn::Equals`. Queste condizioni determinano quando vengono CloudFormation create le risorse associate. Le condizioni possono essere basate su:
   + Valori di input o pseudo parametri
   + Altre condizioni:
   + Valori di mappatura

   Tuttavia, non è possibile fare riferimento alla logica delle risorse IDs o ai relativi attributi nelle condizioni.

1. **Associa le condizioni a risorse o output**: fai riferimento alle condizioni nelle risorse o negli output utilizzando la chiave `Condition` e l’ID logico di una condizione. Facoltativamente, utilizza `Fn::If` in altre parti del modello (come i valori delle proprietà) per impostare i valori in base a una condizione. Per ulteriori informazioni, consulta [Utilizzo della chiave `Condition`](#using-conditions-in-templates).

CloudFormation valuta le condizioni durante la creazione o l'aggiornamento di uno stack. CloudFormation crea entità associate a una condizione vera e ignora le entità associate a una condizione falsa. CloudFormation rivaluta inoltre queste condizioni durante ogni aggiornamento dello stack prima di modificare qualsiasi risorsa. Le entità che rimangono associate a una condizione true vengono aggiornate, mentre quelle che vengono associate a una condizione false vengono eliminate.

**Importante**  
Durante l’aggiornamento di uno stack non puoi aggiornare solo le condizioni. Le condizioni possono essere aggiornate solo se si includono modifiche che comportano l’aggiunta, la modifica o l’eliminazione di risorse.

## Funzioni intrinseche delle condizioni
<a name="conditions-section-structure-functions"></a>

Puoi utilizzare le seguenti funzioni intrinseche per definire le condizioni:
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-and](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-and)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-equals](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-equals)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-foreach.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-foreach.html)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-if](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-if)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-not](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-not)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-or](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-or)

**Nota**  
`Fn::If` è supportata solo nell’attributo di metadati, nell’attributo delle policy di aggiornamento e nei valori di proprietà della sezione`Resources` e nelle sezioni `Outputs` di un modello.

## Utilizzo della chiave `Condition`
<a name="using-conditions-in-templates"></a>

Una volta definita una condizione, è possibile applicarla in diversi punti del modello, ad esempio `Resources` e `Outputs`, utilizzando la chiave `Condition`. La chiave `Condition` fa riferimento al nome logico di una condizione e restituisce il risultato valutato della condizione specificata.

**Topics**
+ [Associa le condizioni alle risorse](#associate-conditions-with-resources)
+ [Associa le condizioni agli output](#associate-conditions-with-outputs)
+ [Condizioni di riferimento in altre condizioni](#reference-conditions-in-other-conditions)
+ [Restituisce in modo condizionale i valori delle proprietà utilizzando `Fn::If`](#conditional-return-property-values-using-fn-if)

### Associa le condizioni alle risorse
<a name="associate-conditions-with-resources"></a>

Per creare risorse in modo condizionale, aggiungi la `Condition` chiave e l'ID logico della condizione come attributo alla risorsa. CloudFormation crea la risorsa solo quando la condizione risulta vera.

#### JSON
<a name="associate-conditions-with-resources.json"></a>

```
"NewVolume" : {
  "Type" : "AWS::EC2::Volume",
  "Condition" : "IsProduction",
  "Properties" : {
     "Size" : "100",
     "AvailabilityZone" : { "Fn::GetAtt" : [ "EC2Instance", "AvailabilityZone" ]}
  }
}
```

#### YAML
<a name="associate-conditions-with-resources.yaml"></a>

```
NewVolume:
  Type: AWS::EC2::Volume
  Condition: IsProduction
  Properties:
    Size: 100
    AvailabilityZone: !GetAtt EC2Instance.AvailabilityZone
```

### Associa le condizioni agli output
<a name="associate-conditions-with-outputs"></a>

È inoltre possibile associare condizioni agli output. CloudFormation crea l'output solo quando la condizione associata risulta vera.

#### JSON
<a name="associate-conditions-with-outputs.json"></a>

```
"Outputs" : {
  "VolumeId" : {
    "Condition" : "IsProduction",
    "Value" : { "Ref" : "NewVolume" }
  }
}
```

#### YAML
<a name="associate-conditions-with-outputs.yaml"></a>

```
Outputs:
  VolumeId:
    Condition: IsProduction
    Value: !Ref NewVolume
```

### Condizioni di riferimento in altre condizioni
<a name="reference-conditions-in-other-conditions"></a>

Quando si definiscono le condizioni nella sezione `Conditions`, è possibile fare riferimento ad altre condizioni utilizzando la chiave `Condition`. Ciò ti consente di creare una logica condizionale più complessa combinando più condizioni.

Nell’esempio seguente, la condizione `IsProdAndFeatureEnabled` viene valutata come true solo se le condizioni `IsProduction` e `IsFeatureEnabled` restituiscono true.

#### JSON
<a name="reference-conditions-in-other-conditions.json"></a>

```
"Conditions": {
  "IsProduction" : {"Fn::Equals" : [{"Ref" : "Environment"}, "prod"]},
  "IsFeatureEnabled" : { "Fn::Equals" : [{"Ref" : "FeatureFlag"}, "enabled"]},
  "IsProdAndFeatureEnabled" : {
    "Fn::And" : [
      {"Condition" : "IsProduction"},
      {"Condition" : "IsFeatureEnabled"}
    ]
  }
}
```

#### YAML
<a name="reference-conditions-in-other-conditions.yaml"></a>

```
Conditions:
  IsProduction:
    !Equals [!Ref Environment, "prod"]
  IsFeatureEnabled:
    !Equals [!Ref FeatureFlag, "enabled"]
  IsProdAndFeatureEnabled: !And
    - !Condition IsProduction
    - !Condition IsFeatureEnabled
```

### Restituisce in modo condizionale i valori delle proprietà utilizzando `Fn::If`
<a name="conditional-return-property-values-using-fn-if"></a>

Per un controllo più granulare, è possibile utilizzare la funzione intrinseca `Fn::If` per restituire in modo condizionale uno dei due valori di proprietà all’interno delle risorse o degli output. Questa funzione valuta una condizione e restituisce un valore se la condizione risulta true e un altro valore se la condizione risulta false.

#### Valori della proprietà condizionale
<a name="using-fn-if-for-conditional-values"></a>

L’esempio seguente dimostra l’impostazione di un tipo di istanza EC2 in base a una condizione ambientale. Se la condizione `IsProduction` risulta true, il tipo di istanza viene impostato su `c5.xlarge`. In caso contrario, viene impostato su `t3.small`.

##### JSON
<a name="using-fn-if-for-conditional-values.json"></a>

```
"Properties" : {
  "InstanceType" : {
    "Fn::If" : [
      "IsProduction",
      "c5.xlarge",
      "t3.small"
    ]
  }
}
```

##### YAML
<a name="using-fn-if-for-conditional-values.yaml"></a>

```
Properties:
  InstanceType: !If
    - IsProduction
    - c5.xlarge
    - t3.small
```

#### Rimozione della proprietà condizionale
<a name="using-fn-if-with-novalue"></a>

Puoi anche utilizzare lo pseudo parametro `AWS::NoValue` come valore restituito per rimuovere la proprietà corrispondente quando la condizione risulta false.

##### JSON
<a name="using-fn-if-with-novalue.json"></a>

```
"DBSnapshotIdentifier" : {
  "Fn::If" : [
    "UseDBSnapshot",
    {"Ref" : "DBSnapshotName"},
    {"Ref" : "AWS::NoValue"}
  ]
}
```

##### YAML
<a name="using-fn-if-with-novalue.yaml"></a>

```
DBSnapshotIdentifier: !If
  - UseDBSnapshot
  - !Ref DBSnapshotName
  - !Ref "AWS::NoValue"
```

## Esempi
<a name="conditions-section-structure-examples"></a>

**Topics**
+ [Creazione di risorsa basata sull’ambiente](#environment-based-resource-creation)
+ [Provisioning di risorse a più condizioni](#multi-condition-resource-provisioning)

### Creazione di risorsa basata sull’ambiente
<a name="environment-based-resource-creation"></a>

Gli esempi seguenti forniscono un’istanza EC2 e creano e collegano in modo condizionale un nuovo volume EBS solo se il tipo di ambiente è `prod`. Se l’ambiente è `test`, creano semplicemente l’istanza EC2 senza il volume aggiuntivo.

#### JSON
<a name="conditions-section-example-resource-creation.json"></a>

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Parameters": {
        "EnvType": {
            "Description": "Environment type",
            "Default": "test",
            "Type": "String",
            "AllowedValues": [
                "prod",
                "test"
            ],
            "ConstraintDescription": "must specify prod or test"
        }
    },
    "Conditions": {
        "IsProduction": {
            "Fn::Equals": [
                {
                    "Ref": "EnvType"
                },
                "prod"
            ]
        }
    },
    "Resources": {
        "EC2Instance": {
            "Type": "AWS::EC2::Instance",
            "Properties": {
                "ImageId": "ami-1234567890abcdef0",
                "InstanceType": "c5.xlarge"
            }
        },
        "MountPoint": {
            "Type": "AWS::EC2::VolumeAttachment",
            "Condition": "IsProduction",
            "Properties": {
                "InstanceId": {
                    "Ref": "EC2Instance"
                },
                "VolumeId": {
                    "Ref": "NewVolume"
                },
                "Device": "/dev/sdh"
            }
        },
        "NewVolume": {
            "Type": "AWS::EC2::Volume",
            "Condition": "IsProduction",
            "Properties": {
                "Size": 100,
                "AvailabilityZone": {
                    "Fn::GetAtt": [
                        "EC2Instance",
                        "AvailabilityZone"
                    ]
                }
            }
        }
    }
}
```

#### YAML
<a name="conditions-section-example-resource-creation.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
Parameters:
  EnvType:
    Description: Environment type
    Default: test
    Type: String
    AllowedValues:
      - prod
      - test
    ConstraintDescription: must specify prod or test
Conditions:
  IsProduction: !Equals
    - !Ref EnvType
    - prod
Resources:
  EC2Instance:
    Type: AWS::EC2::Instance
    Properties:
      ImageId: ami-1234567890abcdef0
      InstanceType: c5.xlarge
  MountPoint:
    Type: AWS::EC2::VolumeAttachment
    Condition: IsProduction
    Properties:
      InstanceId: !Ref EC2Instance
      VolumeId: !Ref NewVolume
      Device: /dev/sdh
  NewVolume:
    Type: AWS::EC2::Volume
    Condition: IsProduction
    Properties:
      Size: 100
      AvailabilityZone: !GetAtt
        - EC2Instance
        - AvailabilityZone
```

### Provisioning di risorse a più condizioni
<a name="multi-condition-resource-provisioning"></a>

Gli esempi seguenti creano in modo condizionale un bucket S3 se viene fornito un nome del bucket e allegano una policy di bucket solo quando l’ambiente è impostato su `prod`. Se non viene fornito un nome del bucket o se l’ambiente è `test` , non viene creata alcuna risorsa.

#### JSON
<a name="conditions-section-example-multi-condition.json"></a>

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Parameters": {
        "EnvType": {
            "Type": "String",
            "AllowedValues": [
                "prod",
                "test"
            ]
        },
        "BucketName": {
            "Default": "",
            "Type": "String"
        }
    },
    "Conditions": {
        "IsProduction": {
            "Fn::Equals": [
                {
                    "Ref": "EnvType"
                },
                "prod"
            ]
        },
        "CreateBucket": {
            "Fn::Not": [
                {
                    "Fn::Equals": [
                        {
                            "Ref": "BucketName"
                        },
                        ""
                    ]
                }
            ]
        },
        "CreateBucketPolicy": {
            "Fn::And": [
                {
                    "Condition": "IsProduction"
                },
                {
                    "Condition": "CreateBucket"
                }
            ]
        }
    },
    "Resources": {
        "Bucket": {
            "Type": "AWS::S3::Bucket",
            "Condition": "CreateBucket",
            "Properties": {
                "BucketName": {
                    "Ref": "BucketName"
                }
            }
        },
        "Policy": {
            "Type": "AWS::S3::BucketPolicy",
            "Condition": "CreateBucketPolicy",
            "Properties": {
                "Bucket": {
                    "Ref": "Bucket"
                },
                "PolicyDocument": { ... }
            }
        }
    }
}
```

#### YAML
<a name="conditions-section-example-multi-condition.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
Parameters:
  EnvType:
    Type: String
    AllowedValues:
      - prod
      - test
  BucketName:
    Default: ''
    Type: String
Conditions:
  IsProduction: !Equals
    - !Ref EnvType
    - prod
  CreateBucket: !Not
    - !Equals
      - !Ref BucketName
      - ''
  CreateBucketPolicy: !And
    - !Condition IsProduction
    - !Condition CreateBucket
Resources:
  Bucket:
    Type: AWS::S3::Bucket
    Condition: CreateBucket
    Properties:
      BucketName: !Ref BucketName
  Policy:
    Type: AWS::S3::BucketPolicy
    Condition: CreateBucketPolicy
    Properties:
      Bucket: !Ref Bucket
      PolicyDocument: ...
```

In questo esempio, la condizione `CreateBucketPolicy` dimostra come fare riferimento ad altre condizioni utilizzando la chiave `Condition`. La policy viene creata solo quando entrambe le condizioni `IsProduction` e `CreateBucket` risultano true.

**Nota**  
Per esempi più complessi sull’utilizzo delle condizioni, consulta l’argomento [Condition attribute](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-condition.html) in *CloudFormation Template Reference Guide*.

# CloudFormation Transformsezione modello
<a name="transform-section-structure"></a>

La `Transform` sezione opzionale specifica una o più macro da CloudFormation utilizzare per elaborare in qualche modo il modello. 

Le macro possono eseguire operazioni semplici come la ricerca e la sostituzione del testo, oppure possono apportare trasformazioni più ampie all'intero modello. CloudFormation esegue le macro nell'ordine in cui sono specificate. Quando si crea un set di modifiche, CloudFormation genera un set di modifiche che include il contenuto del modello elaborato. Puoi quindi esaminare le modifiche ed eseguire il set di modifiche. Per ulteriori informazioni sul funzionamento delle macro, consulta [Esegui elaborazioni personalizzate su CloudFormation modelli con macro di modelli](template-macros.md).

CloudFormation supporta anche *le trasformazioni*, che sono macro ospitate da. CloudFormation CloudFormation tratta queste trasformazioni allo stesso modo di qualsiasi macro creata in termini di ordine e ambito di esecuzione. Per ulteriori informazioni, consulta la [documentazione di riferimento sulle trasformazioni](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/transform-reference.html).

Per dichiarare più macro, utilizza un formato di elenco e specifica una o più macro.

Ad esempio, nell'esempio di modello riportato di seguito, CloudFormation valuta `MyMacro` e quindi `AWS::Serverless` entrambi possono elaborare i contenuti dell'intero modello grazie alla loro inclusione nella sezione. `Transform`

```
# Start of processable content for MyMacro and AWS::Serverless
Transform:
  - MyMacro
  - 'AWS::Serverless'
Resources:
  WaitCondition:
    Type: AWS::CloudFormation::WaitCondition
  MyBucket:
    Type: AWS::S3::Bucket
    Properties: 
      BucketName: amzn-s3-demo-bucket
      Tags: [{"key":"value"}]
      CorsConfiguration: []
  MyEc2Instance:
    Type: AWS::EC2::Instance 
    Properties:
      ImageId: ami-1234567890abcdef0
# End of processable content for MyMacro and AWS::Serverless
```

# CloudFormation sintassi della versione in formato modello
<a name="format-version-structure"></a>

La sezione `AWSTemplateFormatVersion` (opzionale) identifica la versione del formato del modello con cui deve essere conforme il modello. La versione del modello più recente è `2010-09-09` ed è attualmente l’unico valore valido.

La versione del formato del modello non è uguale alla versione dell’API. La versione del formato del modello può variare in modo indipendente rispetto alle versioni dell’API.

Il valore della dichiarazione della versione del modello deve essere una stringa letterale. Non puoi utilizzare un parametro o una funzione per specificare la versione del modello. Se non si specifica un valore, CloudFormation si presuppone la versione più recente del formato del modello. Il seguente frammento è un esempio di una dichiarazione della versione del modello valida:

## JSON
<a name="format-version-structure-example.json"></a>

```
"AWSTemplateFormatVersion" : "2010-09-09"
```

## YAML
<a name="format-version-structure-example.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
```

# CloudFormation Descriptionsintassi del modello
<a name="template-description-structure"></a>

La sezione `Description` (facoltativa) consente di includere una stringa di testo che descrive il modello. Questa sezione deve sempre seguire la sezione relativa alla versione del modello.

Il valore della dichiarazione della descrizione deve essere una stringa letterale con una lunghezza compresa tra 0 e 1024 byte. Non puoi utilizzare un parametro o una funzione per specificare la descrizione. Il seguente frammento è un esempio di una dichiarazione della descrizione:

**Importante**  
Durante l’aggiornamento di uno stack non puoi aggiornare solo la sezione `Description`. Puoi aggiornarla solo quando includi modifiche che prevedono l’aggiunta, la modifica o l’eliminazione di risorse.

## JSON
<a name="template-description-structure-example.json"></a>

```
"Description" : "Here are some details about the template."
```

## YAML
<a name="template-description-structure-example.yaml"></a>

```
Description: > Here are some details about the template.
```

# Creazione di modelli visivi con Infrastructure Composer
<a name="infrastructure-composer-for-cloudformation"></a>

AWS Infrastructure Composer (precedentemente noto come **Application Composer**) consente di comporre e configurare visivamente applicazioni moderne su. AWS Invece di scrivere il codice, puoi trascinare e rilasciare diverse risorse per creare visivamente la tua applicazione. 

*Infrastructure Composer in modalità CloudFormation console* è lo strumento consigliato per lavorare visivamente con i modelli. CloudFormation Questa versione di Infrastructure Composer a cui è possibile accedere dalla CloudFormation console è un miglioramento rispetto a uno strumento precedente chiamato CloudFormation Designer. 

Con Infrastructure Composer in modalità CloudFormation console, puoi trascinare, rilasciare, configurare e connettere una varietà di risorse, chiamate *schede*, su un'area di disegno visiva. Questo approccio visivo semplifica la progettazione e la modifica dell’architettura dell’applicazione senza dover lavorare direttamente con i modelli. Per accedere a questa modalità dalla [CloudFormation console](https://console.aws.amazon.com/cloudformation/), seleziona **Infrastructure Composer** dal menu di navigazione a sinistra.

Per ulteriori informazioni, consulta [Come comporre su AWS Infrastructure Composer](https://docs.aws.amazon.com/infrastructure-composer/latest/dg/using-composer-basics.html) nella *Guida per gli sviluppatori di AWS Infrastructure Composer *.

## Perché usare Infrastructure Composer in modalità console? CloudFormation
<a name="app-composer-for-cloudformation-why-use"></a>

La visualizzazione dei modelli in Infrastructure Composer consente di identificare le lacune e le aree di miglioramento nei modelli e nell'architettura delle applicazioni CloudFormation . Infrastructure Composer migliora l'esperienza di sviluppo grazie alla facilità e all'efficienza della creazione e della modifica visive degli stack. CloudFormation Puoi iniziare con una bozza iniziale, creare un codice implementabile e incorporare i flussi di lavoro degli sviluppatori con il visual designer su Infrastructure Composer.

## In che modo questa modalità è diversa dalla console di Infrastructure Composer?
<a name="app-composer-for-cloudformation-differences"></a>

Sebbene la versione CloudFormation console di Infrastructure Composer abbia caratteristiche simili alla console Infrastructure Composer standard, ci sono alcune differenze. Le schede relative a Lambda (**Lambda Function** e **Lambda Layer**) richiedono build di codice e soluzioni di packaging che non sono disponibili in Infrastructure Composer in modalità console. CloudFormation Inoltre, la sincronizzazione locale non è disponibile in questa modalità.

Tuttavia, puoi utilizzare queste schede relative a Lambda e la funzionalità di sincronizzazione locale nella [console di Infrastructure Composer](https://console.aws.amazon.com/composer/home) o nel AWS Toolkit for Visual Studio Code. Per ulteriori informazioni, consulta [AWS Infrastructure Composer Developer Guide](https://docs.aws.amazon.com/infrastructure-composer/latest/dg/what-is-composer.html) e [Infrastructure Composer](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/appcomposer.html) nella *Guida per l’utente di AWS Toolkit for Visual Studio Code *.

# AWS CloudFormation Server linguistico
<a name="ide-extension"></a>

Il AWS CloudFormation Language Server offre funzionalità per accelerare la creazione infrastructure-as-code (IaC) e l'implementazione AWS delle risorse in modo sicuro e affidabile. Segue il [Language Server Protocol](https://microsoft.github.io/language-server-protocol/) (LSP) per fornire documentazione sull'hover, sul completamento automatico, sulla diagnostica tramite convalida statica, sul passaggio alla definizione e sulle azioni del codice. Oltre a queste funzionalità dei server linguistici tradizionali, il server aggiunge funzionalità online tramite le quali esplorare e distribuire le risorse. AWS CloudFormation Ciò include la possibilità di convalidare e distribuire modelli utilizzando set di modifiche, visualizzare differenze di stack, eventi, risorse e output, elencare gli stack e sfogliare le risorse per tipo e inserire lo stato delle risorse in tempo reale direttamente nei modelli. CloudFormation

**Topics**
+ [IDEs integrazione con il AWS CloudFormation Language Server](#ide-extension-supported-ides)
+ [Nozioni di base](#ide-extension-getting-started)
+ [Inizializzazione di un CloudFormation progetto nell'IDE (solo VS Code)](#ide-extension-initialize-project)
+ [Open source](#ide-extension-open-source)
+ [Serve aiuto?](#ide-extension-need-help)

## IDEs integrazione con il AWS CloudFormation Language Server
<a name="ide-extension-supported-ides"></a>

AWS fornisce off-the-shelf l'integrazione con il CloudFormation Language Server tramite il AWS Toolkit per quanto segue: IDEs
+ [Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=AmazonWebServices.aws-toolkit-vscode)
+ [JetBrains IDEs](https://plugins.jetbrains.com/plugin/11349-aws-toolkit)(versione 2025.3 o successiva), incluso IntelliJ IDEA, e WebStorm PyCharm

Quanto segue supporta IDEs anche il Language Server: CloudFormation 
+ [Kiro](https://kiro.dev/downloads/)
+ [Cursore](https://cursor.com/)
+ La maggior parte dei fork e delle distribuzioni di VS Code

Il CloudFormation Language Server aderisce al [Language Server Protocol](https://microsoft.github.io/language-server-protocol/) (LSP) e quindi altre integrazioni sono configurabili. [Per istruzioni sull'integrazione del server di lingua con altri editor, consulta la guida all'installazione.](https://github.com/aws-cloudformation/cloudformation-languageserver/blob/main/INSTALLATION.md)

## Nozioni di base
<a name="ide-extension-getting-started"></a>

**Topics**
+ [Prerequisiti](#ide-extension-prerequisites)
+ [Fase 1: Installare o aggiornare il Toolkit AWS](#ide-extension-install-toolkit)
+ [Fase 2: Accesso dal Toolkit CloudFormation AWS](#ide-extension-access-toolkit-panel)
+ [Fase 3: Convalida, testa e perfeziona il modello](#ide-extension-validate-test-refine)
+ [Passaggio 4: Naviga attraverso il modello](#ide-extension-navigate-template)
+ [Fase 5: Convalida e implementazione](#ide-extension-validate-deploy)

### Prerequisiti
<a name="ide-extension-prerequisites"></a>

Prima di iniziare, assicurati di quanto segue:
+ Stai utilizzando un IDE supportato su un sistema operativo supportato (macOSWindows, oLinux).
+ Hai installato o eseguito l'aggiornamento alla versione più recente del AWS Toolkit per il tuo IDE.

Alcune funzionalità del AWS CloudFormation Language Server richiedono credenziali attive Account AWS e configurate. È necessario accedere al proprio account Account AWS tramite il AWS Toolkit utilizzando credenziali valide.

### Fase 1: Installare o aggiornare il Toolkit AWS
<a name="ide-extension-install-toolkit"></a>

Installa o aggiorna il AWS Toolkit alla versione più recente dal gestore di estensioni o plugin del tuo IDE, quindi riavvia l'IDE.

Dopo l'installazione, il AWS Toolkit abilita automaticamente il supporto CloudFormation IDE. Quando installi o aggiorni per la prima volta il AWS Toolkit con il AWS CloudFormation Language Server, ti viene richiesto di concedere l'autorizzazione per la raccolta di dati AWS di utilizzo anonimi. Questi dati aiutano a AWS migliorare il CloudFormation Language Server e l'esperienza di creazione. Non vengono raccolte informazioni sensibili e AWS non vengono registrati o archiviati i contenuti dei modelli, le configurazioni delle risorse o i dati identificabili dei clienti. È possibile modificare le preferenze di telemetria in qualsiasi momento dalle impostazioni IDE. Riavvia l'IDE per rendere effettive le modifiche. I dati di utilizzo raccolti si concentrano solo sulle interazioni tra funzionalità e sulle metriche delle prestazioni. Queste informazioni aiutano a AWS identificare e dare priorità a miglioramenti come una convalida più rapida, il completamento automatico avanzato e una migliore diagnostica degli errori.

### Fase 2: Accesso dal Toolkit CloudFormation AWS
<a name="ide-extension-access-toolkit-panel"></a>

Dopo aver installato il AWS Toolkit, apri il CloudFormation pannello nel tuo IDE. **In VS Code, apri il pannello AWS Toolkit dalla barra delle attività e scegli CLOUDFORMATION.** In JetBrains IDEs, apri la finestra **AWS degli strumenti Toolkit** dalla barra laterale e seleziona la scheda. **CloudFormation**

Il CloudFormation pannello contiene le seguenti sezioni:
+ **Regione**: visualizza la corrente Regione AWS. In VS Code, puoi cambiarlo selezionando il nome della regione o utilizzando il comando **AWS CloudFormation: Seleziona regione** dalla palette dei comandi. In JetBrains IDEs, la regione è configurata tramite le impostazioni di connessione del AWS Toolkit.
+ **Pile**: mostra un elenco impaginato di pile presenti nel tuo CloudFormation account. Espandi uno stack per visualizzarne il nodo **Change Sets, che elenca i set** di modifiche associati a quello stack. Utilizzare l'azione Visualizza dettagli dello stack per aprire la visualizzazione dei dettagli dello stack, che mostra la panoramica dello stack, gli eventi, gli output e le risorse.
+ **Risorse**: dopo aver aggiunto un tipo di risorsa, il pannello mostra le AWS risorse di quel tipo nel tuo account. Puoi visualizzarle, aggiornarle, copiarle o importarle nel tuo modello.

****In JetBrains IDEs, la barra degli strumenti sopra l'albero consente di accedere rapidamente alle azioni più comuni, tra cui **Validate and Deploy, Rerun Validate and Deploy****, Add Resource Type e Refresh.****** Le azioni sono disponibili anche tramite i menu contestuali visualizzati con il pulsante destro del mouse sui nodi dell'albero.

### Fase 3: Convalida, testa e perfeziona il modello
<a name="ide-extension-validate-test-refine"></a>

Durante la stesura del CloudFormation modello, l'IDE fornisce assistenza di redazione intelligente per aiutarti a creare più rapidamente un'infrastruttura accurata e conforme. Il CloudFormation Language Server viene eseguito in background e fornisce le seguenti funzionalità di creazione:
+ Completamento del codice: suggerisce tipi di risorse, parametri e proprietà in base a CloudFormation schemi.
+ Aggiungi AWS risorse esistenti: consente di importare risorse esistenti dal tuo Account AWS nel tuo modello. L'IDE utilizza [AWS Cloud Control API (CCAPI)](https://docs.aws.amazon.com/cloudcontrolapi/latest/userguide/what-is-cloudcontrolapi.html) per recuperare la configurazione live e le proprietà della risorsa, aiutandovi a clonare o riutilizzare l'infrastruttura esistente all'interno del modello.
+ Estrai su parametro: quando il cursore si trova su un valore letterale in un modello (ad esempio, una stringa simile a`t2.micro`), l'IDE offre un'azione di refactoring per estrarre il valore nella `Parameters` sezione e sostituire il valore letterale con a nel nuovo parametro. `!Ref` Se lo stesso valore letterale appare in più punti, puoi scegliere di estrarre tutte le occorrenze contemporaneamente.

#### Per aggiungere risorse al modello
<a name="ide-extension-add-resources-to-template"></a>
+ **Aggiungere un tipo di risorsa**: nel CloudFormation pannello AWS Toolkit, in **Risorse**, aggiungi un tipo di risorsa da sfogliare. In VS Code, fai clic sull'icona **Aggiungi \$1** o usa il comando **AWS CloudFormation: Aggiungi tipi di risorse** dalla palette dei comandi. In JetBrains, fai clic sul pulsante **Aggiungi tipo di risorsa** nella barra degli strumenti o fai clic con il pulsante destro del mouse sul nodo **Risorse**.
+ **Cerca un tipo di risorsa**: nella finestra di dialogo di ricerca, digita il tipo di AWS risorsa che desideri aggiungere. Esempio:
  + `AWS::S3::Bucket`
  + `AWS::Lambda::Function`
+ **Sfoglia le risorse**: nella sezione **Risorse**, viene visualizzato un elenco impaginato delle AWS risorse rilevate nel tuo account. Se disponi di molte risorse, viene mostrata solo la prima pagina. Utilizza i controlli di navigazione per spostarti tra le pagine aggiuntive e visualizzare tutte le risorse disponibili.
+ Scegli la risorsa che desideri includere nel tuo modello.
+ Puoi inserire una risorsa nel modello in due modi, a seconda del tuo obiettivo:
  + **Clona una risorsa esistente**: crea una nuova risorsa nel tuo modello utilizzando la configurazione live e le proprietà di una AWS risorsa esistente.
  + **Importa una risorsa esistente**: inserisci la risorsa effettiva nello stack aggiungendola al modello utilizzando il suo stato attivo.

**Suggerimenti**
+ Puoi aggiornare la sezione **Risorse** in qualsiasi momento per visualizzare l'elenco più recente delle risorse disponibili nel tuo account o nella tua regione.
+ Se stai importando risorse, non aggiungere una risorsa che appartiene già a uno CloudFormation stack esistente nello stesso account.
+ Per confermare se una risorsa è già gestita da CloudFormation, utilizzate l'azione informativa accanto alla risorsa. In VS Code, fai clic sull'icona **i**. In JetBrains IDEs, fai clic con il pulsante destro del mouse sulla risorsa e scegli **Ottieni informazioni sulla gestione dello stack**.

##### Aggiungi risorse correlate
<a name="ide-extension-add-related-resources"></a>

In VS Code, puoi aggiungere risorse correlate alla risorsa selezionata utilizzando il comando **AWS CloudFormation: Aggiungi risorse correlate per tipo**. Dopo aver selezionato un tipo di risorsa tra quelli già definiti nel modello, l'IDE visualizza un elenco di risorse che in genere sono associate o dipendenti da quel tipo. Ad esempio, se si seleziona un`AWS::EC2::Instance`, l'IDE potrebbe suggerire di aggiungere risorse correlate come `AWS::EC2::SecurityGroup` o`AWS::EC2::Subnet`. Questa funzionalità consente di creare rapidamente componenti dell'infrastruttura connessa senza cercare manualmente tipi di risorse compatibili. Questa funzionalità non è attualmente supportata in JetBrains IDEs.

#### Convalida statica
<a name="ide-extension-static-validation"></a>

Il CloudFormation Language Server fornisce una convalida statica integrata basata su [AWS CloudFormation Linter (cfn-lint](https://github.com/aws-cloudformation/cfn-lint)) e. [AWS CloudFormation Guard](https://docs.aws.amazon.com/cfn-guard/latest/ug/what-is-guard.html) Queste convalide vengono eseguite dietro le quinte durante la creazione dei modelli e consentono di identificare errori di sintassi, lacune di conformità e problemi relativi alle best practice prima della distribuzione.

**Panoramica sulla convalida statica**

Nell'IDE vedrai due tipi di convalide statiche in tempo reale:
+ CloudFormation Linter (`cfn-lint`): convalida il modello in base alle specifiche CloudFormation delle risorse e alle regole dello schema.
+ Guard (`cfn-guard`): convalida il modello rispetto alle regole di conformità e ai pacchetti di policy organizzative.

##### CloudFormation Linter (cfn-lint)
<a name="ide-extension-cfn-linter-details"></a>

 CloudFormation Linter è integrato nell'IDE per controllare automaticamente la sintassi e la struttura del modello durante la digitazione.
+ **Convalida dello schema**: rileva gli errori di sintassi e schema per garantire che i modelli siano conformi allo schema delle risorse. CloudFormation
+ **Evidenziazione degli errori**: visualizza i marker in linea sotto i problemi, che rappresentano avvisi o blocchi di distribuzione.
+ **Guida al passaggio del mouse**: quando passi il mouse su un errore, l'IDE mostra il messaggio di diagnostica associato a quel problema. Se è disponibile una soluzione rapida, viene offerta anche questa.

##### Integrazione con Guard
<a name="ide-extension-cfn-guard-integration"></a>

Guard convalida i tuoi modelli in base a set di regole che definiscono le politiche di conformità e sicurezza. L'IDE esegue le convalide Guard in tempo reale tramite il CloudFormation Language Server, offrendoti un feedback immediato durante la creazione dei modelli.
+ **Pacchetti di regole predefiniti**: l'IDE include un set preregistrato di regole Guard incentrate sulle migliori pratiche fondamentali per la sicurezza delle risorse e l'igiene della configurazione. Per saperne di più, consulta [il Guard Rule Registry](https://github.com/aws-cloudformation/aws-guard-rules-registry).
+ **Aggiungere pacchetti di regole**: per aggiungere o modificare set di regole, apri le impostazioni IDE e vai alla sezione di configurazione di Guard per selezionare o caricare pacchetti di regole Guard aggiuntivi.

**Suggerimenti**: comprensione degli indicatori diagnostici
+ Indicatori blu: suggerimenti sulle migliori pratiche o consigli di ottimizzazione.
+ Indicatori gialli: avvisi relativi a problemi non bloccanti (ad esempio, tag o parametri mancanti).
+ Indicatori rossi: ostacoli alla distribuzione, ad esempio nomi di proprietà non validi, campi obbligatori mancanti o mancanti corrispondenze dello schema.

### Passaggio 4: Naviga attraverso il modello
<a name="ide-extension-navigate-template"></a>

L'IDE fornisce una visualizzazione strutturata e gerarchica del CloudFormation modello, organizzata in sezioni quali`Parameters`,, e `Resources` `Outputs``Mappings`, che mostrano ogni tipo di risorsa e ID logico. Ciò semplifica l'individuazione e la navigazione rapida di risorse o parametri specifici all'interno di modelli di grandi dimensioni. In VS Code, il pannello **Outline** nella barra laterale di **Explorer** mostra questa struttura. In JetBrains IDEs, apri la finestra dello strumento **Struttura** per visualizzare la struttura del modello per il file attualmente aperto.

È possibile utilizzare **Vai alla definizione** per funzioni intrinseche come `GetAtt` e`Ref`, che consente di passare direttamente alla risorsa o al parametro di riferimento nel modello. Ciò consente di tracciare le dipendenze, comprendere le relazioni tra le risorse e apportare modifiche in modo più efficiente.

### Fase 5: Convalida e implementazione
<a name="ide-extension-validate-deploy"></a>

Quando sei pronto per distribuire il CloudFormation modello, usa la funzionalità Convalida e distribuisci per creare un set di modifiche. [L'IDE convalida il modello e, se non vengono rilevati errori di blocco, procede alla creazione di un set di modifiche in grado di rilevare la deriva.](drift-aware-change-sets.md) L'IDE mostra quindi una visualizzazione differenziale in modo da poter esaminare tutte le modifiche proposte prima di eseguire il set di modifiche.

In VS Code, apri la palette dei comandi ed esegui **AWS CloudFormation: Validate and Deploy**. La palette dei comandi ti guida passo dopo passo nella selezione di un modello, del nome dello stack, dei parametri, delle funzionalità e di altre opzioni di distribuzione. In JetBrains IDEs, utilizzate il pulsante **Validate and Deploy** della barra degli strumenti, fate clic con il pulsante destro del mouse su un file modello nell'editor o fate clic con il pulsante destro del mouse su una pila nell'albero. JetBrains presenta una finestra di dialogo guidata in cui è possibile configurare tutte le opzioni di distribuzione, tra cui la selezione del modello, il nome dello stack, i parametri, le funzionalità, i tag e le opzioni avanzate.

#### Come funziona la convalida
<a name="ide-extension-how-validation-works"></a>

L'IDE esegue automaticamente un [controllo di convalida prima della distribuzione](validate-stack-deployments.md) e convalida il modello in base alle cause di errore più comuni, tra cui:
+ Errori nella sintassi delle proprietà o nello schema non validi: questi problemi vengono in genere rilevati `cfn-lint` durante la creazione, ma se si procede alla distribuzione senza risolverli, la convalida in fase di implementazione evidenzia gli stessi errori prima della creazione o CloudFormation dell'aggiornamento dello stack.
+ Il nome della risorsa è in conflitto con le risorse esistenti nel tuo account.
+ Vincoli specifici del servizio, come i conflitti tra i nomi dei bucket S3 o la mancanza di crittografia.

Se la convalida rileva errori, l'IDE evidenzia i problemi direttamente nel modello e li elenca nel pannello di diagnostica. Ogni problema include la proprietà o la risorsa specifica che ha causato l'errore, insieme a una correzione suggerita. Se non sono presenti errori di blocco, puoi procedere alla fase di distribuzione.

Se vengono rilevati avvisi (problemi non bloccanti), viene visualizzata una finestra di dialogo che consente di procedere con la distribuzione o annullare e apportare correzioni.

L'IDE apre un [set di modifiche in base alla deriva](drift-aware-change-sets.md) che mostra le eventuali differenze tra il modello corrente e la configurazione dello stack distribuito. Ciò consente di rivedere, confermare o annullare il set di modifiche prima dell'esecuzione. L'annullamento della distribuzione elimina il set di modifiche.

I set di modifiche sensibili alla deriva migliorano il processo di CloudFormation implementazione consentendo di gestire la deriva dello stack in modo sicuro. La deriva dello stack si verifica quando lo stato effettivo delle risorse è diverso da quello definito nel CloudFormation modello, spesso a causa di modifiche manuali apportate tramite Console di gestione AWS CLI o SDK. CloudFormation I [set di modifiche in base alla deriva](drift-aware-change-sets.md) confrontano la configurazione dello stack elaborato con lo stato delle risorse in tempo reale e l'IDE evidenzia queste differenze in modo da poter ripristinare la conformità delle risorse prima della distribuzione.

#### Visualizzare gli eventi dello stack
<a name="ide-extension-view-stack-events"></a>

All'avvio della distribuzione, è possibile monitorare l'avanzamento in tempo reale dal pannello. CloudFormation In **Stack Events**, viene visualizzato un elenco di operazioni eseguite durante la distribuzione. Ogni evento include dettagli come:
+ **Timestamp**: l'ora in cui si è verificato l'evento
+ **Risorsa**: la AWS risorsa specifica che viene creata, aggiornata o eliminata
+ **Stato: lo** stato corrente dell'operazione (ad esempio`CREATE_IN_PROGRESS`,`UPDATE_COMPLETE`, o`ROLLBACK_IN_PROGRESS`)
+ **Motivo**: messaggi di contesto o di errore aggiuntivi, se applicabile

Da questo pannello puoi anche visualizzare le **risorse** e **gli output** dello stack. La visualizzazione **Stack Events** consente di tenere traccia dell'avanzamento dell'implementazione, identificare potenziali problemi e confermare se lo stack è stato completato correttamente.

## Inizializzazione di un CloudFormation progetto nell'IDE (solo VS Code)
<a name="ide-extension-initialize-project"></a>

L'inizializzazione di un CloudFormation progetto nell'IDE consente di configurare uno spazio di lavoro strutturato con le cartelle, la configurazione dell'ambiente e le AWS credenziali corrette in modo da poter convalidare e distribuire i modelli in modo affidabile. È possibile inizializzare un nuovo CloudFormation progetto direttamente dall'IDE per creare questa configurazione consigliata. Questa funzionalità è attualmente disponibile solo in VS Code e non è supportata in JetBrains IDEs.

**Per inizializzare un CloudFormation progetto:**
+ **Aprire la palette dei comandi**
  + Da VS Code, apri la palette dei comandi (`Ctrl+Shift+P`o `Cmd+Shift+P` attivamacOS).
  + Scegli **AWS CloudFormation: CFN Init: Initialize** Project.
+ **Scegli una cartella di progetto**
  + Per impostazione predefinita, l'IDE utilizza la directory di lavoro corrente.
  + È possibile modificare questo percorso in qualsiasi cartella in cui si desidera archiviare i CloudFormation modelli.
+ **Seleziona il tuo profilo di AWS credenziali**
  + Ti viene richiesto di scegliere un profilo di AWS credenziali. Il profilo selezionato viene utilizzato per il rilevamento, le convalide e le distribuzioni dell'ambiente.
+ **Configura il tuo ambiente**
  + Ti viene richiesto di creare o selezionare un ambiente.
  + Gli ambienti definiscono dove e come i modelli vengono distribuiti o convalidati (ad esempio, sviluppo, versione beta o produzione). Puoi usare **AWS CloudFormation: CFN Init: Add Environment per selezionare o modificare il tuo ambiente**.
  + Puoi usare **AWS CloudFormation: CFN Init: Remove Environment per rimuovere l'ambiente** che hai selezionato.
+ **(Facoltativo) Importa i file dei parametri**
  + Se disponete già di file di parametri esistenti, l'IDE consente di importarli durante l'inizializzazione.
  + L'IDE rileva automaticamente i file compatibili e li collega al progetto per utilizzarli nella convalida e nella distribuzione dei modelli.
+ **Assegna un nome e finalizza il progetto**
  + Fornisci un nome per il progetto, ad esempio beta-environment, e completa la configurazione.
  + L'IDE crea automaticamente la struttura iniziale del progetto e il file di configurazione.

È possibile eseguire convalide, visualizzare in anteprima le distribuzioni o passare da un ambiente all'altro direttamente dall'IDE.

## Open source
<a name="ide-extension-open-source"></a>

Il AWS CloudFormation Language Server è open source con Apache-2.0 licenza e offre ai clienti la massima trasparenza su come vengono eseguite la diagnostica dei modelli, la convalida dello schema e l'analisi statica. In questo modo si riducono le difficoltà legate alla sicurezza e alla conformità per i clienti che richiedono una visibilità a livello di sorgente prima di adottare gli strumenti.

[Il codice base è disponibile pubblicamente su: cloudformation-languageserver/. GitHub https://github.com/aws-cloudformation/](https://github.com/aws-cloudformation/cloudformation-languageserver/)

## Serve aiuto?
<a name="ide-extension-need-help"></a>

[CloudFormationProva](https://repost.aws/tags/TAm3R3LNU3RfSX9L23YIpo3w) AWS re:Post la community su.

# Generazione di modelli da risorse esistenti con il generatore IaC
<a name="generate-IaC"></a>

Con l' CloudFormation infrastruttura come generatore di codice (generatore IaC), puoi generare un modello utilizzando AWS risorse fornite nel tuo account che non sono già gestite da. CloudFormation 

Di seguito sono elencati i vantaggi del generatore IaC:
+  CloudFormation Gestisci intere applicazioni o migrale in un'app. AWS CDK 
+ Genera modelli senza dover descrivere una risorsa per singola proprietà e poi li traduce in sintassi JSON o YAML.
+ Usa il modello per replicare le risorse in un nuovo account o regione.

Il processo di generazione IaC consiste nei seguenti passaggi:

1. **Scansionare le risorse**: il primo passaggio consiste nell’avviare una scansione delle risorse. Questa scansione è valida per tutta la regione e scade dopo 30 giorni. Durante questo periodo puoi creare più modelli dalla stessa scansione.

1. **Creare il modello**: per creare il modello sono disponibili due opzioni:
   + Creare un nuovo modello da zero e aggiungere le risorse scansionate e le risorse correlate.
   + Usa uno CloudFormation stack esistente come punto di partenza e aggiungi le risorse scansionate e le risorse correlate al relativo modello.

1. **Importa risorse**: utilizza il modello per importare le risorse come CloudFormation pila o migrarle in un'app. AWS CDK 

La funzionalità del generatore IaC è disponibile in tutte le regioni commerciali e supporta molti tipi comuni di risorse AWS . Per un elenco dei tipi di risorse supportati, consulta [Supporto del tipo di risorse](resource-import-supported-resources.md).

**Topics**
+ [Considerazioni](#iac-generator-considerations)
+ [Autorizzazioni IAM richieste per la scansione delle risorse](#iac-generator-permissions)
+ [Comandi comunemente utilizzati per la generazione, la gestione e l’eliminazione dei modelli](#iac-generator-commonly-used-commands)
+ [Esegui la migrazione di un modello verso AWS CDK](#iac-generator-cdk-migrate)
+ [Avvia una scansione delle risorse con il generatore CloudFormation IAc](iac-generator-start-resource-scan.md)
+ [Visualizza il riepilogo della scansione nella CloudFormation console](generate-IaC-view-scan-summary.md)
+ [Crea un CloudFormation modello da risorse scansionate con il generatore IAc](iac-generator-create-template-from-scanned-resources.md)
+ [Crea uno CloudFormation stack da risorse scansionate](iac-generator-create-stack-from-scanned-resources.md)
+ [Risoluzione delle proprietà di sola scrittura](generate-IaC-write-only-properties.md)

## Considerazioni
<a name="iac-generator-considerations"></a>

Puoi generare modelli JSON o YAML per AWS risorse a cui hai accesso in lettura. I modelli per la funzionalità del generatore IaC modellano le risorse cloud in modo affidabile e rapido senza dover descrivere una risorsa per singola proprietà.

Nella tabella seguente sono elencate le quote disponibili per la funzionalità di generazione IaC.


| Name | Scansione completa | Scansione parziale | 
| --- | --- | --- | 
|  Numero massimo di risorse che possono essere elaborate in una scansione  |  100.000  |  100.000  | 
|  Numero di scansioni al giorno (per scansioni con meno di 10.000 risorse)  |  10  |  10  | 
|  Numero di scansioni al giorno (per scansioni con più di 10.000 risorse)  |  1  |  1  | 
|  Numero simultaneo di modelli generati per account  |  5  |  5  | 
|  Numero simultaneo di risorse modellate per una generazione di modelli  |  5  |  5  | 
|  Numero totale di risorse che possono essere modellate in un modello  |  500  |  500  | 
|  Numero massimo di modelli di messaggio per account  |  1.000  |  1.000  | 

**Importante**  
Il generatore IaC supporta solo AWS le risorse supportate dall'API Cloud Control nella tua regione. Per ulteriori informazioni, consulta [Supporto del tipo di risorse](resource-import-supported-resources.md).

## Autorizzazioni IAM richieste per la scansione delle risorse
<a name="iac-generator-permissions"></a>

Per eseguire la scansione delle risorse con il generatore IaC, la IAM principale (utente, ruolo o gruppo) deve disporre di:
+ CloudFormation autorizzazioni di scansione
+ Autorizzazioni di lettura per i servizi di destinazione AWS 

L’ambito di scansione è limitato alle risorse a cui hai accesso in lettura. Le autorizzazioni mancanti non causeranno errori di scansione ma escluderanno tali risorse.

Consultare [Consenti tutte le operazioni dei generatori di IaC](security_iam_id-based-policy-examples.md#iam-policy-example-for-iac-generator) per una policy IAM di esempio che concede le autorizzazioni per la scansione e la gestione dei modelli.

## Comandi comunemente utilizzati per la generazione, la gestione e l’eliminazione dei modelli
<a name="iac-generator-commonly-used-commands"></a>

I comandi comunemente utilizzati per operare con il generatore IaC includono: 
+ [start-resource-scan](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/start-resource-scan.html)per avviare una scansione delle risorse dell'account in un Regione AWS. 
+ [describe-resource-scan](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-resource-scan.html)per monitorare lo stato di avanzamento di una scansione delle risorse. 
+ [list-resource-scans](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-resource-scans.html)per elencare le scansioni delle risorse in un Regione AWS.
+ [list-resource-scan-resources](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-resource-scan-resources.html)per elencare le risorse trovate durante la scansione delle risorse.
+  [list-resource-scan-related-resources](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-resource-scan-related-resources.html) per elencare le risorse relative alle risorse scansionate.
+ [create-generated-template](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-generated-template.html)per generare un CloudFormation modello da un insieme di risorse scansionate.
+ [update-generated-template](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/update-generated-template.html)per aggiornare il modello generato.
+ [describe-generated-template](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-generated-template.html)per restituire informazioni su un modello generato.
+ [list-generated-templates](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-generated-templates.html)per elencare tutti i modelli generati nel tuo account e nella regione corrente.
+ [delete-generated-template](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/delete-generated-template.html)per eliminare un modello generato.

## Esegui la migrazione di un modello verso AWS CDK
<a name="iac-generator-cdk-migrate"></a>

 AWS Cloud Development Kit (AWS CDK) è un framework di sviluppo software open source che è possibile utilizzare per sviluppare, gestire e distribuire CloudFormation risorse utilizzando i linguaggi di programmazione più diffusi.

La AWS CDK CLI fornisce un'integrazione con il generatore IAc. Usa il `cdk migrate` comando AWS CDK CLI per convertire il CloudFormation modello e creare una nuova app CDK che contenga le tue risorse. Quindi, puoi utilizzare il AWS CDK per gestire le tue risorse e distribuirle su. CloudFormation

Per ulteriori informazioni, consulta [Migrate to AWS CDK](https://docs.aws.amazon.com/cdk/v2/guide/migrate.html) nella *Guida per gli sviluppatori di AWS Cloud Development Kit (AWS CDK) *.

# Avvia una scansione delle risorse con il generatore CloudFormation IAc
<a name="iac-generator-start-resource-scan"></a>

Prima di creare un modello da risorse esistenti, devi avviare una scansione delle risorse per scoprire quelle attuali e le loro relazioni.

Puoi avviare una scansione delle risorse utilizzando una delle opzioni seguenti. Per gli utenti alle prime armi con il generatore IaC, consigliamo la prima opzione.
+ **Scansiona tutte le risorse (scansione completa)**: esegue la scansione di tutte le risorse esistenti nell’account e nella regione attuali. Questo processo di scansione può richiedere fino a 10 minuti per 1.000 risorse.
+ **Scansione di risorse specifiche (scansione parziale)**: seleziona manualmente i tipi di risorse da scansionare nell’account e nella regione attuali. Questa opzione offre un processo di scansione più rapido e mirato, il che la rende ideale per lo sviluppo iterativo di modelli.

Una volta completata la scansione, puoi scegliere le risorse e le risorse correlate da includere nella generazione del modello. Quando utilizzi la scansione parziale, le risorse correlate saranno disponibili durante la generazione del modello solo se:
+ le hai selezionate specificamente prima di iniziare la scansione, oppure
+ erano necessarie per scoprire i tipi di risorse selezionati. 

Ad esempio, se selezioni `AWS::EKS::Nodegroup` senza selezionare `AWS::EKS::Cluster`, il generatore IaC include automaticamente le risorse `AWS::EKS::Cluster` nella scansione perché la scoperta del gruppo di nodi richiede prima la scoperta del cluster. In tutti gli altri casi, la scansione includerà solo le risorse selezionate in modo specifico.

**Nota**  
Prima di continuare, verifica di disporre delle autorizzazioni necessarie per lavorare con il generatore IaC. Per ulteriori informazioni, consulta [Autorizzazioni IAM richieste per la scansione delle risorse](generate-IaC.md#iac-generator-permissions).

**Topics**
+ [Avvio di una scansione delle risorse (console)](#start-resource-scan-console)
+ [Avvio di una scansione delle risorse (AWS CLI)](#start-resource-scan-cli)

## Avvio di una scansione delle risorse (console)
<a name="start-resource-scan-console"></a>

**Avvio di una scansione delle risorse di tutti i tipi (scansione completa)**

1. Apri la [pagina del generatore IAc](https://console.aws.amazon.com/cloudformation/home?#iac-generator) della CloudFormation console.

1. Nella barra di navigazione, nella parte superiore della schermata, seleziona la Regione AWS che contiene le risorse da scansionare.

1. Dal pannello **Scansioni**, scegli **Avvia una nuova scansione**, quindi scegli **Scansiona tutte le risorse**. 

**Avvio di una scansione delle risorse di tipi specifici (scansione parziale)**

1. Apri la [pagina del generatore IaC](https://console.aws.amazon.com/cloudformation/home?#iac-generator) della CloudFormation console.

1. Nella barra di navigazione, nella parte superiore della schermata, seleziona la Regione AWS che contiene le risorse da scansionare.

1. Dal pannello **Scansioni**, scegli **Avvia una nuova scansione**, quindi scegli **Scansiona risorse specifiche**. 

1. Nella finestra di dialogo **Avvia scansione parziale** seleziona fino a 100 tipi di risorse, quindi scegli **Avvia scansione**. 

## Avvio di una scansione delle risorse (AWS CLI)
<a name="start-resource-scan-cli"></a>

**Avvio di una scansione delle risorse di tutti i tipi (scansione completa)**  
Utilizza il seguente comando [start-resource-scan](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/start-resource-scan.html). Sostituisci *us-east-1* con Regione AWS quello che contiene le risorse da scansionare.

```
aws cloudformation start-resource-scan --region us-east-1
```

In caso di esito positivo, il comando restituisce l’ARN della scansione. Annota l’ARN della proprietà `ResourceScanId`. Ti serve per creare il tuo modello.

```
{
    "ResourceScanId":
      "arn:aws:cloudformation:region:account-id:resourceScan/0a699f15-489c-43ca-a3ef-3e6ecfa5da60"
}
```

**Avvio di una scansione delle risorse di tipi specifici (scansione parziale)**

1. Usa il seguente comando [cat](https://en.wikipedia.org/wiki/Cat_(Unix)) per memorizzare i tipi di risorse che desideri scansionare in un file JSON denominato `config.json` nella tua home directory. Di seguito è riportato un esempio di configurazione di scansione che analizza le istanze Amazon EC2, i gruppi di sicurezza e tutte le risorse Amazon S3.

   ```
   $ cat > config.json
   [
     {
       "Types":[
         "AWS::EC2::Instance",
         "AWS::EC2::SecurityGroup",
         "AWS::S3::*"
       ]
     }
   ]
   ```

1. Utilizzate il [start-resource-scan](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/start-resource-scan.html)comando con l'`--scan-filters`opzione, insieme al `config.json` file creato, per avviare la scansione parziale. Sostituisci *us-east-1* con Regione AWS quello che contiene le risorse da scansionare.

   ```
   aws cloudformation start-resource-scan --scan-filters file://config.json --region us-east-1
   ```

   In caso di esito positivo, il comando restituisce l’ARN della scansione. Annota l’ARN della proprietà `ResourceScanId`. Ti serve per creare il tuo modello.

   ```
   {
       "ResourceScanId":
         "arn:aws:cloudformation:region:account-id:resourceScan/0a699f15-489c-43ca-a3ef-3e6ecfa5da60"
   }
   ```

**Monitoraggio dello stato di avanzamento di una scansione delle risorse**  
Utilizza il comando [describe-resource-scan](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-resource-scan.html). Per l’opzione `--resource-scan-id`, sostituisci l’ARN di esempio con quello effettivo.

```
aws cloudformation describe-resource-scan --region us-east-1 \
  --resource-scan-id arn:aws:cloudformation:us-east-1:123456789012:resourceScan/0a699f15-489c-43ca-a3ef-3e6ecfa5da60
```

Se il comando viene eseguito correttamente, verrà visualizzato un output simile al seguente: 

```
{
    "ResourceScanId": "arn:aws:cloudformation:region:account-id:resourceScan/0a699f15-489c-43ca-a3ef-3e6ecfa5da60",
    "Status": "COMPLETE",
    "StartTime": "2023-08-21T03:10:38.485000+00:00",
    "EndTime": "2023-08-21T03:20:28.485000+00:00",
    "PercentageCompleted": 100.0,
    "ResourceTypes": [
        "AWS::CloudFront::CachePolicy",
        "AWS::CloudFront::OriginRequestPolicy",
        "AWS::EC2::DHCPOptions",
        "AWS::EC2::InternetGateway",
        "AWS::EC2::KeyPair",
        "AWS::EC2::NetworkAcl",
        "AWS::EC2::NetworkInsightsPath",
        "AWS::EC2::NetworkInterface",
        "AWS::EC2::PlacementGroup",
        "AWS::EC2::Route",
        "AWS::EC2::RouteTable",
        "AWS::EC2::SecurityGroup",
        "AWS::EC2::Subnet",
        "AWS::EC2::SubnetCidrBlock",
        "AWS::EC2::SubnetNetworkAclAssociation",
        "AWS::EC2::SubnetRouteTableAssociation",
        ...
    ],
    "ResourcesRead": 676
}
```

Per una scansione parziale, l’output risulterà simile al seguente: 

```
{
    "ResourceScanId": "arn:aws:cloudformation:region:account-id:resourceScan/0a699f15-489c-43ca-a3ef-3e6ecfa5da60",
    "Status": "COMPLETE",
    "StartTime": "2025-03-06T18:24:19.542000+00:00",
    "EndTime": "2025-03-06T18:25:23.142000+00:00",
    "PercentageCompleted": 100.0,
    "ResourceTypes": [
        "AWS::EC2::Instance",
        "AWS::EC2::SecurityGroup",
        "AWS::S3::Bucket",
        "AWS::S3::BucketPolicy"
    ],
    "ResourcesRead": 65,
    "ScanFilters": [
        {
            "Types": [
                "AWS::EC2::Instance",
                "AWS::EC2::SecurityGroup",
                "AWS::S3::*"
            ]
        }
    ]
}
```

Per una descrizione dei campi dell'output, consulta [DescribeResourceScan](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_DescribeResourceScan.html)l'*AWS CloudFormation API Reference*.

# Visualizza il riepilogo della scansione nella CloudFormation console
<a name="generate-IaC-view-scan-summary"></a>

Una volta completata la scansione, puoi aprire una visualizzazione delle risorse trovate durante la scansione per individuare la concentrazione di risorse tra diversi tipi di prodotto.

**Per visualizzare le informazioni sulle risorse trovate durante la scansione:**

1. Apri la [pagina del generatore iAc](https://console.aws.amazon.com/cloudformation/home?#iac-generator) della CloudFormation console.

1. Nella barra di navigazione nella parte superiore dello schermo, scegli Regione AWS la scansione delle risorse da visualizzare.

1. Nel riquadro di navigazione scegli **Generatore IaC**.

1. In **Suddivisione risorse scansionate**, troverai una suddivisione visiva delle risorse scansionate per tipo di prodotto, ad esempio **Calcolo** e **Archiviazione**. 

1. Per personalizzare il numero di tipi di prodotto visualizzati, scegli **Filtra i dati visualizzati**. Questa opzione ti aiuta a personalizzare la visualizzazione per concentrarti sui tipi di prodotto che ti interessano di più.

1. Sul lato destro della pagina è presente il pannello **Dettagli riepilogo scansione**. Scegli l’icona **Apri pannello** per aprirlo.

![\[La console del generatore IaC fornisce una suddivisione visiva delle risorse scansionate.\]](http://docs.aws.amazon.com/it_it/AWSCloudFormation/latest/UserGuide/images/IaC-generator-scan-summary.png)


# Crea un CloudFormation modello da risorse scansionate con il generatore IAc
<a name="iac-generator-create-template-from-scanned-resources"></a>

In questo argomento viene descritto come creare un modello da risorse che sono state scansionate utilizzando la funzionalità del generatore IaC. 

## Creazione di un modello da risorse scansionate (console)
<a name="create-template-from-scanned-resources-console"></a>

**Creazione di un modello di stack da risorse scansionate**

1. Apri la [pagina del generatore IAc](https://console.aws.amazon.com/cloudformation/home?#iac-generator) della console. CloudFormation 

1. Nella barra di navigazione, nella parte superiore della schermata, seleziona la Regione AWS che contiene le risorse analizzate.

1. Nella sezione **Modelli**, scegli **Crea modello**. 

1. Scegli **Inizia da un nuovo modello**.

   1. In **Nome modello**, digita un nome per il modello.

   1. (Facoltativo) Configura la **Policy di eliminazione** e la **Policy di aggiornamento e sostituzione**.

   1. Scegli **Avanti** per aggiungere risorse scansionate al modello.

1. Per **Aggiungi risorse scansionate**, sfoglia l’elenco delle risorse scansionate e seleziona quelle che desideri aggiungere al modello. Puoi filtrare le risorse per identificatore di risorsa, tipo di risorsa o tag. I filtri sono mutualmente inclusivi.

1. Dopo aver aggiunto tutte le risorse necessarie al modello, scegli **Avanti** per uscire dalla pagina **Aggiungi risorse scansionate** e passare alla pagina **Aggiungi risorse correlate**.

1. Consulta l’elenco consigliato di risorse correlate. Le risorse correlate, come le istanze e i gruppi di sicurezza di Amazon EC2, sono interdipendenti e in genere appartengono allo stesso carico di lavoro. Seleziona le risorse correlate da includere nel modello generato.
**Nota**  
Ti suggeriamo di aggiungere tutte le risorse correlate a questo modello.

1. Esamina i dettagli del modello, le risorse scansionate e le risorse correlate. 

1. Scegli **Crea modello** per uscire dalla pagina **Revisione e creazione** e creare il modello.

## Creazione di un modello da risorse scansionate (AWS CLI)
<a name="create-template-from-scanned-resources-cli"></a>

**Creazione di un modello di stack da risorse scansionate**

1. Utilizzate il [list-resource-scan-resources](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-resource-scan-resources.html)comando per elencare le risorse trovate durante la scansione, specificando facoltativamente l'`--resource-identifier`opzione per limitare l'output. Per l’opzione `--resource-scan-id`, sostituisci l’ARN di esempio con quello effettivo.

   ```
   aws cloudformation list-resource-scan-resources \
     --resource-scan-id arn:aws:cloudformation:us-east-1:123456789012:resourceScan/0a699f15-489c-43ca-a3ef-3e6ecfa5da60 \
     --resource-identifier MyApp
   ```

   Di seguito è riportato un esempio di risposta, in cui `ManagedByStack` indica se CloudFormation gestisce già la risorsa. Copia l’output. Servirà per la fase successiva.

   ```
   {
       "Resources": [
           {
               "ResourceType": "AWS::EKS::Cluster",
               "ResourceIdentifier": {
                   "ClusterName": "MyAppClusterName"
               },
               "ManagedByStack": false
           },
           {
               "ResourceType": "AWS::AutoScaling::AutoScalingGroup",
               "ResourceIdentifier": {
                   "AutoScalingGroupName": "MyAppASGName"
               },
               "ManagedByStack": false
           }
       ]
   }
   ```

   Per una descrizione dei campi nell'output, consulta [ScannedResource](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_ScannedResource.html)l'*AWS CloudFormation API Reference*.

1. Usa il comando `cat` per memorizzare i tipi di risorse e gli identificatori in un file JSON denominato `resources.json` nella tua home directory. Di seguito è riportato un JSON di esempio basato sull’output di esempio precedente.

   ```
   $ cat > resources.json
   [
       {
           "ResourceType": "AWS::EKS::Cluster",
           "ResourceIdentifier": {
               "ClusterName": "MyAppClusterName"
           }
       },
       {
           "ResourceType": "AWS::AutoScaling::AutoScalingGroup",
           "ResourceIdentifier": {
               "AutoScalingGroupName": "MyAppASGName"
           }
       }
   ]
   ```

1. Usa il comando [list-resource-scan-related-resources](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-resource-scan-related-resources.html), insieme al `resources.json` file che hai creato, per elencare le risorse relative alle risorse scansionate.

   ```
   aws cloudformation list-resource-scan-related-resources \
     --resource-scan-id arn:aws:cloudformation:us-east-1:123456789012:resourceScan/0a699f15-489c-43ca-a3ef-3e6ecfa5da60 \
     --resources file://resources.json
   ```

   Di seguito è riportato un esempio di risposta, in cui `ManagedByStack` indica se CloudFormation gestisce già la risorsa. Aggiungi queste risorse al file JSON creato nella fase precedente. Sarà necessario per creare il modello.

   ```
   {
       "RelatedResources": [
           {
               "ResourceType": "AWS::EKS::Nodegroup",
               "ResourceIdentifier": {
                   "NodegroupName": "MyAppNodegroupName"
               },
               "ManagedByStack": false
           },
           {
               "ResourceType": "AWS::IAM::Role",
               "ResourceIdentifier": {
                   "RoleId": "arn:aws::iam::account-id:role/MyAppIAMRole"
               },
               "ManagedByStack": false
           }
       ]
   }
   ```

   Per una descrizione dei campi nell'output, consulta [ScannedResource](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_ScannedResource.html)l'*AWS CloudFormation API Reference*.
**Nota**  
L’elenco di risorse di input non può superare il valore 100. Per elencare le risorse correlate per più di 100 risorse, esegui il comando **list-resource-scan-related-resources** in batch da 100 e consolida i risultati.  
Tieni presente che l’output può contenere risorse duplicate nell’elenco.

1. Utilizzate il [create-generated-template](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-generated-template.html)comando per creare un nuovo modello di stack, come segue, con queste modifiche:
   + Sostituisci `us-east-1` con quello Regione AWS che contiene le risorse scansionate.
   + Sostituisci `MyTemplate` con il nome del modello da creare.

   ```
   aws cloudformation create-generated-template --region us-east-1 \
    --generated-template-name MyTemplate \
     --resources file://resources.json
   ```

   Di seguito è riportato un esempio del file `resources.json`.

   ```
   [
       {
           "ResourceType": "AWS::EKS::Cluster",
           "LogicalResourceId":"MyCluster",
           "ResourceIdentifier": {
               "ClusterName": "MyAppClusterName"
           }
       },
       {
           "ResourceType": "AWS::AutoScaling::AutoScalingGroup",
           "LogicalResourceId":"MyASG",
           "ResourceIdentifier": {
               "AutoScalingGroupName": "MyAppASGName"
           }
       },
       {
           "ResourceType": "AWS::EKS::Nodegroup",
           "LogicalResourceId":"MyNodegroup",
           "ResourceIdentifier": {
               "NodegroupName": "MyAppNodegroupName"
           }
       },
       {
           "ResourceType": "AWS::IAM::Role",
           "LogicalResourceId":"MyRole",
           "ResourceIdentifier": {
               "RoleId": "arn:aws::iam::account-id:role/MyAppIAMRole"
           }
       }
   ]
   ```

   In caso di esito positivo, il comando restituisce la risposta seguente.

   ```
   {
     "Arn":
       "arn:aws:cloudformation:region:account-id:generatedtemplate/7fc8512c-d8cb-4e02-b266-d39c48344e48",
     "Name": "MyTemplate"
   }
   ```

# Crea uno CloudFormation stack da risorse scansionate
<a name="iac-generator-create-stack-from-scanned-resources"></a>

Dopo aver creato il modello, puoi visualizzare in anteprima il modello generato con Infrastructure Composer prima di creare lo stack e importare le risorse scansionate. Ciò consente di visualizzare l’architettura completa dell’applicazione con le risorse e le relative relazioni. Per ulteriori informazioni su Infrastructure Composer, consulta [Creazione di modelli visivi con Infrastructure Composer](infrastructure-composer-for-cloudformation.md).

**Creazione dello stack e importazione delle risorse scansionate**

1. Apri la [pagina del generatore IaC](https://console.aws.amazon.com/cloudformation/home?#iac-generator) della console. CloudFormation 

1. Nella barra di navigazione nella parte superiore dello schermo, scegli il modello Regione AWS per il tuo modello.

1. Scegli la scheda **Modelli**, quindi scegli il nome del modello per visualizzare ulteriori informazioni.

1. Nella scheda **Definizione modello**, nella parte superiore della sezione **Modello**, puoi cambiare il modello dalla sintassi YAML a quella JSON in base alle tue preferenze. 

1. Esamina i dettagli del modello per assicurarti che tutto sia corretto. Per semplificare la revisione e la comprensione del modello, puoi passare dalla visualizzazione del codice predefinita a una visualizzazione grafica dell’infrastruttura descritta nel modello utilizzando Infrastructure Composer. Per fare ciò, in **Modello**, scegli **Canvas** anziché **Modello**.

    **Azioni Canvas** 
   + Per concentrarti sui dettagli di una risorsa specifica all’interno del modello, fai doppio clic su una scheda per visualizzare il pannello **Proprietà della risorsa**.
   + Per disporre e organizzare visivamente le schede sui canvas, scegli **Disponi** nella parte superiore sinistra dell’area di disegno. 
   + Per ingrandire e rimpicciolire il canvas, usa i controlli di zoom in basso a destra del canvas. 

1. Per visualizzare una risorsa specifica nella console, scegli la scheda **Risorse modello**, quindi scegli l’ID fisico della risorsa che vuoi consultare. Ciò ti reindirizzerà alla console relativa a quella risorsa specifica. Puoi inoltre aggiungere, rimuovere e risincronizzare le risorse nella definizione del modello dalla scheda **Risorse modello**. 

1. Nella scheda **Definizione modello**, il generatore IaC potrebbe emettere avvisi sulle risorse che contengono proprietà di sola scrittura. Dopo aver esaminato gli avvisi, puoi scaricare il modello generato e apportare eventuali modifiche necessarie. Per ulteriori informazioni, consulta [Risoluzione delle proprietà di sola scrittura](generate-IaC-write-only-properties.md).

1. Quando la definizione del modello ti soddisfa, nella scheda **Definizione modello**, scegli **Importa in stack**, quindi scegli **Avanti**.

1. Nel pannello **Specifica stack** della pagina **Specifica dettagli stack** inserisci il nome dello stack, quindi scegli **Avanti**.

1. Esamina e inserisci i parametri per lo stack. Scegli **Avanti**.

1. Controlla le opzioni disponibili nella pagina **Revisione modifiche** e scegli **Avanti**.

1. Controlla i tuoi dati nella pagina **Revisione e importazione** e scegli **Importa risorse**. 

# Risoluzione delle proprietà di sola scrittura
<a name="generate-IaC-write-only-properties"></a>

Con il generatore CloudFormation IAc, puoi generare un modello utilizzando risorse fornite nel tuo account che non sono già gestite da. CloudFormation Tuttavia, alcune proprietà delle risorse sono designate come di *sola scrittura*, il che significa che possono essere scritte ma non possono essere lette, ad esempio CloudFormation, da una password del database. 

Quando si generano CloudFormation modelli a partire da risorse esistenti, le proprietà di sola scrittura rappresentano una sfida. Nella maggior parte dei casi, CloudFormation converte queste proprietà in parametri nel modello generato. Ciò consente di inserire le proprietà come valori dei parametri durante le operazioni di importazione. Tuttavia, esistono scenari in cui questa conversione non è possibile e CloudFormation gestisce questi casi in modo diverso.

## Proprietà che si escludono a vicenda
<a name="write-only-mutually-exclusive-properties"></a>

Alcune risorse dispongono di più set di proprietà che si escludono a vicenda, alcune delle quali sono di sola scrittura. In questi casi, il generatore IaC non è in grado di determinare quale insieme di proprietà esclusive sia stato applicato alla risorsa durante la creazione. Ad esempio, è possibile fornire il codice per una [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-lambda-function.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-lambda-function.html) utilizzando uno di questi set di proprietà. 
+ `Code/S3Bucket`, `Code/S3Key` e facoltativamente `Code/S3ObjectVersion`
+ `Code/ImageUri`
+ `Code/ZipFile`

Tutte queste proprietà sono di sola scrittura. Il generatore IaC seleziona uno dei set esclusivi di proprietà e li aggiunge al modello generato. I parametri vengono aggiunti per ciascuna delle proprietà di sola scrittura. I nomi dei parametri includono `OneOf` e le relative descrizioni indicano che la proprietà corrispondente può essere sostituita con altre proprietà esclusive. Il generatore IaC imposta un tipo di avviso `MUTUALLY_EXCLUSIVE_PROPERTIES` per le proprietà incluse.

## Tipi che si escludono a vicenda
<a name="write-only-mutually-exclusive-types"></a>

In alcuni casi, una proprietà di sola scrittura può contenere più tipi di dati. Ad esempio, la proprietà `Body` di [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-apigateway-restapi.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-apigateway-restapi.html) può essere un `object` o una `string`. In questo caso, il generatore IaC include la proprietà nel modello generato utilizzando il tipo di `string` e imposta un tipo di avviso di `MUTUALLY_EXCLUSIVE_TYPES`.

## Proprietà Array
<a name="write-only-array-properties"></a>

Se una proprietà di sola scrittura ha un tipo di `array`, il generatore IaC non può includerla nel modello generato perché i parametri possono essere solo valori scalari. In questo caso, la proprietà viene omessa dal modello e viene impostato un tipo di avviso di `UNSUPPORTED_PROPERTIES`.

## Proprietà facoltative
<a name="write-only-optional-properties"></a>

Per le proprietà opzionali di sola scrittura, il generatore IaC non è in grado di rilevare se la proprietà sia stata utilizzata durante l’impostazione della risorsa. In questo caso, la proprietà viene omessa dal modello generato e viene impostato un tipo di avviso di `UNSUPPORTED_PROPERTIES`.

## Avvisi e fasi successive
<a name="write-only-properties-warnings-and-next-steps"></a>

Per determinare quali proprietà sono di sola scrittura è necessario esaminare gli avvisi restituiti dalla console del generatore IaC. Le [Informazioni di riferimento sui tipi di proprietà e di risorse AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-template-resource-type-ref.html) non indicano se una proprietà è di sola scrittura o se supporta più tipi.

In alternativa, puoi vedere quali proprietà sono di sola scrittura dagli schemi dei provider di risorse. Per scaricare gli schemi dei provider di risorse, consulta gli [schemi dei provider di CloudFormation risorse](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/resource-type-schemas.html). 

**Per risolvere i problemi relativi alle proprietà di sola scrittura**

1. Apri la [pagina del generatore IaC](https://console.aws.amazon.com/cloudformation/home?#iac-generator) della console. CloudFormation 

1. Nella barra di navigazione nella parte superiore dello schermo, scegli il modello Regione AWS per il tuo modello.

1. Scegli la scheda **Modelli**, quindi scegli il nome del modello che hai creato.

1. Nella scheda **Definizione del modello**, quando il modello generato include risorse con proprietà di sola scrittura, la console del generatore IaC mostra un avviso con un riepilogo del tipo di problemi. Esempio:  
![\[Avviso della console del generatore IaC sulle proprietà di sola scrittura nel modello generato\]](http://docs.aws.amazon.com/it_it/AWSCloudFormation/latest/UserGuide/images/IaC-generator-write-only-property-warning.png)

1. Scegli **Visualizza dettagli degli avvisi** per maggiori informazioni. Le risorse con proprietà di sola scrittura sono identificate dall’ID logico utilizzato nel modello e nel tipo di risorsa generati.

   Utilizza l’elenco di avvisi per identificare le risorse con proprietà di sola scrittura e analizza ogni risorsa per determinare quali modifiche (se presenti) devono essere apportate al modello generato.  
![\[Avvisi dettagliati della console del generatore IaC sulle proprietà di sola scrittura nel modello generato\]](http://docs.aws.amazon.com/it_it/AWSCloudFormation/latest/UserGuide/images/IaC-generator-write-only-property-resource-warning.png)

1. Se il modello deve essere aggiornato per risolvere problemi con le proprietà di sola scrittura, procedi come segue: 

   1. Per scaricare una copia del modello, scegli **Scarica**.

   1. Modifica il modello.

   1. Una volta completate le modifiche, puoi scegliere il pulsante **Importa modello modificato** per continuare il processo di importazione.

# Come risolvere i problemi relativi alle proprietà di sola scrittura nelle risorse AWS::ApiGateway::RestAPI
<a name="generate-IaC-apigateway-restapi"></a>

Questo argomento spiega come risolvere i problemi relativi alle proprietà di sola scrittura nelle risorse [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-apigateway-restapi.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-apigateway-restapi.html) quando si utilizza il generatore IaC.

## Problema
<a name="apigateway-restapi-write-only-properties-issue"></a>

Quando un modello generato contiene risorse `AWS::ApiGateway::RestApi`, vengono generati avvisi che indicano che le proprietà `Body`, `BodyS3Location` e `CloneFrom` sono identificate come `UNSUPPORTED_PROPERTIES`. Questo perché si tratta di proprietà opzionali di sola scrittura. Il generatore IaC non sa se queste proprietà siano mai state applicate alla risorsa. Pertanto, omette queste proprietà nel modello generato.

## Risoluzione
<a name="apigateway-restapi-write-only-properties-resolution"></a>

Aggiorna il modello generato per impostare la proprietà `Body` per la tua REST API.

1. Utilizza l’azione API [https://docs.aws.amazon.com/apigateway/latest/api/API_GetExport.html](https://docs.aws.amazon.com/apigateway/latest/api/API_GetExport.html) di Gateway Amazon API per scaricare l’API. Ad esempio, utilizzando il [https://docs.aws.amazon.com/cli/latest/reference/apigateway/get-export.html](https://docs.aws.amazon.com/cli/latest/reference/apigateway/get-export.html) AWS CLI comando. Per ulteriori informazioni, consulta [Esportazione di una REST API da API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-export-api.html) nella *Guida per gli sviluppatori di Amazon API Gateway*.

1. Recupera la proprietà `Body` dalla risposta dell’azione API `GetExport`. Carica oggetti in un bucket Amazon S3.

1. Esegui il download del modello generato.

1. Aggiungi le proprietà `BodyS3Location/Bucket` e `BodyS3Location/Key` al modello, specificando il nome del bucket e la chiave in cui il `Body` è memorizzato.

1. Apri il modello generato nella console del generatore IaC e scegli **Importa modello modificato**.

# Come risolvere i problemi relativi alle proprietà di sola scrittura nelle risorse AWS::Lambda::Function
<a name="generate-IaC-lambda-function"></a>

Questo argomento spiega come risolvere i problemi relativi alle proprietà di sola scrittura nelle risorse [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-lambda-function.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-lambda-function.html) quando si utilizza il generatore IaC.

## Problema
<a name="lambda-function-mutually-exclusive-properties-issue"></a>

La risorsa `AWS::Lambda::Function` dispone di tre set di proprietà che si escludono a vicenda per specificare il codice Lambda:
+ Le proprietà `Code/S3Bucket` e `Code/S3Key` e, facoltativamente, la proprietà `Code/S3ObjectVersion`
+ Proprietà `Code/ImageUri` 
+ Proprietà `Code/ZipFile` 

È possibile utilizzare solo uno di questi set per una determinata risorsa `AWS::Lambda::Function`.

Il generatore IaC non è in grado di determinare quale set di proprietà esclusive di sola scrittura sia stato utilizzato per creare o aggiornare la risorsa. Di conseguenza, include solo il primo set di proprietà nel modello generato. Le proprietà `Code/ImageUri` e `Code/ZipFile` vengono omesse. 

Inoltre, il generatore IaC emette i seguenti avvisi:
+ **`MUTUALLY_EXCLUSIVE_PROPERTIES`**: avvisa che `Code/S3Bucket` e `Code/S3Key` sono identificate come proprietà che si escludono a vicenda.
+ **`UNSUPPORTED_PROPERTIES`**: avvisa che la proprietà `Code/S3ObjectVersion` non è supportata.

Per includere risorse `AWS::Lambda::Function` in un modello generato, devi scaricare e aggiornare il modello con le proprietà del codice corrette.

## Risoluzione
<a name="lambda-function-mutually-exclusive-properties-resolution"></a>

**Se memorizzi il codice Lambda in un bucket Amazon S3 e non utilizzi la proprietà `S3ObjectVersion`**, puoi importare il modello generato senza alcuna modifica. Il generatore IaC ti chiederà il bucket e la chiave Amazon S3 come parametri del modello durante l’operazione di importazione.

****Se memorizzi il codice Lambda come repository Amazon ECR**, puoi aggiornare il modello utilizzando le seguenti istruzioni:**

1. Esegui il download del modello generato.

1. Rimuovi le proprietà e i parametri corrispondenti per le proprietà `Code/S3Bucket` e `Code/S3Key` dal modello generato.

1. Sostituisci le proprietà rimosse nel modello generato con la proprietà `Code/ImageUri`, specificando l’URL per il repository Amazon ECR.

1. Apri il modello generato nella console del generatore IaC e scegli il pulsante **Importa modello modificato**.

****Se memorizzi il codice Lambda come in un file zip**, puoi aggiornare il modello seguendo le seguenti istruzioni:**

1. Esegui il download del modello generato.

1. Rimuovi le proprietà e i parametri corrispondenti per le proprietà `Code/S3Bucket` e `Code/S3Key` dal modello generato.

1. Sostituisci le proprietà rimosse nel modello generato con la proprietà `Code/ZipFile`.

1. Apri il modello generato nella console del generatore IaC e scegli il pulsante **Importa modello modificato**.

****Se non disponi di una copia del codice Lambda**, puoi aggiornare il modello seguendo le seguenti istruzioni:**

1. Utilizza l'azione AWS Lambda [https://docs.aws.amazon.com/lambda/latest/api/API_GetFunction.html](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunction.html)API (ad esempio, utilizzando il [https://docs.aws.amazon.com/cli/latest/reference/lambda/get-function.html](https://docs.aws.amazon.com/cli/latest/reference/lambda/get-function.html) AWS CLI comando).

1. Nella risposta, il parametro `RepositoryType` è `S3` se il codice si trova in un bucket Amazon S3 o `ECR` se il codice si trova in un repository Amazon ECR.

1. Nella risposta, il parametro `Location` contiene un URL prefirmato da utilizzare per scaricare il pacchetto di implementazione per 10 minuti. Scarica il codice.

1. Carica il codice in un bucket Amazon S3.

1. Esegui un’operazione di importazione con il modello generato e fornisci il nome e la chiave del bucket come valori dei parametri.

# Ottenimento di valori archiviati in altri servizi utilizzando riferimenti dinamici
<a name="dynamic-references"></a>

I riferimenti dinamici offrono un modo pratico per specificare i valori esterni archiviati e gestiti in altri servizi e disaccoppiare le informazioni sensibili dai modelli. infrastructure-as-code CloudFormation recupera il valore del riferimento specificato quando necessario durante le operazioni di stack e change set.

Con i riferimenti dinamici puoi:
+ **Usa stringhe sicure**: per i dati sensibili, utilizza sempre parametri di stringa sicuri in AWS Systems Manager Parameter Store o segreti Gestione dei segreti AWS per garantire che i dati siano crittografati quando sono inattivi.
+ **Limitare l’accesso**: limita l’accesso ai parametri Parameter Store o ai segreti di Secrets Manager solo ai principali e ai ruoli autorizzati.
+ **Ruotare le credenziali**: ruota regolarmente i dati sensibili archiviati in Parameter Store o Secrets Manager per mantenere un elevato livello di sicurezza.
+ **Rotazione automatica**: sfrutta le funzionalità di rotazione automatica di Secrets Manager per aggiornare e distribuire periodicamente i dati sensibili tra le applicazioni e gli ambienti.

## Considerazioni generali
<a name="dynamic-references-considerations"></a>

Di seguito sono riportate le considerazioni generali da considerare prima di specificare riferimenti dinamici CloudFormation nei modelli:
+ Evita di includere riferimenti dinamici o dati sensibili nelle proprietà delle risorse che fanno parte dell'identificatore principale di una risorsa. CloudFormation può utilizzare l'effettivo valore di testo in chiaro nell'identificatore della risorsa principale, il che potrebbe rappresentare un rischio per la sicurezza. Questo ID risorsa può apparire in qualsiasi output o destinazione derivata.

  Per determinare quali proprietà delle risorse comprendono l’identificatore principale di un tipo di risorsa, fai riferimento alla documentazione di riferimento delle risorse nelle [Informazioni di riferimento sui tipi di proprietà e di risorse AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-template-resource-type-ref.html) per la risorsa in questione. Nella sezione **Return values** (Valori restituiti), il valore restituito della funzione `Ref` rappresenta le proprietà delle risorse che comprendono l’identificatore principale del tipo di risorsa.
+ È possibile includere fino a 60 riferimenti dinamici in un modello di stack.
+ Se utilizzi trasformazioni (come `AWS::Include` o`AWS::Serverless`), CloudFormation non risolve i riferimenti dinamici prima di applicare la trasformazione. Trasmette, invece, la stringa letterale del riferimento dinamico alla trasformazione e risolve i riferimenti quando si esegue il set di modifiche utilizzando il modello.
+ I riferimenti dinamici non possono essere utilizzati per valori sicuri (come quelli archiviati in Parameter Store o Secrets Manager) nelle risorse personalizzate. 
+ Inoltre, i riferimenti dinamici non sono supportati nei metadati `AWS::CloudFormation::Init` e nelle proprietà `UserData` di Amazon EC2.
+ Non create un riferimento dinamico che termina con una barra rovesciata (\$1). CloudFormationnon è in grado di risolvere questi riferimenti, il che causerà il fallimento delle operazioni di stack.

I seguenti argomenti forniscono informazioni e altre considerazioni sull’utilizzo dei riferimenti dinamici.

**Topics**
+ [Considerazioni generali](#dynamic-references-considerations)
+ [Ottenimento di un valore in testo normale da Systems Manager Parameter Store](dynamic-references-ssm.md)
+ [Ottenimento di un valore di stringa sicura da Systems Manager Parameter Store](dynamic-references-ssm-secure-strings.md)
+ [Ottieni un segreto o un valore segreto da Secrets Manager](dynamic-references-secretsmanager.md)

# Ottenimento di un valore in testo normale da Systems Manager Parameter Store
<a name="dynamic-references-ssm"></a>

Quando crei un CloudFormation modello, potresti voler utilizzare valori di testo in chiaro memorizzati in Parameter Store. Parameter Store è una funzionalità di. AWS Systems Manager Per un’introduzione a Parameter Store, consulta [AWS Systems Manager Parameter Store](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html) nella *Guida per l’utente di AWS Systems Manager *. 

Per utilizzare un valore in testo normale di Parameter Store all’interno del modello, si utilizza un riferimento dinamico `ssm`. Questo riferimento consente di accedere ai valori dai parametri di tipo `String` o `StringList` in Parameter Store. 

Per verificare quale versione di un riferimento dinamico `ssm` verrà utilizzata in un’operazione di stack, crea un set di modifiche per quest’ultimo. Quindi, esamina il modello elaborato nella scheda **Modello**. Per ulteriori informazioni, consulta [Creare un set di modifiche per uno CloudFormation stack](using-cfn-updating-stacks-changesets-create.md).

Quando si utilizzano riferimenti dinamici `ssm`, ci sono alcune cose importanti da tenere a mente:
+ CloudFormation non supporta il rilevamento della deriva sui riferimenti dinamici. Per i riferimenti dinamici `ssm` in cui non hai specificato la versione del parametro, ti consigliamo, se aggiorni la versione del parametro in Systems Manager, di eseguire anche un’operazione di aggiornamento dello stack su tutti gli stack che includono il riferimento dinamico `ssm`, al fine di recuperare la versione più recente del parametro.
+ Per utilizzare un riferimento `ssm` dinamico nella `Parameters` sezione del CloudFormation modello, è necessario includere un numero di versione. CloudFormation non consente di fare riferimento a un valore di Parameter Store senza un numero di versione in questa sezione. In alternativa, puoi definire il parametro come tipo di parametro Systems Manager nel modello. Quando si esegue questa operazione, è possibile specificare una chiave del parametro Systems Manager come valore predefinito per il parametro. CloudFormation recupererà quindi la versione più recente del valore del parametro da Parameter Store, senza che sia necessario specificare un numero di versione. Questo può rendere i tuoi modelli più semplici e facili da gestire. Per ulteriori informazioni, consulta [Specificare le risorse esistenti in fase di esecuzione con i CloudFormation tipi di parametri forniti da](cloudformation-supplied-parameter-types.md).
+ Per le risorse personalizzate, CloudFormation risolve i riferimenti `ssm` dinamici prima di inviare la richiesta alla risorsa personalizzata.
+ CloudFormation non supporta l'utilizzo di riferimenti dinamici per fare riferimento a un parametro condiviso da un altro. Account AWS
+ CloudFormation non supporta l'utilizzo delle etichette dei parametri di Systems Manager nei riferimenti dinamici.

## Permissions
<a name="dynamic-references-ssm-permissions"></a>

Per specificare un parametro archiviato in Systems Manager Parameter Store, devi disporre di un accesso che consente di chiamare [https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_GetParameter.html](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_GetParameter.html) per il parametro specificato. Per scoprire come creare policy IAM che forniscano l’accesso a parametri specifici di Systems Manager, consulta [Limitazione dell’accesso ai parametri di Systems Manager mediante policy IAM](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-paramstore-access.html) nella *Guida per l’utente di AWS Systems Manager *.

## Schema di riferimento
<a name="dynamic-references-ssm-pattern"></a>

Per fare riferimento a un valore di testo semplice memorizzato in Systems Manager Parameter Store nel CloudFormation modello, utilizzare il seguente schema `ssm` di riferimento.

```
{{resolve:ssm:parameter-name:version}}
```

Il riferimento deve essere conforme allo schema di espressione regolare per parameter-name e version:

```
{{resolve:ssm:[a-zA-Z0-9_.\-/]+(:\d+)?}}
```

`parameter-name`  
Il nome del parametro in Archivio parametri . Il nome di parametro prevede la distinzione tra lettere maiuscole e minuscole.  
Obbligatorio.

`version`  
Un numero intero che specifica la versione del parametro da utilizzare. Se non specificate la versione esatta, CloudFormation utilizza la versione più recente del parametro ogni volta che create o aggiornate lo stack. Per ulteriori informazioni, consulta [Working with parameter versions](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-paramstore-versions.html) nella *Guida per l’utente di AWS Systems Manager *.  
Opzionale.

## Esempi
<a name="dynamic-references-ssm-examples"></a>

**Topics**
+ [Parametro ID AMI pubblico](#dynamic-references-ssm-public-ami-example)
+ [Parametro ID AMI personalizzato](#dynamic-references-ssm-custom-ami-example)

### Parametro ID AMI pubblico
<a name="dynamic-references-ssm-public-ami-example"></a>

L’esempio seguente crea un’istanza EC2 che fa riferimento a un parametro AMI pubblico. Il riferimento dinamico recupera l’ID AMI Amazon Linux 2023 più recente dal parametro pubblico. Per ulteriori informazioni sui parametri pubblici, consulta [Discovering public parameters in Parameter Store](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-store-finding-public-parameters.html) nella *Guida per l’utente di AWS Systems Manager *.

#### JSON
<a name="dynamic-references-ssm-public-ami-example.json"></a>

```
{
    "Resources": {
        "MyInstance": {
            "Type": "AWS::EC2::Instance",
            "Properties": {
                "ImageId": "{{resolve:ssm:/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-6.1-x86_64}}",
                "InstanceType": "t2.micro"
            }
        }
    }
}
```

#### YAML
<a name="dynamic-references-ssm-public-ami-example.yaml"></a>

```
Resources:
  MyInstance:
    Type: AWS::EC2::Instance
    Properties:
      ImageId: '{{resolve:ssm:/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-6.1-x86_64}}'
      InstanceType: t2.micro
```

### Parametro ID AMI personalizzato
<a name="dynamic-references-ssm-custom-ami-example"></a>

L’esempio seguente crea un modello di avvio EC2 che fa riferimento a un ID AMI personalizzato archiviato nel Parameter Store. Il riferimento dinamico recupera l’ID AMI dalla versione *`2`* del parametro `golden-ami` ogni volta che un’istanza viene avviata dal modello di avvio.

#### JSON
<a name="dynamic-references-ssm-custom-ami-example.json"></a>

```
{
    "Resources": {
        "MyLaunchTemplate": {
            "Type": "AWS::EC2::LaunchTemplate",
            "Properties": {
                "LaunchTemplateName": {
                    "Fn::Sub": "${AWS::StackName}-launch-template"
                },
                "LaunchTemplateData": {
                    "ImageId": "{{resolve:ssm:golden-ami:2}}",
                    "InstanceType": "t2.micro"
                }
            }
        }
    }
}
```

#### YAML
<a name="dynamic-references-ssm-custom-ami-example.yaml"></a>

```
Resources:
  MyLaunchTemplate:
    Type: AWS::EC2::LaunchTemplate
    Properties: 
      LaunchTemplateName: !Sub ${AWS::StackName}-launch-template
      LaunchTemplateData:
        ImageId: '{{resolve:ssm:golden-ami:2}}'
        InstanceType: t2.micro
```

# Ottenimento di un valore di stringa sicura da Systems Manager Parameter Store
<a name="dynamic-references-ssm-secure-strings"></a>

In CloudFormation, puoi utilizzare dati sensibili come password o chiavi di licenza senza esporli direttamente nei tuoi modelli archiviando i dati sensibili come «stringa sicura» in AWS Systems Manager Parameter Store. Per un’introduzione a Parameter Store, consulta [AWS Systems Manager Parameter Store](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html) nella *Guida per l’utente di AWS Systems Manager *.

Per utilizzare una stringa sicura di Parameter Store all'interno del modello, si utilizza un riferimento `ssm-secure` dinamico. CloudFormation non memorizza mai il valore effettivo della stringa sicura. Al contrario, archivia il riferimento dinamico letterale, che contiene il nome del parametro della stringa sicura in testo normale. 

Durante la creazione o gli aggiornamenti dello stack, CloudFormation accede al valore della stringa sicura secondo necessità, senza esporre il valore effettivo. Al momento, i parametri di stringa sicura possono essere utilizzati solo per proprietà di risorsa che supportano lo schema di riferimenti dinamici `ssm-secure`. Per ulteriori informazioni, consulta [Risorse che supportano schemi di parametri dinamici per stringhe sicure](#template-parameters-dynamic-patterns-resources).

CloudFormation non restituisce il valore effettivo del parametro per le stringhe sicure in nessuna chiamata API. Restituisce solo il riferimento dinamico letterale. Quando si confrontano le modifiche utilizzando i set di modifiche, confronta CloudFormation solo la stringa di riferimento dinamica letterale. Non risolve e non confronta i valori effettivi della stringa sicura.

Quando si utilizzano riferimenti dinamici `ssm-secure`, ci sono alcune cose importanti da tenere a mente:
+ CloudFormation non può accedere ai valori di Parameter Store da altri. Account AWS
+ CloudFormation non supporta l'uso delle etichette dei parametri di Systems Manager o dei parametri pubblici nei riferimenti dinamici.
+ Le stringhe sicure non sono supportate da Systems Manager nelle regioni `cn-north-1` e `cn-northwest-1`.
+ I riferimenti dinamici per valori sicuri, ad esempio`ssm-secure`, non sono attualmente supportati nelle risorse personalizzate.
+ Se è CloudFormation necessario ripristinare un aggiornamento dello stack e la versione specificata in precedenza di un parametro di stringa sicuro non è più disponibile, l'operazione di rollback avrà esito negativo. In questi casi, sono disponibili due opzioni:
  + Utilizza `CONTINUE_UPDATE_ROLLBACK` per ignorare la risorsa.
  + Ricrea il parametro di stringa sicura in Systems Manager Parameter Store e aggiornalo fino a che la versione del parametro è identica alla versione utilizzata nel modello. Utilizza quindi `CONTINUE_UPDATE_ROLLBACK` senza ignorare la risorsa.

## Risorse che supportano schemi di parametri dinamici per stringhe sicure
<a name="template-parameters-dynamic-patterns-resources"></a>

Le risorse che supportano lo schema di riferimenti dinamici `ssm-secure` includono:


| Risorsa | Tipo di proprietà | Properties | 
| --- | --- | --- | 
| [AWS::DirectoryService::MicrosoftANNUNCIO](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-directoryservice-microsoftad.html) |  | `Password` | 
| [AWS::DirectoryService::SimpleANNUNCIO](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-directoryservice-simplead.html) |  | `Password` | 
| [AWS::ElastiCache::ReplicationGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticache-replicationgroup.html) |  | `AuthToken` | 
| [AWS::IAM::User](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-user.html) | [LoginProfile](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-iam-user-loginprofile.html) | `Password` | 
| [AWS::KinesisFirehose::DeliveryStream](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-kinesisfirehose-deliverystream.html) | [RedshiftDestinationConfiguration](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-kinesisfirehose-deliverystream-redshiftdestinationconfiguration.html) | `Password` | 
| [AWS::OpsWorks::App](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-opsworks-app.html) | [Origine](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-opsworks-app-source.html) | `Password` | 
| [AWS::OpsWorks::Stack](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-opsworks-stack.html) | [CustomCookbooksSource](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-opsworks-stack-source.html) | `Password` | 
| [AWS::OpsWorks::Stack](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-opsworks-stack.html) | [RdsDbInstances](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-opsworks-stack-rdsdbinstance.html) | `DbPassword` | 
| [AWS: :RDS:: DBCluster](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbcluster.html) |  | `MasterUserPassword` | 
| [AWS: :RDS:: DBInstance](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbinstance.html) |  | `MasterUserPassword`  | 
| [AWS::Redshift::Cluster](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-redshift-cluster.html) |  | `MasterUserPassword` | 

## Schema di riferimento
<a name="dynamic-references-ssm-secure-pattern"></a>

Per fare riferimento a un valore di stringa sicuro da Systems Manager Parameter Store nel CloudFormation modello, utilizzare il seguente schema `ssm-secure` di riferimento.

```
{{resolve:ssm-secure:parameter-name:version}}
```

Il riferimento deve essere conforme allo schema di espressione regolare per parameter-name e version:

```
{{resolve:ssm-secure:[a-zA-Z0-9_.\-/]+(:\d+)?}}
```

`parameter-name`  
Il nome del parametro in Archivio parametri . Il nome di parametro prevede la distinzione tra lettere maiuscole e minuscole.  
Obbligatorio.

`version`  
Un numero intero che specifica la versione del parametro da utilizzare. Se non specificate la versione esatta, CloudFormation utilizza la versione più recente del parametro ogni volta che create o aggiornate lo stack. Per ulteriori informazioni, consulta [Working with parameter versions](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-paramstore-versions.html) nella *Guida per l’utente di AWS Systems Manager *.  
Opzionale.

## Esempio
<a name="dynamic-references-ssm-secure-example"></a>

L’esempio seguente utilizza un riferimento dinamico `ssm-secure` per impostare la password per un utente IAM su una stringa sicura archiviata in Parameter Store. Come specificato, CloudFormation utilizzerà la versione *`10`* del `IAMUserPassword` parametro per le operazioni sullo stack e sul set di modifiche.

### JSON
<a name="dynamic-references-ssm-secure-example.json"></a>

```
  "MyIAMUser": {
    "Type": "AWS::IAM::User",
    "Properties": {
      "UserName": "MyUserName",
      "LoginProfile": {
        "Password": "{{resolve:ssm-secure:IAMUserPassword:10}}"
      }
    }
  }
```

### YAML
<a name="dynamic-references-ssm-secure-example.yaml"></a>

```
  MyIAMUser:
    Type: AWS::IAM::User
    Properties:
      UserName: 'MyUserName'
      LoginProfile:
        Password: '{{resolve:ssm-secure:IAMUserPassword:10}}'
```

# Ottieni un segreto o un valore segreto da Secrets Manager
<a name="dynamic-references-secretsmanager"></a>

Secrets Manager è un servizio che consente di archiviare e gestire in modo sicuro segreti come credenziali di database, password e chiavi API di terzi. Con Secrets Manager puoi archiviare e controllare centralmente l’accesso a questi segreti, in modo da poter sostituire le credenziali con codifica fissa nel codice (incluse le password), con una chiamata API a Secrets Manager per recuperare il segreto a livello di programmazione. Per ulteriori informazioni, consulta [Cos'è Gestione dei segreti AWS?](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) nella *Guida Gestione dei segreti AWS per l'utente*.

Per utilizzare interi segreti o valori segreti archiviati in Secrets Manager all'interno dei CloudFormation modelli, si utilizzano riferimenti `secretsmanager` dinamici.

## Best practice
<a name="dynamic-references-secretsmanager-best-practices"></a>

Segui queste best practice quando utilizzi i riferimenti dinamici di Secrets Manager nei tuoi CloudFormation modelli:
+ **Usa riferimenti senza versione per i tuoi CloudFormation modelli**: archivia le credenziali in Secrets Manager e usa riferimenti dinamici senza specificare `version-id` parametri per supportare flussi di `version-stage` lavoro di rotazione segreti adeguati.
+ **Sfrutta la rotazione automatica**: utilizza la funzionalità di rotazione automatica di Secrets Manager con riferimenti dinamici senza versione per la gestione delle credenziali. Ciò garantisce che le credenziali vengano aggiornate regolarmente senza richiedere modifiche al modello. Per ulteriori informazioni, consulta [Rotazione dei segreti Gestione dei segreti AWS](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotating-secrets.html).
+ **Usa i riferimenti che presentano versioni con parsimonia**: specifica solo i parametri `version-stage` o `version-id` espliciti per scenari specifici come situazioni di test o rollback.

## Considerazioni
<a name="dynamic-references-secretsmanager-considerations"></a>

Quando si utilizzano riferimenti dinamici `secretsmanager`, è necessario tenere a mente alcune considerazioni importanti:
+ CloudFormation non tiene traccia della versione di un segreto utilizzata nelle distribuzioni precedenti. Pianifica attentamente la tua strategia di gestione del segreto prima di implementare i riferimenti dinamici. Se possibile, utilizza riferimenti senza versione per sfruttare la rotazione automatica del segreto. Monitora e convalida gli aggiornamenti delle risorse quando apporti modifiche alle configurazioni dei riferimenti dinamici, ad esempio durante la transizione da riferimenti dinamici senza versioni a quelli con versioni e viceversa.
+ L'aggiornamento del solo valore segreto in Secrets Manager non comporta automaticamente CloudFormation il recupero del nuovo valore. CloudFormation recupera il valore segreto solo durante la creazione di risorse o gli aggiornamenti che modificano la risorsa contenente il riferimento dinamico. 

  Ad esempio, supponiamo che il modello includa una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbinstance.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbinstance.html) in cui la proprietà `MasterPassword` è impostata su un riferimento dinamico di Secrets Manager. Dopo aver creato uno stack da questo modello, aggiorna il valore del segreto in Secrets Manager. Tuttavia, la proprietà `MasterPassword` mantiene il vecchio valore della password. 

  Per applicare il nuovo valore segreto, è necessario modificare la `AWS::RDS::DBInstance` risorsa nel CloudFormation modello ed eseguire un aggiornamento dello stack. 

  Per evitare questo processo manuale in futuro, ti consigliamo di utilizzare Secrets Manager per ruotare in automatico il segreto. 
+ I riferimenti dinamici per valori sicuri, ad esempio`secretsmanager`, non sono attualmente supportati nelle risorse personalizzate.
+ Il riferimento dinamico `secretsmanager` può essere utilizzato in tutte le proprietà di risorsa. L'utilizzo del riferimento `secretsmanager` dinamico indica che né Secrets Manager né CloudFormation i log devono rendere persistente alcun valore segreto risolto. Tuttavia, il valore di segreto può essere visualizzato nel servizio proprietario della risorsa in cui è utilizzato. Rivedi l’utilizzo per evitare perdite di dati segreti.

## Permissions
<a name="dynamic-references-secretsmanager-permissions"></a>

Per specificare un segreto archiviato in Secrets Manager, devi disporre dell’autorizzazione alla chiamata per il segreto [https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html).

## Schema di riferimento
<a name="dynamic-references-secretsmanager-pattern"></a>

Per fare riferimento ai segreti di Secrets Manager nel tuo CloudFormation modello, usa il seguente schema `secretsmanager` di riferimento.

```
{{resolve:secretsmanager:secret-id:secret-string:json-key:version-stage:version-id}}
```

`secret-id`  
Il nome o l’ARN del segreto.  
Per accedere a un segreto nel tuo Account AWS, devi solo specificare il nome del segreto. Per accedere a un segreto in un altro Account AWS, specifica l'ARN completo del segreto.  
Obbligatorio.

`secret-string`  
L’unico valore supportato è `SecretString`. Il valore predefinito è `SecretString`.

`json-key`  
Il nome della chiave della coppia chiave-valore di cui intendi recuperare il valore. Se non specifichi a`json-key`, CloudFormation recupera l'intero testo segreto.  
Questo segmento può non includere il carattere di due punti (`:`).

`version-stage`  
L’etichetta temporanea della versione del segreto da utilizzare. Secrets Manager utilizza le etichette temporanee per tenere traccia delle differenti versioni durante il processo di rotazione. Se utilizzi `version-stage`, non specificare `version-id`. Se non specifichi né `version-stage` né `version-id`, la versione di default sarà la `AWSCURRENT`.  
Questo segmento può non includere il carattere di due punti (`:`).

`version-id`  
L’identificatore univoco della versione del segreto da utilizzare. Se specifichi `version-id`, non è necessario specificare anche `version-stage`. Se non specifichi né `version-stage` né `version-id`, la versione di default sarà la `AWSCURRENT`.  
Questo segmento può non includere il carattere di due punti (`:`).

## Esempi
<a name="dynamic-references-secretsmanager-examples"></a>

**Topics**
+ [Recupero dei valori nome utente e password da un segreto](#dynamic-references-secretsmanager-examples-user-name-and-password)
+ [Recupero dell’intero SecretString](#dynamic-references-secretsmanager-examples-entire-secretstring)
+ [Recupero di un valore da una versione specifica di un segreto](#dynamic-references-secretsmanager-examples-specific-version)
+ [Recuperare segreti da un altro Account AWS](#dynamic-references-secretsmanager-examples-secrets-from-another-account)

### Recupero dei valori nome utente e password da un segreto
<a name="dynamic-references-secretsmanager-examples-user-name-and-password"></a>

L’esempio [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbinstance.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbinstance.html) seguente recupera i valori nome utente e password archiviati nel segreto `MySecret`. Questo esempio mostra lo schema consigliato per i riferimenti dinamici senza versione, che utilizza automaticamente la versione `AWSCURRENT` e supporta i flussi di lavoro di rotazione di Secrets Manager senza richiedere modifiche al modello.

#### JSON
<a name="dynamic-references-secretsmanager-examples-user-name-and-password.json"></a>

```
{
    "MyRDSInstance": {
        "Type": "AWS::RDS::DBInstance",
        "Properties": {
            "DBName": "MyRDSInstance",
            "AllocatedStorage": "20",
            "DBInstanceClass": "db.t2.micro",
            "Engine": "mysql",
            "MasterUsername": "{{resolve:secretsmanager:MySecret:SecretString:username}}",
            "MasterUserPassword": "{{resolve:secretsmanager:MySecret:SecretString:password}}"
        }
    }
}
```

#### YAML
<a name="dynamic-references-secretsmanager-examples-user-name-and-password.yaml"></a>

```
  MyRDSInstance:
    Type: AWS::RDS::DBInstance
    Properties:
      DBName: MyRDSInstance
      AllocatedStorage: '20'
      DBInstanceClass: db.t2.micro
      Engine: mysql
      MasterUsername: '{{resolve:secretsmanager:MySecret:SecretString:username}}'
      MasterUserPassword: '{{resolve:secretsmanager:MySecret:SecretString:password}}'
```

### Recupero dell’intero SecretString
<a name="dynamic-references-secretsmanager-examples-entire-secretstring"></a>

Il riferimento dinamico seguente recupera `SecretString` per `MySecret`.

```
{{resolve:secretsmanager:MySecret}}
```

In alternativa:

```
{{resolve:secretsmanager:MySecret::::}}
```

### Recupero di un valore da una versione specifica di un segreto
<a name="dynamic-references-secretsmanager-examples-specific-version"></a>

Il riferimento dinamico seguente recupera il valore `password` per la versione `AWSPREVIOUS` di `MySecret`.

```
{{resolve:secretsmanager:MySecret:SecretString:password:AWSPREVIOUS}}
```

### Recuperare segreti da un altro Account AWS
<a name="dynamic-references-secretsmanager-examples-secrets-from-another-account"></a>

Il riferimento dinamico seguente recupera `SecretString` per `MySecret` che si trova in un altro Account AWS. È necessario specificare l'ARN segreto completo per accedere ai segreti in un altro. Account AWS

```
{{resolve:secretsmanager:arn:aws:secretsmanager:us-west-2:123456789012:secret:MySecret}}
```

Il riferimento dinamico seguente recupera il valore `password` per `MySecret` che si trova in un altro Account AWS. È necessario specificare l'ARN segreto completo per accedere ai segreti in un altro. Account AWS

```
{{resolve:secretsmanager:arn:aws:secretsmanager:us-west-2:123456789012:secret:MySecret:SecretString:password}}
```

# Ottieni AWS valori usando pseudo parametri
<a name="pseudo-parameter-reference"></a>

Gli pseudo parametri sono variabili integrate che forniscono l'accesso a importanti informazioni AWS sull'ambiente, come account IDs, nomi delle regioni e dettagli dello stack, che possono cambiare tra le distribuzioni o gli ambienti.

È possibile utilizzare pseudoparametri anziché valori codificati per rendere i modelli più portabili e più facili da riutilizzare in diverse aree geografiche. Account AWS 

## Sintassi
<a name="pseudo-parameter-syntax"></a>

È possibile fare riferimento agli pseudo parametri utilizzando la funzione intrinseca `Ref` o la funzione intrinseca `Fn::Sub`. 

### Ref
<a name="pseudo-parameter-ref-syntax"></a>

La funzione intrinseca `Ref` utilizza la seguente sintassi generale. Per ulteriori informazioni, consulta [Ref](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-ref.html).

#### JSON
<a name="pseudo-parameter-ref-syntax.json"></a>

```
{ "Ref" : "AWS::PseudoParameter" }
```

#### YAML
<a name="pseudo-parameter-ref-syntax.yaml"></a>

```
!Ref AWS::PseudoParameter
```

### Fn::Sub
<a name="pseudo-parameter-sub-syntax"></a>

La funzione intrinseca `Fn::Sub` utilizza un formato diverso che include la sintassi `${}` attorno allo pseudo parametro. Per ulteriori informazioni, consulta [Fn::Sub](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-sub.html).

#### JSON
<a name="pseudo-parameter-sub-syntax.json"></a>

```
{ "Fn::Sub" : "${AWS::PseudoParameter}" }
```

#### YAML
<a name="pseudo-parameter-sub-syntax.yaml"></a>

```
!Sub '${AWS::PseudoParameter}'
```

## Pseudo parametri disponibili
<a name="available-pseudo-parameters"></a>

### `AWS::AccountId`
<a name="cfn-pseudo-param-accountid"></a>

Restituisce l' Account AWS ID dell'account in cui viene creato lo stack, ad esempio. `123456789012`

Questo pseudo parametro viene comunemente utilizzato per definire ruoli IAM, policy e altre policy relative alle risorse che coinvolgono account specifici. ARNs

### `AWS::NotificationARNs`
<a name="cfn-pseudo-param-notificationarns"></a>

Restituisce l'elenco di Amazon Resource Names (ARNs) per gli argomenti di Amazon SNS che ricevono notifiche sugli eventi dello stack. Puoi specificarli ARNs tramite l'`--notification-arns`opzione presente in AWS CLI o tramite la console durante la creazione o l'aggiornamento dello stack.

A differenza di altri pseudo parametri che restituiscono un singolo valore, `AWS::NotificationARNs` restituisce un elenco di. ARNs Per accedere a un ARN specifico nell’elenco, utilizza la funzione intrinseca `Fn::Select`. Per ulteriori informazioni, consulta [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-select.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-select.html).

### `AWS::NoValue`
<a name="cfn-pseudo-param-novalue"></a>

Rimuove la proprietà della risorsa corrispondente quando specificata come valore restituito nella funzione intrinseca `Fn::If`. Per ulteriori informazioni, consulta [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-if](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-conditions.html#intrinsic-function-reference-conditions-if).

Questo pseudo parametro è particolarmente utile per creare proprietà condizionali delle risorse che devono essere incluse solo in determinate condizioni.

### `AWS::Partition`
<a name="cfn-pseudo-param-partition"></a>

Restituisce la partizione in cui si trova la risorsa. Per lo standard Regioni AWS, la partizione è. `aws` Per risorse in altre partizioni, la partizione è `aws-`*partitionname*. Ad esempio, la partizione per le risorse nelle regioni della Cina (Pechino e Ningxia) è `aws-cn` e la partizione per le risorse nella regione AWS GovCloud (Stati Uniti occidentali) è. `aws-us-gov`

La partizione fa parte dell’ARN per le risorse. L'utilizzo `AWS::Partition` garantisce il corretto funzionamento dei modelli su diverse partizioni. AWS 

### `AWS::Region`
<a name="cfn-pseudo-param-region"></a>

Restituisce una stringa che rappresenta la regione in cui la risorsa comprendente è in fase di creazione, ad esempio `us-west-2`.

Questo è uno degli pseudo parametri più comunemente usati, in quanto consente ai modelli di adattarsi a diversi Regioni AWS modelli senza modifiche.

### `AWS::StackId`
<a name="cfn-pseudo-param-stackid"></a>

Restituisce l’ID (ARN) dello stack, ad esempio `arn:aws:cloudformation:us-west-2:123456789012:stack/teststack/51af3dc0-da77-11e4-872e-1234567db123`.

### `AWS::StackName`
<a name="cfn-pseudo-param-stackname"></a>

Restituisce il nome dello stack, ad esempio `teststack`.

Il nome dello stack viene comunemente utilizzato per creare nomi di risorse univoci facilmente identificabili come appartenenti a uno stack specifico.

### `AWS::URLSuffix`
<a name="cfn-pseudo-param-urlsuffix"></a>

Restituisce il suffisso per il AWS dominio in Regione AWS cui è distribuito lo stack. Il suffisso è in genere `amazonaws.com`, ma per la regione Cina (Pechino) il suffisso è `amazonaws.com.cn`.

Questo parametro è particolarmente utile durante la creazione di endpoint di servizio. URLs AWS 

## Esempi
<a name="pseudo-parameter-examples"></a>

**Topics**
+ [Utilizzo di base](#pseudo-parameter-basic-example)
+ [Uso di AWS::NotificationARNs](#pseudo-parameter-notification-example)
+ [Proprietà condizionali con AWS::NoValue](#pseudo-parameter-novalue-example)

### Utilizzo di base
<a name="pseudo-parameter-basic-example"></a>

Gli esempi seguenti creano due risorse: un argomento Amazon SNS e un CloudWatch allarme che invia notifiche a quell'argomento. `AWS::StackName`Utilizzano e `AWS::AccountId` inseriscono dinamicamente il nome dello stack, l'ID corrente e l'ID dell'account nei nomi Regione AWS, nelle descrizioni delle risorse e. `AWS::Region` ARNs

#### JSON
<a name="pseudo-parameter-basic-example.json"></a>

```
{
    "Resources": {
        "MyNotificationTopic": {
            "Type": "AWS::SNS::Topic",
            "Properties": {
                "DisplayName": { "Fn::Sub": "Notifications for ${AWS::StackName}" }
            }
        },
        "CPUAlarm": {
            "Type": "AWS::CloudWatch::Alarm",
            "Properties": {
                "AlarmDescription": { "Fn::Sub": "Alarm for high CPU in ${AWS::Region}" },
                "AlarmName": { "Fn::Sub": "${AWS::StackName}-HighCPUAlarm" },
                "MetricName": "CPUUtilization",
                "Namespace": "AWS/EC2",
                "Statistic": "Average",
                "Period": 300,
                "EvaluationPeriods": 1,
                "Threshold": 80,
                "ComparisonOperator": "GreaterThanThreshold",
                "AlarmActions": [{ "Fn::Sub": "arn:aws:sns:${AWS::Region}:${AWS::AccountId}:${MyNotificationTopic}" }]
            }
        }
    }
}
```

#### YAML
<a name="pseudo-parameter-basic-example.yaml"></a>

```
Resources:
  MyNotificationTopic:
    Type: AWS::SNS::Topic
    Properties:
      DisplayName: !Sub Notifications for ${AWS::StackName}
  CPUAlarm:
    Type: AWS::CloudWatch::Alarm
    Properties:
      AlarmDescription: !Sub Alarm for high CPU in ${AWS::Region}
      AlarmName: !Sub ${AWS::StackName}-HighCPUAlarm
      MetricName: CPUUtilization
      Namespace: AWS/EC2
      Statistic: Average
      Period: 300
      EvaluationPeriods: 1
      Threshold: 80
      ComparisonOperator: GreaterThanThreshold
      AlarmActions:
        - !Sub arn:aws:sns:${AWS::Region}:${AWS::AccountId}:${MyNotificationTopic}
```

### Uso di AWS::NotificationARNs
<a name="pseudo-parameter-notification-example"></a>

Gli esempi seguenti configurano un gruppo Auto Scaling affinché invii notifiche per eventi di avvio delle istanze ed errori di avvio. La configurazione utilizza lo `AWS::NotificationARNs` pseudo parametro, che fornisce un elenco di ARNs argomenti di Amazon SNS specificati durante la creazione dello stack. La funzione `Fn::Select` sceglie il primo ARN da quell’elenco.

#### JSON
<a name="pseudo-parameter-notification-example.json"></a>

```
"myASG": {
   "Type": "AWS::AutoScaling::AutoScalingGroup",
   "Properties": {
      "LaunchTemplate": {
         "LaunchTemplateId": { "Ref": "myLaunchTemplate" },
         "Version": { "Fn::GetAtt": [ "myLaunchTemplate", "LatestVersionNumber" ] }
       },
       "MaxSize": "1",
       "MinSize": "1",
       "VPCZoneIdentifier": [
          "subnetIdAz1",
          "subnetIdAz2",
          "subnetIdAz3"
      ],
      "NotificationConfigurations" : [{
         "TopicARN" : { "Fn::Select" : [ "0", { "Ref" : "AWS::NotificationARNs" } ] },
         "NotificationTypes" : [ "autoscaling:EC2_INSTANCE_LAUNCH", "autoscaling:EC2_INSTANCE_LAUNCH_ERROR" ]
      }]
   }
}
```

#### YAML
<a name="pseudo-parameter-notification-example.yaml"></a>

```
myASG:
  Type: AWS::AutoScaling::AutoScalingGroup
  Properties:
    LaunchTemplate:
      LaunchTemplateId: !Ref myLaunchTemplate
      Version: !GetAtt myLaunchTemplate.LatestVersionNumber
    MinSize: '1'
    MaxSize: '1'
    VPCZoneIdentifier:
      - subnetIdAz1
      - subnetIdAz2
      - subnetIdAz3
    NotificationConfigurations:
      - TopicARN:
          Fn::Select:
          - '0'
          - Ref: AWS::NotificationARNs
        NotificationTypes:
        - autoscaling:EC2_INSTANCE_LAUNCH
        - autoscaling:EC2_INSTANCE_LAUNCH_ERROR
```

### Proprietà condizionali con AWS::NoValue
<a name="pseudo-parameter-novalue-example"></a>

I seguenti esempi creano un’istanza Amazon RDS DB cha utilizza uno snapshot solo se viene fornito un ID snapshot. Se la `UseDBSnapshot` condizione risulta vera, CloudFormation utilizza il valore del `DBSnapshotName` parametro per la proprietà. `DBSnapshotIdentifier` Se la condizione risulta falsa, CloudFormation rimuove la `DBSnapshotIdentifier` proprietà. 

#### JSON
<a name="pseudo-parameter-novalue-example.json"></a>

```
"MyDB" : {
  "Type" : "AWS::RDS::DBInstance",
  "Properties" : {
    "AllocatedStorage" : "5",
    "DBInstanceClass" : "db.t2.small",
    "Engine" : "MySQL",
    "EngineVersion" : "5.5",
    "MasterUsername" : { "Ref" : "DBUser" },
    "MasterUserPassword" : { "Ref" : "DBPassword" },
    "DBParameterGroupName" : { "Ref" : "MyRDSParamGroup" },
    "DBSnapshotIdentifier" : {
      "Fn::If" : [
        "UseDBSnapshot",
        {"Ref" : "DBSnapshotName"},
        {"Ref" : "AWS::NoValue"}
      ]
    }
  }
}
```

#### YAML
<a name="pseudo-parameter-novalue-example.yaml"></a>

```
MyDB:
  Type: AWS::RDS::DBInstance
  Properties:
    AllocatedStorage: '5'
    DBInstanceClass: db.t2.small
    Engine: MySQL
    EngineVersion: '5.5'
    MasterUsername:
      Ref: DBUser
    MasterUserPassword:
      Ref: DBPassword
    DBParameterGroupName:
      Ref: MyRDSParamGroup
    DBSnapshotIdentifier:
      Fn::If:
        - UseDBSnapshot
        - Ref: DBSnapshotName
        - Ref: AWS::NoValue
```

# Ottieni gli output esportati da uno stack distribuito CloudFormation
<a name="using-cfn-stack-exports"></a>

Se disponi di più stack nella stessa regione Account AWS e nella stessa regione, potresti voler condividere informazioni tra di loro. Questo è utile quando uno stack deve utilizzare le risorse create da un altro stack.

Ad esempio, potresti avere uno stack che crea risorse di rete, come sottoreti e gruppi di sicurezza, per i tuoi server web. Gli altri stack che creano i server Web effettivi possono quindi utilizzare le risorse di rete create dal primo stack. Non è necessario codificare le risorse IDs nel modello dello stack o passarle IDs come parametri di input.

Per condividere informazioni tra stack, *esporta* i valori di output da uno stack e *importali* in un altro stack. Come funziona:

1. Nel modello del primo stack (ad esempio, lo stack di rete), definisci determinati valori da esportare utilizzando il campo `Export` nella sezione `Outputs`. Per ulteriori informazioni, consulta [CloudFormation Outputssintassi del modello](outputs-section-structure.md).

1. Quando crei o aggiorni quello stack, CloudFormation esporta i valori di output, rendendoli disponibili ad altri stack nello stesso stack e nella stessa Account AWS regione.

1. Nel modello dell’altro stack, utilizza la funzione [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-importvalue.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-importvalue.html) per importare i valori esportati dal primo stack.

1. Quando crei o aggiorni il secondo stack (ad esempio, lo stack del server Web), recupera CloudFormation automaticamente i valori esportati dal primo stack e li utilizza.

Per una procedura guidata e modelli di esempio, consulta [Fai riferimento agli output di risorse in un altro stack CloudFormation](walkthrough-crossstackref.md).

## Esportazione dei valori di output di uno stack e utilizzo di stack nidificati
<a name="output-vs-nested"></a>

Uno stack nidificato è uno stack creato all’interno di un altro stack utilizzando la risorsa `AWS::CloudFormation::Stack`. Con gli stack nidificati, puoi distribuire e gestire tutte le risorse da un singolo stack. Puoi utilizzare output da uno stack nel gruppo di stack nidificati come input per un altro stack del gruppo. Ciò è diverso dall'esportazione di valori.

Se desideri isolare la condivisione delle informazioni all'interno di un gruppo di stack nidificati, è consigliabile utilizzare stack nidificati. Per condividere le informazioni con altri stack (non solo nel gruppo di stack nidificati), esporta i valori. Ad esempio, puoi creare un singolo stack con una sottorete ed esportarne l'ID. Altri stack possono utilizzare questa sottorete importandone l’ID. Non è necessario che ogni stack crei una sottorete propria. Finché gli stack importano l'ID della sottorete, non è possibile modificarlo o eliminarlo.

Per ulteriori informazioni sugli stack nidificati, consulta [Dividi un modello in pezzi riutilizzabili usando stack nidificati](using-cfn-nested-stacks.md).

## Considerazioni
<a name="using-cfn-stack-exports-considerations"></a>

Ai riferimenti tra stack si applicano le seguenti limitazioni:
+ Per ognuno Account AWS, i `Export` nomi devono essere univoci all'interno di una regione.
+ Non puoi creare riferimenti tra stack tra Regioni. Puoi utilizzare la funzione intrinseca `Fn::ImportValue` per importare solo valori che sono stati esportati all’interno della stessa Regione.
+ Per gli output, il valore della proprietà `Name` di un `Export` non può utilizzare le funzioni `Ref` o `GetAtt` che dipendono da una risorsa.

  Allo stesso modo, la funzione `ImportValue` non può includere le funzioni `Ref` o `GetAtt` che dipendono da una risorsa.
+ Quando un altro stack importa un valore di output, non puoi eliminare lo stack che esporta il valore di output o modificare il valore di output esportato. Tutte le importazioni devono essere eliminate prima di poter eliminare lo stack di esportazione o di modificare il valore di output.

## Elencazione dei valori di output esportati
<a name="using-cfn-stack-exports-listing"></a>

Se devi visualizzare i valori di output esportati dagli stack, utilizza uno dei metodi seguenti:

**Per elencare i valori di output esportati (console)**

1. Apri la CloudFormation console in [https://console.aws.amazon.com/cloudformazione.](https://console.aws.amazon.com/cloudformation/)

1. Nella barra di navigazione nella parte superiore dello schermo, scegli la Regione AWS.

1. Nel riquadro di navigazione a sinistra, scegli **Esportazioni**.

**Per elencare i valori di output esportati (AWS CLI)**  
Utilizza il seguente comando [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-exports.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-exports.html). Sostituisci con il tuo*us-east-1*. Regione AWS

```
aws cloudformation list-exports --region us-east-1
```

Di seguito è riportato un output di esempio.

```
{
    "Exports": [
        {
            "ExportingStackId": "arn:aws:cloudformation:us-west-2:123456789012:stack/private-vpc/99764070-b56c-xmpl-bee8-062a88d1d800",
            "Name": "private-vpc-subnet-a",
            "Value": "subnet-07b410xmplddcfa03"
        },
        {
            "ExportingStackId": "arn:aws:cloudformation:us-west-2:123456789012:stack/private-vpc/99764070-b56c-xmpl-bee8-062a88d1d800",
            "Name": "private-vpc-subnet-b",
            "Value": "subnet-075ed3xmplebd2fb1"
        },
        {
            "ExportingStackId": "arn:aws:cloudformation:us-west-2:123456789012:stack/private-vpc/99764070-b56c-xmpl-bee8-062a88d1d800",
            "Name": "private-vpc-vpcid",
            "Value": "vpc-011d7xmpl100e9841"
        }
    ]
}
```

CloudFormation mostra i nomi e i valori degli output esportati per la regione corrente e lo stack da cui sono stati esportati. Per utilizzare un valore di output esportato in un modello di stack, puoi farvi riferimento utilizzando il nome di esportazione e la funzione `Fn::ImportValue`.

## Creazione di elenchi di stack che importano un valore di output esportato
<a name="using-cfn-stack-imports"></a>

Per eliminare o modificare i valori di output esportati, devi prima scoprire quali stack li stanno importando.

Per visualizzare gli stack che importano un valore di output esportato, utilizza uno dei metodi seguenti:

**Per elencare gli stack che importano un valore di output esportato (console)**

1. [Apri la CloudFormation console in /cloudformation. https://console.aws.amazon.com](https://console.aws.amazon.com/cloudformation/)

1. Nel riquadro di navigazione a sinistra, scegli **Esportazioni**.

1. Per vedere quali pile importano un determinato valore di esportazione, scegli il **nome di esportazione per quel valore di esportazione**. CloudFormation visualizza la pagina dei dettagli di esportazione, che elenca tutti gli stack che importano il valore.

**Per elencare gli stack che importano un valore di output esportato (AWS CLI)**  
Utilizza il comando [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-imports.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/list-imports.html). *us-east-1*Sostituiscilo con il tuo Regione AWS e `private-vpc-vpcid` con il nome del valore di output esportato.

```
aws cloudformation list-imports --region us-east-1 \
    --export-name private-vpc-vpcid
```

CloudFormation restituisce un elenco di pile che stanno importando il valore.

```
{
    "Imports": [
        "my-app-stack"
    ]
}
```

Una volta che sai quali stack importano un particolare valore esportato, devi modificare tali stack per rimuovere le funzioni `Fn::ImportValue` che fanno riferimento ai valori di output. Prima di poter eliminare o modificare i valori di output esportati, è necessario rimuovere tutte le importazioni che fanno riferimento a tali valori. 

# Specificare le risorse esistenti in fase di esecuzione con i CloudFormation tipi di parametri forniti da
<a name="cloudformation-supplied-parameter-types"></a>

Durante la creazione del modello, è possibile creare parametri che richiedono agli utenti di inserire identificatori di AWS risorse esistenti o parametri di Systems Manager utilizzando i tipi di parametri specializzati forniti da CloudFormation. 

**Topics**
+ [Panoramica di](#cloudformation-supplied-parameter-types-overview)
+ [Esempio](#cloudformation-supplied-parameter-types-example)
+ [Considerazioni](#cloudformation-supplied-parameter-types-considerations)
+ [Tipi AWS di parametri specifici supportati](#aws-specific-parameter-types-supported)
+ [Tipi di parametri supportati da Systems Manager](#systems-manager-parameter-types-supported)
+ [Tipi di parametri Systems Manager non supportati](#systems-manager-parameter-types-unsupported)

## Panoramica di
<a name="cloudformation-supplied-parameter-types-overview"></a>

In CloudFormation, è possibile utilizzare i parametri per personalizzare gli stack fornendo valori di input durante la creazione o l'aggiornamento degli stack. Questa funzionalità rende i modelli riutilizzabili e flessibili in diversi scenari. 

I parametri sono definiti nella `Parameters` sezione di un CloudFormation modello. Ogni parametro ha un nome e un tipo e può avere impostazioni aggiuntive come un valore predefinito e valori consentiti. Per ulteriori informazioni, consulta [CloudFormation Parameterssintassi del modello](parameters-section-structure.md). 

Il tipo di parametro determina il tipo di valore di input che il parametro può accettare. Ad esempio, `Number` accetta solo valori numerici, mentre `String` accetta l’immissione di testo. 

CloudFormation fornisce diversi tipi di parametri aggiuntivi che è possibile utilizzare nei modelli per fare riferimento alle AWS risorse esistenti e ai parametri di Systems Manager. 

Questi tipi di parametri si dividono in due categorie:
+ **AWS-tipi di parametri specifici**: CloudFormation fornisce una serie di tipi di parametri che aiutano a catturare valori non validi durante la creazione o l'aggiornamento di uno stack. Quando utilizzi questi tipi di parametri, chiunque utilizzi il tuo modello deve specificare valori validi dalla regione Account AWS e dalla regione in cui sta creando lo stack.

  Se utilizzano Console di gestione AWS, CloudFormation fornisce un elenco precompilato di valori esistenti dal proprio account e dalla propria regione. In questo modo l’utente non dovrà ricordare alcuna informazione e immetterà correttamente un nome o un ID specifico. Al contrario, deve solo selezionare i valori da un elenco a discesa. In alcuni casi è anche possibile cercare i valori per ID, nome o valore del tag `Name`.
+ **Tipi di parametri di Systems Manager**: fornisce CloudFormation anche tipi di parametri che corrispondono ai parametri esistenti in Systems Manager Parameter Store. Quando si utilizzano questi tipi di parametri, chiunque utilizzi il modello deve specificare una chiave Parameter Store come valore del tipo di parametro Systems Manager, CloudFormation quindi recuperare il valore più recente da Parameter Store da utilizzare nel proprio stack. Ciò può essere utile quando è necessario aggiornare frequentemente le applicazioni con nuovi valori di proprietà, come la nuova Amazon Machine Image (AMI) IDs. Per ulteriori informazioni sul Parameter Store, consultare [Systems Manager Parameter Store](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html).

Una volta definiti i parametri nella `Parameters` sezione, puoi fare riferimento ai valori dei parametri in tutto il CloudFormation modello utilizzando la `Ref` funzione.

## Esempio
<a name="cloudformation-supplied-parameter-types-example"></a>

Nel seguente esempio viene mostrato un modello che utilizza i seguenti tipi di parametro. 
+ `AWS::EC2::VPC::Id`
+ `AWS::EC2::Subnet::Id`
+ `AWS::EC2::KeyPair::KeyName`
+ `AWS::SSM::Parameter::Value<AWS::EC2::Image::Id>`

Per creare uno stack da questo modello devi specificare un ID del VPC, un ID di sottorete e un nome della coppia di chiavi esistenti dal tuo account. Puoi anche specificare una chiave Parameter Store esistente che faccia riferimento all’ID AMI desiderato o mantenga il valore predefinito di `/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2`. Questo parametro pubblico è un alias per l’ID AMI regionale per l’AMI Amazon Linux 2 più recente. Per ulteriori informazioni sui parametri pubblici, consulta [Discovering public parameters in Parameter Store](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-store-finding-public-parameters.html) nella *Guida per l’utente di AWS Systems Manager *.

### JSON
<a name="cloudformation-supplied-parameter-types-example.json"></a>

```
{
    "Parameters": {
        "VpcId": {
            "Description": "ID of an existing Virtual Private Cloud (VPC).",
            "Type": "AWS::EC2::VPC::Id"
        },
        "PublicSubnetId": {
            "Description": "ID of an existing public subnet within the specified VPC.",
            "Type": "AWS::EC2::Subnet::Id"
        },
        "KeyName": {
            "Description": "Name of an existing EC2 key pair to enable SSH access to the instance.",
            "Type": "AWS::EC2::KeyPair::KeyName"
        },
        "AMIId": {
            "Description": "Name of a Parameter Store parameter that stores the ID of the Amazon Machine Image (AMI).",
            "Type": "AWS::SSM::Parameter::Value<AWS::EC2::Image::Id>",
            "Default": "/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2"
        }
    },
    "Resources": {
        "InstanceSecurityGroup": {
            "Type": "AWS::EC2::SecurityGroup",
            "Properties": {
                "GroupDescription": "Enable SSH access via port 22",
                "VpcId": { "Ref": "VpcId" },
                "SecurityGroupIngress": [
                    {
                        "IpProtocol": "tcp",
                        "FromPort": 22,
                        "ToPort": 22,
                        "CidrIp": "0.0.0.0/0"
                    }
                ]
            }
        },
        "Ec2Instance": {
            "Type": "AWS::EC2::Instance",
            "Properties": {
                "KeyName": { "Ref": "KeyName" },
                "ImageId": { "Ref": "AMIId" },
                "NetworkInterfaces": [
                    {
                        "AssociatePublicIpAddress": "true",
                        "DeviceIndex": "0",
                        "SubnetId": { "Ref": "PublicSubnetId" },
                        "GroupSet": [{ "Ref": "InstanceSecurityGroup" }]
                    }
                ]
            }
        }
    },
    "Outputs": {
        "InstanceId": {
            "Value": { "Ref": "Ec2Instance" }
        }
    }
}
```

### YAML
<a name="cloudformation-supplied-parameter-types-example.yaml"></a>

```
Parameters:
  VpcId:
    Description: ID of an existing Virtual Private Cloud (VPC).
    Type: AWS::EC2::VPC::Id
  PublicSubnetId:
    Description: ID of an existing public subnet within the specified VPC.
    Type: AWS::EC2::Subnet::Id
  KeyName:
    Description: Name of an existing EC2 KeyPair to enable SSH access to the instance.
    Type: AWS::EC2::KeyPair::KeyName
  AMIId:
    Description: Name of a Parameter Store parameter that stores the ID of the Amazon Machine Image (AMI).
    Type: AWS::SSM::Parameter::Value<AWS::EC2::Image::Id>
    Default: /aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2
Resources:
  InstanceSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Enable SSH access via port 22
      VpcId: !Ref VpcId
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: 22
          ToPort: 22
          CidrIp: 0.0.0.0/0
  Ec2Instance:
    Type: AWS::EC2::Instance
    Properties:
      KeyName: !Ref KeyName
      ImageId: !Ref AMIId
      NetworkInterfaces:
        - AssociatePublicIpAddress: "true"
          DeviceIndex: "0"
          SubnetId: !Ref PublicSubnetId
          GroupSet:
            - !Ref InstanceSecurityGroup
Outputs:
  InstanceId:
    Value: !Ref Ec2Instance
```

### AWS CLI comando per creare lo stack
<a name="cloudformation-supplied-parameter-types-cli-command"></a>

Il seguente comando [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html) crea uno stack in base al modello di esempio. 

```
aws cloudformation create-stack --stack-name MyStack \
  --template-body file://sampletemplate.json \
  --parameters \
ParameterKey="VpcId",ParameterValue="vpc-a123baa3" \
ParameterKey="PublicSubnetId",ParameterValue="subnet-123a351e" \
ParameterKey="KeyName",ParameterValue="MyKeyName" \
ParameterKey="AMIId",ParameterValue="MyParameterKey"
```

Per utilizzare un tipo di parametro che accetta un elenco di stringhe, ad esempio `List<AWS::EC2::Subnet::Id>`, devi evitare le virgole all’interno del `ParameterValue` con una doppia barra rovesciata, come illustrato nell’esempio seguente.

```
--parameters ParameterKey="SubnetIDs",ParameterValue="subnet-5ea0c127\\,subnet-6194ea3b\\,subnet-c87f2be0"
```

## Considerazioni
<a name="cloudformation-supplied-parameter-types-considerations"></a>

Si consiglia vivamente di utilizzare riferimenti dinamici per limitare l’accesso a definizioni di configurazione riservate, come le credenziali di terze parti. Per ulteriori informazioni, consulta [Ottenimento di valori archiviati in altri servizi utilizzando riferimenti dinamici](dynamic-references.md).

Se desideri consentire agli utenti del modello di specificare valori tra diversi Account AWS, non utilizzare tipi di parametri AWS specifici. Definisci, invece, parametri di tipo `String` o `CommaDelimitedList`. 

Ci sono alcune cose da tenere a mente con i tipi di parametri di Systems Manager:
+ Puoi visualizzare i valori risolti per i parametri nella scheda **Parametri** dello stack nella console oppure eseguendo [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-stacks.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-stacks.html) o [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-change-set.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-change-set.html). Ricorda che questi valori vengono impostati quando lo stack viene creato o aggiornato, pertanto potrebbero essere diversi dai valori più recenti presenti nel Parameter Store.
+ Per gli aggiornamenti dello stack, quando si **utilizza l'opzione Use existing value** (o impostata su `UsePreviousValue` true), significa che si desidera continuare a utilizzare la stessa chiave Parameter Store, non il relativo valore. CloudFormation recupera sempre il valore più recente.
+ Se specificate valori consentiti o altri vincoli, li CloudFormation convalida in base alle chiavi dei parametri specificate, ma non ai relativi valori. Devi convalidare i valori nel Parameter Store stesso.
+ Quando crei o aggiorni pile e crei set di modifiche, CloudFormation utilizza qualsiasi valore esistente in Parameter Store in quel momento. Se un parametro specificato non esiste in Parameter Store sotto quello del chiamante Account AWS, CloudFormation restituisce un errore di convalida.
+ Quando si esegue un set di modifiche, CloudFormation utilizza i valori specificati nel set di modifiche. Esamina questi valori prima di eseguire il set di modifiche perché potrebbero variare in Archivio parametri tra il momento in cui crei il set di modifiche e l’esecuzione dello stesso.
+ Per i parametri Parameter Store memorizzati nello stesso Account AWS, è necessario fornire il nome del parametro. Per i parametri Parameter Store condivisi da un altro Account AWS, devi fornire il parametro ARN completo.

## Tipi AWS di parametri specifici supportati
<a name="aws-specific-parameter-types-supported"></a>

CloudFormation supporta i seguenti tipi AWS specifici:

`AWS::EC2::AvailabilityZone::Name`  
Zona di disponibilità, ad esempio `us-west-2a`.

`AWS::EC2::Image::Id`  
ID dell’immagine Amazon EC2, ad esempio `ami-0ff8a91507f77f867`. Tieni presente che la CloudFormation console non mostra un elenco a discesa di valori per questo tipo di parametro.

`AWS::EC2::Instance::Id`  
ID dell’istanza Amazon EC2, ad esempio `i-1e731a32`.

`AWS::EC2::KeyPair::KeyName`  
Nome della coppia di chiavi Amazon EC2.

`AWS::EC2::SecurityGroup::GroupName`  
Nome di un gruppo di sicurezza VPC predefinito, ad esempio `my-sg-abc`.

`AWS::EC2::SecurityGroup::Id`  
ID del gruppo di sicurezza, ad esempio `sg-a123fd85`.

`AWS::EC2::Subnet::Id`  
ID della sottorete, ad esempio `subnet-123a351e`.

`AWS::EC2::Volume::Id`  
ID del volume Amazon EBS, ad esempio `vol-3cdd3f56`.

`AWS::EC2::VPC::Id`  
ID VPC, ad esempio `vpc-a123baa3`.

`AWS::Route53::HostedZone::Id`  
ID della zona ospitata Amazon Route 53, ad esempio `Z23YXV4OVPL04A`.

`List<AWS::EC2::AvailabilityZone::Name>`  
Matrice di zone di disponibilità per una Regione, ad esempio `us-west-2a, us-west-2b`.

`List<AWS::EC2::Image::Id>`  
Una serie di immagini Amazon EC2 IDs, ad esempio. `ami-0ff8a91507f77f867, ami-0a584ac55a7631c0c` Tieni presente che la CloudFormation console non mostra un elenco a discesa di valori per questo tipo di parametro.

`List<AWS::EC2::Instance::Id>`  
Un array di istanze Amazon EC2 IDs, ad esempio. `i-1e731a32, i-1e731a34`

`List<AWS::EC2::SecurityGroup::GroupName>`  
Matrice dei nomi dei gruppi di sicurezza VPC predefiniti, ad esempio `my-sg-abc, my-sg-def`.

`List<AWS::EC2::SecurityGroup::Id>`  
Una serie di gruppi di sicurezza IDs, ad esempio`sg-a123fd85, sg-b456fd85`.

`List<AWS::EC2::Subnet::Id>`  
Un array di sottoreti IDs, ad esempio`subnet-123a351e, subnet-456b351e`.

`List<AWS::EC2::Volume::Id>`  
Una matrice di volumi Amazon EBS IDs, ad esempio`vol-3cdd3f56, vol-4cdd3f56`.

`List<AWS::EC2::VPC::Id>`  
Una serie di VPC IDs, ad esempio. `vpc-a123baa3, vpc-b456baa3`

`List<AWS::Route53::HostedZone::Id>`  
Una serie di zone ospitate su Amazon Route 53 IDs, ad esempio`Z23YXV4OVPL04A, Z23YXV4OVPL04B`.

## Tipi di parametri supportati da Systems Manager
<a name="systems-manager-parameter-types-supported"></a>

CloudFormation supporta i seguenti tipi di parametri Systems Manager:

`AWS::SSM::Parameter::Name`  
Nome di una chiave di parametro Systems Manager. Utilizzate questo tipo di parametro solo per verificare che esista un parametro richiesto. CloudFormation non recupererà il valore effettivo associato al parametro. 

`AWS::SSM::Parameter::Value<String>`  
Parametro Systems Manager il cui valore è una stringa. Corrisponde al tipo di parametro `String` in Archivio parametri.

`AWS::SSM::Parameter::Value<List<String>>` o `AWS::SSM::Parameter::Value<CommaDelimitedList>`  
Parametro Systems Manager il cui valore è un elenco di stringhe. Corrisponde al tipo di parametro `StringList` in Archivio parametri.

`AWS::SSM::Parameter::Value<AWS-specific parameter type>`  
Un parametro Systems Manager il cui valore è un tipo AWS di parametro specifico.   
L’esempio seguente specifica il tipo `AWS::EC2::KeyPair::KeyName`:  
+ `AWS::SSM::Parameter::Value<AWS::EC2::KeyPair::KeyName>`

`AWS::SSM::Parameter::Value<List<AWS-specific parameter type>>`  
Un parametro Systems Manager il cui valore è un elenco di tipi AWS di parametri specifici.   
L’esempio seguente specifica un elenco di tipi `AWS::EC2::KeyPair::KeyName`:  
+ `AWS::SSM::Parameter::Value<List<AWS::EC2::KeyPair::KeyName>>`

## Tipi di parametri Systems Manager non supportati
<a name="systems-manager-parameter-types-unsupported"></a>

CloudFormation non supporta il seguente tipo di parametro Systems Manager:
+ Elenchi dei tipi di parametri Systems Manager, ad esempio: `List<AWS::SSM::Parameter::Value<String>>`

Inoltre, CloudFormation non supporta la definizione dei parametri del modello come tipi di parametri `SecureString` Systems Manager. Tuttavia, puoi specificare stringhe sicure come *valori* dei parametri per alcune risorse. Per ulteriori informazioni, consulta [Ottenimento di valori archiviati in altri servizi utilizzando riferimenti dinamici](dynamic-references.md).

# CloudFormation procedure dettagliate
<a name="walkthroughs"></a>

Questa documentazione fornisce una raccolta di procedure guidate pensate per offrirti esercitazioni pratiche per le implementazioni di stack.
+ [Fai riferimento agli output di risorse in un altro stack CloudFormation](walkthrough-crossstackref.md)— Questa procedura dettagliata mostra come fare riferimento agli output di uno stack all'interno di un altro stack. CloudFormation Invece di includere tutte le risorse in un unico stack, è possibile creare AWS risorse correlate in pile separate per creare modelli più modulari e riutilizzabili.
+ [Implementa le applicazioni su Amazon EC2](deploying.applications.md)— Scopri come utilizzare CloudFormation per installare, configurare e avviare automaticamente la tua applicazione sulle EC2 istanze Amazon. In questo modo, puoi duplicare in modo semplice le implementazioni e aggiornare le installazioni esistenti senza stabilire una connessione diretta con le istanze.
+ [Aggiornare uno CloudFormation stack](updating.stacks.walkthrough.md)— Esegui una semplice progressione di aggiornamenti a uno stack in esecuzione con. CloudFormation
+ [Creazione di un'applicazione dimensionata e con carico bilanciato](walkthrough-autoscaling.md)— Scopri come utilizzarla per CloudFormation creare un'applicazione scalabile e con carico bilanciato. Questa procedura guidata spiega come creare un gruppo Auto Scaling, un bilanciatore del carico e altre risorse correlate per garantire che l’applicazione possa gestire carichi di traffico variabili e mantenere un’elevata disponibilità.
+ [Peer con un VPC in un altro Account AWS](peer-with-vpc-in-another-account.md)— Questa procedura dettagliata illustra il processo di creazione di una connessione peering Virtual Private Cloud (VPC) tra due connessioni diverse. VPCs Account AWS Il peering VPC ti aiuta a indirizzare il traffico tra VPCs e ad accedere alle risorse come se facessero parte della stessa rete.
+ [Esegui le blue/green implementazioni ECS tramite l'utilizzo CodeDeploy CloudFormation](blue-green.md)— Scopri come utilizzare per CloudFormation eseguire le AWS CodeDeploy blue/green deployments on Amazon ECS. Blue/green implementazioni è un modo per aggiornare le tue applicazioni o i tuoi servizi con tempi di inattività minimi.

# Fai riferimento agli output di risorse in un altro stack CloudFormation
<a name="walkthrough-crossstackref"></a>

Questa procedura dettagliata mostra come fare riferimento agli output di uno CloudFormation stack all'interno di un altro stack per creare modelli più modulari e riutilizzabili. 

Invece di includere tutte le risorse in un unico stack, crei risorse correlate in pile separate. AWS Puoi quindi fare riferimento agli output necessari di risorse di altri stack. Limitando i riferimenti tra stack agli output, puoi controllare le parti di uno stack a cui fanno riferimento altri stack.

Ad esempio, potresti avere un stack di rete con un VPC, un gruppo di sicurezza e una sottorete per applicazioni Web pubbliche, nonché uno stack separato per le applicazioni Web pubbliche. Per garantire che le applicazioni Web utilizzino il gruppo di sicurezza e la sottorete dello stack di rete, è necessario creare un riferimento tra stack che consenta allo stack per le applicazioni Web di fare riferimento agli output delle risorse dello stack di rete. Con un riferimento tra stack, non c'è necessità i proprietari degli stack per le applicazioni Web di creare o mantenere regole o asset di rete.

Per creare un riferimento tra stack, utilizza il campo di output `Export` per contrassegnare il valore dell'output di una risorsa per l'esportazione. Quindi, importa il valore tramite la funzione intrinseca `Fn::ImportValue`. Per ulteriori informazioni, consulta [Ottieni gli output esportati da uno stack distribuito CloudFormation](using-cfn-stack-exports.md).

**Nota**  
CloudFormation è un servizio gratuito. Tuttavia, ti verranno addebitate le AWS risorse che includi nei tuoi stack alla tariffa corrente per ciascuna di esse. Per ulteriori informazioni sui prezzi di AWS visita [la pagina dei dettagli per ogni prodotto](https://aws.amazon.com/).

**Topics**
+ [Utilizzare un modello di esempio per creare uno stack di rete](#walkthrough-crossstackref-create-vpc-stack)
+ [Utilizzare un modello di esempio per creare uno stack di applicazioni web](#walkthrough-crossstackref-create-ec2-stack)
+ [Verificare che lo stack funzioni come previsto](#walkthrough-crossstackref-verify)
+ [Risolvere gli errori di mappatura AMI](#walkthrough-crossstackref-troubleshooting-ami)
+ [Pulizia delle risorse](#walkthrough-crossstackref-clean-up)

## Utilizzare un modello di esempio per creare uno stack di rete
<a name="walkthrough-crossstackref-create-vpc-stack"></a>

Prima di iniziare questa procedura dettagliata, verifica di disporre delle autorizzazioni IAM per utilizzare tutti i seguenti servizi: Amazon VPC, Amazon EC2 e. CloudFormation

Lo stack di rete contiene il VPC, il gruppo di sicurezza e la sottorete da utilizzare nello stack delle applicazioni Web. Oltre a queste risorse, lo stack di rete crea un gateway Internet e le tabelle di instradamento per abilitare l'accesso pubblico.

È necessario creare questo stack prima di creare lo stack delle applicazioni Web. Se crei prima lo stack dell'applicazione Web, non disporrai di un gruppo di sicurezza o di una sottorete.

[Il modello di stack è disponibile al seguente URL: user- .template. https://s3.amazonaws.com/cloudformation-examples/ guide/cross-stack/SampleNetworkCrossStack](https://s3.amazonaws.com/cloudformation-examples/user-guide/cross-stack/SampleNetworkCrossStack.template) Per visualizzare le risorse che saranno create dallo stack, selezionare il link per aprire il modello. Nella sezione `Outputs`, puoi visualizzare le risorse di rete esportate dal modello di esempio. I nomi delle risorse esportate hanno come prefisso il nome dello stack, qualora vengano esportate risorse di rete da altri stack. Quando gli utenti importano le risorse di rete, possono specificare da quale stack farlo.

**Per creare lo stack di rete**

1. [Accedi Console di gestione AWS e apri la CloudFormation console all'indirizzo https://console.aws.amazon.com /cloudformazione.](https://console.aws.amazon.com/cloudformation/)

1. Dalla pagina **Stack**, scegli **Crea stack** in alto a destra, poi scegli **Con nuove risorse (standard)**.

1. Seleziona **Scegli un modello esistente** e, nella sezione **Specifica modello**, scegli **URL Amazon S3**.

1. In **URL Amazon S3**, incolla il seguente URL: **https://s3.amazonaws.com/cloudformation-examples/user-guide/cross-stack/SampleNetworkCrossStack.template**.

1. Scegli **Next (Successivo)**.

1. Per **Stack name (Nome stack)**, digitare **SampleNetworkCrossStack**, quindi scegliere **Next (Avanti)**.
**Nota**  
Registrare il nome di questo stack: servirà all'avvio dello stack delle applicazioni Web.

1. Scegli **Next (Successivo)**. Per questa procedura guidata, non è necessario aggiungere tag o specificare impostazioni avanzate.

1. Assicurarsi che il nome dello stack e l’URL del modello siano corretti e scegliere **Create stack (Crea stack)**.

   La creazione dello stack potrebbe richiedere alcuni minuti. CloudFormation Attendere che tutte le risorse siano state create prima di continuare a creare lo stack delle applicazioni Web.

1. È possibile controllare l’avanzamento negli eventi per lo stack. Per ulteriori informazioni, consulta [Monitoraggio dell’avanzamento dello stack](monitor-stack-progress.md).

## Utilizzare un modello di esempio per creare uno stack di applicazioni web
<a name="walkthrough-crossstackref-create-ec2-stack"></a>

Lo stack delle applicazioni Web crea un'istanza EC2 che impiega il gruppo di sicurezza e la sottorete dello stack di rete. 

È necessario creare questo stack nello stesso stack Regione AWS di rete.

Il modello di stack è disponibile dal seguente URL: [https://s3.amazonaws.com/cloudformation-examples/user](https://s3.amazonaws.com/cloudformation-examples/user-guide/cross-stack/SampleWebAppCrossStack.template) - .template. guide/cross-stack/SampleWebAppCrossStack Per visualizzare le risorse che saranno create dallo stack, selezionare il link per aprire il modello. Nella sezione `Resources`, visualizza le proprietà dell’istanza EC2. È possibile visualizzare il modo in cui le risorse di rete vengono importate da un altro stack utilizzando la funzione `Fn::ImportValue`.

**Per creare lo stack delle applicazioni Web**

1. Dalla pagina **Stack**, scegli **Crea stack** in alto a destra, poi scegli **Con nuove risorse (standard)**.

1. Seleziona **Scegli un modello esistente** e, nella sezione **Specifica modello**, scegli **URL Amazon S3**.

1. In **URL Amazon S3**, incolla il seguente URL: **https://s3.amazonaws.com/cloudformation-examples/user-guide/cross-stack/SampleWebAppCrossStack.template**.

1. Scegli **Next (Successivo)**.

1. Per **Stack name (Nome stack)**, digitare **SampleWebAppCrossStack**. **Nella sezione **Parametri**, utilizzate il valore predefinito per il **NetworkStackName**parametro, quindi scegliete Avanti.**

   Il modello di esempio usa il valore del parametro per specificare da quale stack importare i valori.

1. Scegli **Next (Successivo)**. Per questa procedura guidata, non è necessario aggiungere tag o specificare impostazioni avanzate.

1. Assicurarsi che il nome dello stack e l’URL del modello siano corretti e scegliere **Create stack (Crea stack)**.

   La creazione dello stack potrebbe richiedere alcuni minuti. CloudFormation 

## Verificare che lo stack funzioni come previsto
<a name="walkthrough-crossstackref-verify"></a>

Dopo che lo stack è stato creato, visualizzare le relative risorse e annotare l'ID istanza. Per ulteriori informazioni sulla visualizzazione delle risorse dello stack, consulta [Visualizza le informazioni sullo stack dalla console CloudFormation](cfn-console-view-stack-data-resources.md).

Per verificare il gruppo di sicurezza e la sottorete dell'istanza, visualizzare le proprietà di quest'ultima nella [console Amazon EC2](https://console.aws.amazon.com/ec2/). Se l'istanza utilizza il gruppo di sicurezza e la sottorete dello stack `SampleNetworkCrossStack`, il riferimento tra stack è stato creato senza errori.

Utilizza la console per visualizzare gli output dello stack e l'URL del sito Web di esempio per verificare che l'applicazione Web sia operativa. Per ulteriori informazioni, consulta [Visualizza le informazioni sullo stack dalla console CloudFormation](cfn-console-view-stack-data-resources.md).

## Risolvere gli errori di mappatura AMI
<a name="walkthrough-crossstackref-troubleshooting-ami"></a>

Se ricevi l’errore `Template error: Unable to get mapping for AWSRegionArch2AMI::[region]::HVM64`, il modello non include una mappatura AMI per la Regione AWS. Invece di aggiornare la mappatura, consigliamo di utilizzare i parametri pubblici di Systems Manager per fare riferimento dinamicamente alle ultime novità: AMIs

1. Scaricate il `SampleWebAppCrossStack` modello sul computer locale da: [https://s3.amazonaws.com/cloudformation-examples/user- guide/cross-stack/SampleWebAppCrossStack](https://s3.amazonaws.com/cloudformation-examples/user-guide/cross-stack/SampleWebAppCrossStack.template) .template.

1. Elimina l’intera sezione di mappatura `AWSRegionArch2AMI`.

1. Aggiungi il seguente parametro di Systems Manager:

   ```
   "LatestAmiId": {
     "Description": "The latest Amazon Linux 2 AMI from the Parameter Store",
       "Type": "AWS::SSM::Parameter::Value<AWS::EC2::Image::Id>",
       "Default": "/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2"
     }
   ```

1. Sostituisci il riferimento `ImageId` esistente:

   ```
   "ImageId": { "Fn::FindInMap": [ "AWSRegionArch2AMI", { "Ref": "AWS::Region" } , "HVM64" ] }, 
   ```

   Con:

   ```
   "ImageId": { "Ref": "LatestAmiId" },
   ```

   Questo parametro viene risolto automaticamente nell’AMI Amazon Linux 2 più recente per la Regione in cui implementi lo stack. 

   Per altre distribuzioni Linux, utilizza il percorso del parametro adeguato. Per ulteriori informazioni, consulta [Discovering public parameters in Parameter Store](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-store-finding-public-parameters.html) nella *Guida per l’utente di AWS Systems Manager *.

1. Carica il modello modificato in un bucket S3 nell’account:

   ```
   aws s3 cp SampleWebAppCrossStack.template s3://amzn-s3-demo-bucket/
   ```

1. Quando crei lo stack, specifica l’URL S3 del modello anziché l’URL dell’esempio.

## Pulizia delle risorse
<a name="walkthrough-crossstackref-clean-up"></a>

Per assicurarti che non ti vengano addebitati servizi indesiderati, elimina gli stack.

**Per eliminare gli stack**

1. Nella CloudFormation console, scegli lo `SampleWebAppCrossStack` stack.

1. Scegliere **Actions (Operazioni)**, quindi **Delete Stack (Elimina stack)**.

1. Nel messaggio di conferma, scegliere **Delete (Elimina)**.

1. Una volta eliminato lo stack, ripeti la stessa procedura per lo stack `SampleNetworkCrossStack`.
**Nota**  
Attendi che lo stack venga eliminato CloudFormation completamente. `SampleWebAppCrossStack` Se l'istanza EC2 è ancora in esecuzione nel VPC CloudFormation , non eliminerà il VPC nello stack. `SampleNetworkCrossStack`

# Implementa le applicazioni su Amazon EC2
<a name="deploying.applications"></a>

Puoi utilizzarlo CloudFormation per installare, configurare e avviare automaticamente le applicazioni sulle istanze Amazon EC2. Ciò ti consente di duplicare in modo semplice le implementazioni e di aggiornare le installazioni esistenti senza stabilire una connessione diretta con l’istanza, risparmiando in questo modo una quantità significativa di tempo e lavoro.

CloudFormation include un set di script di supporto (`cfn-init`, `cfn-signal``cfn-get-metadata`, e`cfn-hup`) basati su. `cloud-init` Puoi richiamare questi script di supporto dai tuoi CloudFormation modelli per installare, configurare e aggiornare le applicazioni su istanze Amazon EC2 che si trovano nello stesso modello. *Per ulteriori informazioni, consulta il riferimento agli [script di CloudFormation supporto nella Template Reference Guide.](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/cfn-helper-scripts-reference.html)CloudFormation *

Nel [tutorial introduttivo](gettingstarted.walkthrough.md), hai creato un semplice server Web utilizzando `UserData` con uno script bash di base. Sebbene abbia funzionato per una semplice pagina “Hello World”, le applicazioni reali spesso richiedono configurazioni più sofisticate, tra cui:
+ Più pacchetti software installati nell’ordine corretto.
+ File di configurazione complessi creati con contenuti specifici.
+ Servizi avviati e configurati per l’esecuzione automatica.
+ Gestione degli errori e convalida del processo di configurazione.

CloudFormationgli script di supporto forniscono un modo più affidabile e gestibile per configurare le istanze EC2 rispetto agli script bash di base in. `UserData` Lo script helper `cfn-init` legge i dati di configurazione dai metadati del modello e li applica in maniera sistematica all’istanza.

In questo tutorial, scoprirai come utilizzare lo script helper `cfn-init` e come monitorare il processo di bootstrapping.

**Nota**  
CloudFormation è gratuito, ma ti verranno addebitate le risorse Amazon EC2 che crei. Tuttavia, se sei alle prime armi AWS, puoi sfruttare il [piano gratuito](https://aws.amazon.com/free/) per ridurre al minimo o eliminare i costi durante questo processo di apprendimento.

**Topics**
+ [Prerequisiti](#bootstrapping-tutorial-prerequisites)
+ [Comprensione dei concetti di bootstrap](#bootstrapping-tutorial-understand-concepts)
+ [Inizia con un semplice esempio di bootstrap](#bootstrapping-tutorial-simple-example)
+ [Aggiungere file e comandi](#bootstrapping-tutorial-add-complexity)
+ [Aggiungere la sicurezza della rete](#bootstrapping-tutorial-security-group)
+ [Il modello di bootstrap completo](#bootstrapping-tutorial-complete-template)
+ [Crea uno stack utilizzando la console](#bootstrapping-tutorial-create-stack)
+ [Monitora il processo di bootstrap](#bootstrapping-tutorial-validate-bootstrap)
+ [Prova il server Web avviato](#bootstrapping-tutorial-test-web-server)
+ [Risoluzione dei problemi di bootstrap](#bootstrapping-tutorial-troubleshooting)
+ [Eseguire la pulizia delle risorse](#bootstrapping-tutorial-clean-up)
+ [Fasi successive](#bootstrapping-tutorial-next-steps)

## Prerequisiti
<a name="bootstrapping-tutorial-prerequisites"></a>
+ Devi aver completato il [Creazione del primo stack](gettingstarted.walkthrough.md) tutorial o avere un'esperienza equivalente con le nozioni di CloudFormation base.
+ Devi avere accesso a un utente o ruolo IAM Account AWS con le autorizzazioni per usare Amazon EC2 CloudFormation e/o l'accesso come utente amministrativo.
+ È necessario disporre di un cloud privato virtuale (VPC) con accesso a Internet. Questo modello di tutorial richiede un VPC predefinito, che viene fornito automaticamente con la versione più recente dell’ Account AWS. Se non disponi di un VPC predefinito, o se è stato eliminato, consulta la sezione sulla risoluzione dei problemi nel tutorial [Creazione del primo stack](gettingstarted.walkthrough.md) per soluzioni alternative.

## Comprensione dei concetti di bootstrap
<a name="bootstrapping-tutorial-understand-concepts"></a>

Prima di creare il modello, scopriamo i concetti chiave che fanno funzionare il bootstrapping.

### Lo script helper `cfn-init`
<a name="bootstrapping-tutorial-cfn-init-overview"></a>

CloudFormation fornisce script di supporto in Python che puoi utilizzare per installare software e avviare servizi su un'istanza Amazon EC2. Lo script `cfn-init` legge i metadati delle risorse dal modello e applica la configurazione all’istanza.

Di seguito è riportato il procedimento:

1. Definisci la configurazione nella sezione `Metadata` della tua risorsa EC2.

1. Chiami `cfn-init` dallo script `UserData`.

1. `cfn-init` legge i metadati e applica la configurazione.

1. L’istanza è configurata in base alle tue specifiche.

### Struttura dei metadati
<a name="bootstrapping-tutorial-metadata-structure"></a>

La configurazione è definita in una struttura specifica all’interno dell’istanza EC2.

```
Resources:
  EC2Instance:
    Type: AWS::EC2::Instance
    Metadata:                       # Metadata section for the resource
      AWS::CloudFormation::Init:    # Required key that cfn-init looks for
        config:                     # Configuration name (you can have multiple)
          packages:                 # Install packages
          files:                    # Create files
          commands:                 # Run commands
          services:                 # Start/stop services
```

Lo script `cfn-init` elabora queste sezioni in un ordine specifico: pacchetti, gruppi, utenti, origini, file, comandi e servizi.

## Inizia con un semplice esempio di bootstrap
<a name="bootstrapping-tutorial-simple-example"></a>

Cominciamo con un esempio di bootstrap minimo, che si limita a installare e avviare Apache.

```
Resources:
  EC2Instance:
    Type: AWS::EC2::Instance
    Metadata:
      AWS::CloudFormation::Init:
        config:
          packages:                 # Install Apache web server
            yum:
              httpd: []
          services:                 # Start Apache and enable it to start on boot
            systemd:
              httpd:
                enabled: true
                ensureRunning: true
    Properties:
      ImageId: !Ref LatestAmiId
      InstanceType: !Ref InstanceType
      UserData: !Base64             # Script that runs when instance starts
        Fn::Sub: |
          #!/bin/bash
          yum install -y aws-cfn-bootstrap
          /opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource EC2Instance --region ${AWS::Region}
```

Questo semplice esempio illustra i concetti fondamentali:
+ La sezione `packages` installa il pacchetto `httpd` utilizzando yum. Funziona su Amazon Linux e altre distribuzioni Linux che utilizzano yum.
+ La sezione `services` garantisce l’avvio e l’esecuzione automatica di `httpd`.
+ `UserData` installa gli strumenti di bootstrap più recenti e chiama `cfn-init`.

## Aggiungere file e comandi
<a name="bootstrapping-tutorial-add-complexity"></a>

Ora, miglioriamo il nostro esempio aggiungendo una pagina Web personalizzata e un file di log nella directory `/var/log` dell’istanza EC2.

### Creazione dei file
<a name="bootstrapping-tutorial-files-section"></a>

La sezione `files` consente di creare file sull’istanza con contenuti specifici. La barra verticale (`|`) consente di passare un blocco letterale di testo (codice HTML) come contenuto del file (`/var/www/html/index.html`).

```
files:
  /var/www/html/index.html:
    content: |
      <body>
        <h1>Congratulations, you have successfully launched the AWS CloudFormation sample.</h1>
      </body>
```

### Esecuzione di comandi
<a name="bootstrapping-tutorial-commands-section"></a>

La sezione `commands` consente di eseguire i comandi della shell durante il processo di bootstrap. Questo comando crea un file di log in `/var/log/welcome.txt` sull’istanza EC2. Per visualizzarlo, è necessaria una coppia di chiavi di Amazon EC2 da utilizzare per l’accesso SSH e un intervallo dell’indirizzo IP che può essere utilizzato per effettuare l’accesso SSH all’istanza (non descritto in questa sezione).

```
commands:
  createWelcomeLog:
    command: "echo 'cfn-init ran successfully!' > /var/log/welcome.txt"
```

## Aggiungere la sicurezza della rete
<a name="bootstrapping-tutorial-security-group"></a>

Poiché stiamo configurando un server Web, dobbiamo consentire al traffico Web (HTTP) di raggiungere la nostra istanza EC2. Per farlo, creeremo un gruppo di sicurezza che consente il traffico in entrata sulla porta 80 dal tuo indirizzo IP. Le istanze EC2 devono inoltre inviare traffico verso Internet, ad esempio per installare gli aggiornamenti dei pacchetti. Per impostazione predefinita, i gruppi di sicurezza autorizzano tutto il traffico in uscita. Assoceremo quindi questo gruppo di sicurezza alla nostra istanza EC2 utilizzando la proprietà `SecurityGroupIds`.

```
WebServerSecurityGroup:
  Type: AWS::EC2::SecurityGroup
  Properties:
    GroupDescription: Allow HTTP access from my IP address
    SecurityGroupIngress:
      - IpProtocol: tcp
        Description: HTTP
        FromPort: 80
        ToPort: 80
        CidrIp: !Ref MyIP
```

## Il modello di bootstrap completo
<a name="bootstrapping-tutorial-complete-template"></a>

Ora, mettiamo insieme tutti i pezzi. Ecco il modello completo che combina tutti i concetti di cui abbiamo parlato.

```
AWSTemplateFormatVersion: 2010-09-09
Description: Bootstrap an EC2 instance with Apache web server using cfn-init

Parameters:
  LatestAmiId:
    Description: The latest Amazon Linux 2 AMI from the Parameter Store
    Type: AWS::SSM::Parameter::Value<AWS::EC2::Image::Id>
    Default: '/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2'

  InstanceType:
    Description: EC2 instance type
    Type: String
    Default: t2.micro
    AllowedValues:
      - t3.micro
      - t2.micro
    ConstraintDescription: must be a valid EC2 instance type.

  MyIP:
    Description: Your IP address in CIDR format (e.g. 203.0.113.1/32)
    Type: String
    MinLength: 9
    MaxLength: 18
    Default: 0.0.0.0/0
    AllowedPattern: '^(\d{1,3}\.){3}\d{1,3}\/\d{1,2}$'
    ConstraintDescription: must be a valid IP CIDR range of the form x.x.x.x/x.

Resources:
  WebServerSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Allow HTTP access from my IP address
      SecurityGroupIngress:
        - IpProtocol: tcp
          Description: HTTP
          FromPort: 80
          ToPort: 80
          CidrIp: !Ref MyIP

  WebServer:
    Type: AWS::EC2::Instance
    Metadata:
      AWS::CloudFormation::Init:
        config:
          packages:
            yum:
              httpd: []
          files:
            /var/www/html/index.html:
              content: |
                <body>
                  <h1>Congratulations, you have successfully launched the AWS CloudFormation sample.</h1>
                </body>
          commands:
            createWelcomeLog:
              command: "echo 'cfn-init ran successfully!' > /var/log/welcome.txt"
          services:
            systemd:
              httpd:
                enabled: true
                ensureRunning: true
    Properties:
      ImageId: !Ref LatestAmiId
      InstanceType: !Ref InstanceType
      SecurityGroupIds:
        - !Ref WebServerSecurityGroup
      UserData: !Base64
        Fn::Sub: |
          #!/bin/bash
          yum install -y aws-cfn-bootstrap
          /opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource WebServer --region ${AWS::Region}
      Tags:
        - Key: Name
          Value: Bootstrap Tutorial Web Server

Outputs:
  WebsiteURL:
    Value: !Sub 'http://${WebServer.PublicDnsName}'
    Description: EC2 instance public DNS name
```

## Crea uno stack utilizzando la console
<a name="bootstrapping-tutorial-create-stack"></a>

La procedura seguente prevede il caricamento del modello di stack di esempio da un file. Apri un editor di testo sul tuo computer locale e aggiungi il modello. Salva il file con il nome `samplelinux2stack.template`.

**Avvio del modello dello stack**

1. [Accedi e apri la console all'indirizzo Console di gestione AWS /cloudformazione. CloudFormation https://console.aws.amazon.com](https://console.aws.amazon.com/cloudformation/)

1. Scegli **Crea stack**, **Con nuove risorse (standard)**.

1. In **Specifica modello**, seleziona **Carica un file di modello** e poi **Scegli file** per caricare il file `samplelinux2stack.template`. 

1. Scegli **Successivo**.

1. Nella pagina **Specifica i dettagli dello stack**, inserisci **BootstrapTutorialStack** come nome dello stack.

1. Per **Parametri**, effettua le seguenti operazioni.
   + **LatestAmiId**: lascia il valore predefinito.
   + **InstanceType**: Scegli **t2.micro o **t3.micro**** per il tipo di istanza EC2.
   + **MyIP**: inserisci il tuo indirizzo IP pubblico con un suffisso `/32`.

1. Scegli **Avanti** due volte, quindi **Invia** per creare lo stack.

## Monitora il processo di bootstrap
<a name="bootstrapping-tutorial-validate-bootstrap"></a>

I processi di bootstrap richiedono più tempo rispetto ai semplici avvii di EC2 perché vengono installati e configurati software aggiuntivi.

**Per monitorare l’avanzamento del bootstrap**

1. **Nella CloudFormation console, seleziona il tuo stack e apri la scheda Eventi.**

1. Cerca l’evento `WebServer CREATE_IN_PROGRESS`. Il processo di bootstrap inizia dopo l’avvio dell’istanza.

1. In genere, il processo di bootstrap richiede pochi minuti. Al termine vedrai `WebServer CREATE_COMPLETE`.

Se vuoi vedere cosa succede durante il processo di bootstrap, puoi controllare i log delle istanze.

**Visualizzare i log di bootstrap (facoltativo)**

1. Apri la [console EC2](https://console.aws.amazon.com/ec2/) e trova l’istanza.

1. Seleziona l’istanza e poi scegli **Operazioni**, **Monitoraggio e risoluzione dei problemi**, **Ottieni il log di sistema** per visualizzare i progressi del bootstrap.

1. Se non vedi i log immediatamente, attendi e aggiorna la pagina. 

## Prova il server Web avviato
<a name="bootstrapping-tutorial-test-web-server"></a>

Quando il tuo stack mostra `CREATE_COMPLETE`, esegui il test del tuo server Web.

**Per testare il server web**

1. Nella CloudFormation console, vai alla scheda **Output** relativa al tuo stack.

1. Fai clic sul valore **WebsiteURL** per aprire il tuo server Web in una nuova scheda.

1. Dovresti vedere la tua pagina Web personalizzata con il messaggio `Congratulations, you have successfully launched the AWS CloudFormation sample`.

**Nota**  
Se la pagina non viene caricata immediatamente, attendi un minuto e riprova. Il processo di bootstrap potrebbe essere ancora completato anche dopo che lo stack mostra `CREATE_COMPLETE`.

## Risoluzione dei problemi di bootstrap
<a name="bootstrapping-tutorial-troubleshooting"></a>

Se il processo di bootstrap fallisce o il server Web non funziona, ecco i problemi e le soluzioni più comuni.

### Problemi comuni
<a name="bootstrapping-tutorial-common-issues"></a>
+ **La creazione dello stack fallisce**: controlla la scheda **Eventi** per messaggi di errore specifici.
+ **Server Web non accessibile**: verifica che l’indirizzo IP sia corretto nel parametro `MyIP`. Ricordati di includere `/32` alla fine.
+ **Il processo di bootstrap fallisce**: l’istanza si avvia ma `cfn-init` fallisce. Controlla i log di sistema come descritto nella sezione di monitoraggio.

## Eseguire la pulizia delle risorse
<a name="bootstrapping-tutorial-clean-up"></a>

Per evitare addebiti in corso, puoi eseguire una pulizia eliminando lo stack e le relative risorse. 

**Eliminare lo stack e delle relative risorse**

1. Apri la [CloudFormation console](https://console.aws.amazon.com/cloudformation/).

1. Nella pagina **Stack** seleziona l’opzione accanto al nome dello stack che hai creato (**BootstrapTutorialStack**), quindi scegli **Elimina**.

1. Quando viene richiesta la conferma, seleziona **Elimina**.

1. Monitora l’avanzamento del processo di eliminazione dello stack nella scheda **Evento**. Lo stato di **BootstrapTutorialStack** cambia in `DELETE_IN_PROGRESS`. Una volta CloudFormation completata l'eliminazione dello stack, lo rimuove dall'elenco.

## Fasi successive
<a name="bootstrapping-tutorial-next-steps"></a>

Complimenti\$1 Hai imparato con successo come avviare le istanze EC2 con. CloudFormation Ora sai:
+ Come usare gli script helper `cfn-init`
+ Come strutturare i metadati per il bootstrapping
+ Come installare pacchetti, creare file, eseguire comandi e gestire servizi
+ Come monitorare i problemi di bootstrap

Per continuare a imparare:
+ Scopri come aggiornare uno stack in esecuzione e utilizzare lo script di supporto. `cfn-hup` Per ulteriori informazioni, consulta [Aggiornare uno CloudFormation stack](updating.stacks.walkthrough.md).
+ Scopri come eseguire il bootstrap di uno stack Windows. Per ulteriori informazioni, consulta [Stack basati sul bootstrap Windows CloudFormation](cfn-windows-stacks-bootstrapping.md).
+ Esplora scenari di bootstrap più complessi con più set di configurazione. *Per maggiori informazioni, consulta [cfn-init](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/cfn-init.html) e [AWS::CloudFormation::Init](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-init.html)nella Template Reference Guide.CloudFormation *
+ Scopri come segnalare lo stato di completamento del bootstrap con `cfn-signal`. Per ulteriori informazioni, consulta [cfn-signal](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/cfn-signal.html) in *CloudFormation Template Reference Guide*.

# Aggiornare uno CloudFormation stack
<a name="updating.stacks.walkthrough"></a>

**Nota**  
Questo tutorial si basa sui concetti del [Implementa le applicazioni su Amazon EC2](deploying.applications.md) tutorial. Se non hai completato il tutorial, ti consigliamo di farlo prima per capire come funziona il EC2 bootstrap con. CloudFormation

Questo argomento illustra una semplice progressione degli aggiornamenti a uno stack in esecuzione. Verranno descritte le fasi seguenti:

1. **Crea lo stack iniziale**: crea uno stack utilizzando un'AMI Amazon Linux 2 di base, installando Apache Web Server e una semplice applicazione PHP utilizzando gli CloudFormation script di supporto.

1. **Aggiorna l'applicazione**: aggiorna uno dei file dell'applicazione e distribuisci il software utilizzando. CloudFormation

1. **Aggiungi una coppia di chiavi**: aggiungi una coppia di EC2 chiavi Amazon all'istanza, quindi aggiorna il gruppo di sicurezza per consentire l'accesso SSH all'istanza.

1. **Aggiorna il tipo di istanza**: modifica il tipo di istanza dell' EC2 istanza Amazon sottostante.

1. **Aggiorna l'AMI**: modifica l'Amazon Machine Image (AMI) per l' EC2 istanza Amazon nel tuo stack.

**Nota**  
CloudFormation è gratuito, ma ti verranno addebitati i costi per le EC2 risorse Amazon che crei. Tuttavia, se sei alle prime armi AWS, puoi sfruttare il [piano gratuito](https://aws.amazon.com/free/) per ridurre al minimo o eliminare i costi durante questo processo di apprendimento.

**Topics**
+ [Fase 1: Creare lo stack iniziale](#update-stack-initial-stack)
+ [Passaggio 2: aggiorna l'applicazione](#update-stack-update-application)
+ [Fase 3: Aggiungere l'accesso SSH con una coppia di key pair](#update-stack-add-key-pair)
+ [Fase 4: Aggiornare il tipo di istanza](#update-stack-update-instance-type)
+ [Fase 5: Aggiornare l'AMI](#update-stack-update-ami)
+ [Considerazioni su disponibilità e impatto](#update.walkthrough.impact)
+ [Risorse correlate](#update.walkthrough.related)

## Fase 1: Creare lo stack iniziale
<a name="update-stack-initial-stack"></a>

Inizieremo creando uno stack che potremo utilizzare nel resto di questo argomento. Abbiamo fornito un modello semplice che avvia un'applicazione Web PHP a istanza singola ospitata su Apache Web Server e in esecuzione su un'AMI Amazon Linux 2.

L'Apache Web Serverapplicazione PHP e la semplice applicazione PHP sono tutte installate dagli script di CloudFormation supporto installati di default sull'AMI Amazon Linux 2. Il seguente frammento di modello mostra i metadati che descrivono i pacchetti e i file da installare, in questo caso l'Apache Web Serverinfrastruttura PHP dal Yum repository per l'AMI Amazon Linux 2. Lo snippet mostra anche la `Services` sezione, che assicura che sia in esecuzione. Apache Web Server 

```
WebServerInstance:
  Type: AWS::EC2::Instance
  Metadata:
    AWS::CloudFormation::Init:
      config:
        packages:
          yum:
            httpd: []
            php: []
        files:
          /var/www/html/index.php:
            content: |
              <?php
              echo '<h1>Hello World!</h1>';
              ?>
            mode: '000644'
            owner: apache
            group: apache
        services:
          systemd:
            httpd:
              enabled: true
              ensureRunning: true
```

L'applicazione stessa è un esempio di «Hello World» interamente definito all'interno del modello. Per un'applicazione reale, i file possono essere archiviati su Amazon S3 GitHub o su un altro repository e referenziati dal modello. CloudFormation può scaricare pacchetti (come RPMs o RubyGems) e fare riferimento a singoli file ed espandere `.zip` e `.tar` file per creare gli artefatti dell'applicazione sull'istanza Amazon EC2.

Il modello abilita e configura il `cfn-hup` demone per ascoltare le modifiche alla configurazione definita nei metadati per l'istanza Amazon. EC2 Utilizzando il `cfn-hup` daemon, puoi aggiornare il software applicativo, come la versione di Apache o PHP, oppure puoi aggiornare il file dell'applicazione PHP stesso da. CloudFormation Il seguente frammento della stessa EC2 risorsa Amazon nel modello mostra le parti necessarie per configurare la chiamata `cfn-init` ogni due minuti `cfn-hup` per notificare e applicare gli aggiornamenti ai metadati. Altrimenti, viene eseguito una `cfn-init` sola volta all'avvio.

```
files:
  /etc/cfn/cfn-hup.conf:
    content: !Sub |
      [main]
      stack=${AWS::StackId}
      region=${AWS::Region}
      # The interval used to check for changes to the resource metadata in minutes. Default is 15
      interval=2
    mode: '000400'
    owner: root
    group: root
  /etc/cfn/hooks.d/cfn-auto-reloader.conf:
    content: !Sub |
      [cfn-auto-reloader-hook]
      triggers=post.update
      path=Resources.WebServerInstance.Metadata.AWS::CloudFormation::Init
      action=/opt/aws/bin/cfn-init -s ${AWS::StackId} -r WebServerInstance --region ${AWS::Region}
      runas=root
services:
  systemd:
    cfn-hup:
      enabled: true
      ensureRunning: true
      files:
        - /etc/cfn/cfn-hup.conf
        - /etc/cfn/hooks.d/cfn-auto-reloader.conf
```

Per completare lo stack, nella `Properties` sezione della definizione dell' EC2 istanza Amazon, la `UserData` proprietà contiene lo `cloud-init` script che chiama `cfn-init` per installare i pacchetti e i file. Per ulteriori informazioni, consulta il [riferimento agli script di CloudFormation supporto](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/cfn-helper-scripts-reference.html) nella *CloudFormation Template* Reference Guide. Il modello crea anche un gruppo EC2 di sicurezza Amazon.

```
AWSTemplateFormatVersion: 2010-09-09

Parameters:
  LatestAmiId:
    Description: The latest Amazon Linux 2 AMI from the Parameter Store
    Type: AWS::SSM::Parameter::Value<AWS::EC2::Image::Id>
    Default: '/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2'

  InstanceType:
    Description: WebServer EC2 instance type
    Type: String
    Default: t3.micro
    AllowedValues:
      - t3.nano
      - t3.micro
      - t3.small
      - t3.medium
      - t3a.nano
      - t3a.micro
      - t3a.small
      - t3a.medium
      - m5.large
      - m5.xlarge
      - m5.2xlarge
      - m5a.large
      - m5a.xlarge
      - m5a.2xlarge
      - c5.large
      - c5.xlarge
      - c5.2xlarge
      - r5.large
      - r5.xlarge
      - r5.2xlarge
      - r5a.large
      - r5a.xlarge
      - r5a.2xlarge
    ConstraintDescription: must be a valid EC2 instance type.
    
Resources:
  WebServerInstance:
    Type: AWS::EC2::Instance
    Properties:
      ImageId: !Ref LatestAmiId
      InstanceType: !Ref InstanceType
      SecurityGroupIds:
        - !Ref WebServerSecurityGroup
      UserData:
        Fn::Base64: !Sub |
          #!/bin/bash -xe
          # Get the latest CloudFormation package
          yum update -y aws-cfn-bootstrap
          # Run cfn-init
          /opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource WebServerInstance --region ${AWS::Region} || error_exit 'Failed to run cfn-init'        
          # Start up the cfn-hup daemon to listen for changes to the EC2 instance metadata
          /opt/aws/bin/cfn-hup || error_exit 'Failed to start cfn-hup'
          # Signal success or failure
          /opt/aws/bin/cfn-signal -e $? --stack ${AWS::StackName} --resource WebServerInstance --region ${AWS::Region}
    Metadata:
      AWS::CloudFormation::Init:
        config:
          packages:
            yum:
              httpd: []
              php: []
          files:
            /var/www/html/index.php:
              content: |
                <?php
                echo "<h1>Hello World!</h1>";
                ?>
              mode: '000644'
              owner: apache
              group: apache
            /etc/cfn/cfn-hup.conf:
              content: !Sub |
                [main]
                stack=${AWS::StackId}
                region=${AWS::Region}
                # The interval used to check for changes to the resource metadata in minutes. Default is 15
                interval=2
              mode: '000400'
              owner: root
              group: root
            /etc/cfn/hooks.d/cfn-auto-reloader.conf:
              content: !Sub |
                [cfn-auto-reloader-hook]
                triggers=post.update
                path=Resources.WebServerInstance.Metadata.AWS::CloudFormation::Init
                action=/opt/aws/bin/cfn-init -s ${AWS::StackId} -r WebServerInstance --region ${AWS::Region}
                runas=root
          services:
            systemd:
              httpd:
                enabled: true
                ensureRunning: true
              cfn-hup:
                enabled: true
                ensureRunning: true
                files:
                  - /etc/cfn/cfn-hup.conf
                  - /etc/cfn/hooks.d/cfn-auto-reloader.conf
    CreationPolicy:
      ResourceSignal:
        Timeout: PT5M

  WebServerSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Enable HTTP access via port 80
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: 80
          ToPort: 80
          CidrIp: 0.0.0.0/0

Outputs:
  WebsiteURL:
    Value: !Sub 'http://${WebServerInstance.PublicDnsName}'
    Description: URL of the web application
```

**Per avviare uno stack da questo modello**

1. Copia il modello e salvalo localmente sul tuo sistema come file di testo. Annotare il percorso perché sarà necessario utilizzare il file in una fase successiva.

1. Accedi Console di gestione AWS e apri la CloudFormation console all'indirizzo [https://console.aws.amazon.com/cloudformazione.](https://console.aws.amazon.com/cloudformation/)

1. Scegli **Crea stack, con nuove risorse** (standard).

1. Scegli **Scegli un modello esistente**.

1. In **Specificare modello**, scegli **Carica un file modello** e vai al file che hai creato nel primo passaggio, quindi scegli **Avanti**.

1. Nella pagina **Specificare i dettagli dello stack**, immettete **UpdateTutorial** come nome dello stack.

1. In **Parametri**, mantieni invariati tutti i parametri e scegli **Avanti** due volte.

1. Nella schermata **Rivedi e crea**, scegli **Invia**.

Dopo che lo stato del tuo stack sarà stato raggiunto`CREATE_COMPLETE`, la scheda **Output** mostrerà l'URL del tuo sito web. Se scegli il valore dell'`WebsiteURL`output, vedrai funzionare la tua nuova applicazione PHP.

## Passaggio 2: aggiorna l'applicazione
<a name="update-stack-update-application"></a>

Una volta distribuito lo stack, è il momento di aggiornare l'applicazione. Apporteremo una semplice modifica al testo visualizzato dall'applicazione. Per farlo, aggiungeremo un comando echo al file index.php come illustrato in questo frammento di modello:

```
files:
  /var/www/html/index.php:
    content: |
      <?php
      echo "<h1>Hello World!</h1>";
      echo "<p>This is an updated version of our application.</p>";
      ?>
    mode: '000644'
    owner: apache
    group: apache
```

Utilizza un editor di testo per modificare manualmente il file del modello salvato in locale.

Ora aggiorna lo stack.

**Per aggiornare lo stack con il modello aggiornato**

1. Nella CloudFormation console, seleziona il tuo **UpdateTutorial** stack.

1. Scegli **Aggiorna, Effettua un aggiornamento diretto**.

1. Scegli **Sostituisci modello esistente**.

1. In **Specificare modello**, scegli **Carica un file modello** e carica il file modello modificato, quindi scegli **Avanti**.

1. Nella pagina **Specificare i dettagli dello stack**, mantieni invariati tutti i parametri e scegli **Avanti** due volte.

1. Nella pagina **Revisione**, esamina le modifiche. In **Modifiche**, dovresti vedere che CloudFormation aggiornerà la `WebServerInstance` risorsa.

1. Seleziona **Invia**.

Quando lo stack è nello `UPDATE_COMPLETE` stato, puoi scegliere nuovamente il valore `WebsiteURL` di output per verificare che le modifiche all'applicazione abbiano avuto effetto. Il `cfn-hup` demone viene eseguito ogni 2 minuti, quindi potrebbero essere necessari fino a 2 minuti prima che l'applicazione cambi una volta aggiornato lo stack.

Per vedere il set di risorse che sono state aggiornate, vai alla console. CloudFormation Nella scheda **Events (Eventi)** controlla gli eventi dello stack. In questo caso particolare, i metadati per l' EC2 istanza Amazon sono `WebServerInstance` stati aggiornati, il che ha CloudFormation comportato anche una rivalutazione delle altre risorse (`WebServerSecurityGroup`) per garantire che non vi fossero altre modifiche. Nessuna delle altre risorse dello stack è stata modificata. CloudFormation aggiornerà solo le risorse dello stack interessate dalle modifiche allo stack. Tali modifiche possono essere dirette, ad esempio modifiche alle proprietà o ai metadati, oppure possono essere dovute a dipendenze o flussi di dati o ad altre funzioni `Ref` `GetAtt` intrinseche del modello. Per ulteriori informazioni, consulta [Intrinsic function reference](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference.html).

Questo semplice aggiornamento illustra il processo. Tuttavia, puoi apportare modifiche molto più complesse ai file e ai pacchetti distribuiti nelle tue EC2 istanze Amazon. Ad esempio, puoi decidere di aggiungere MySQL all'istanza, insieme al supporto PHP per MySQL. A tale scopo, è sufficiente aggiungere gli ulteriori pacchetti e file con eventuali altri servizi alla configurazione e quindi aggiornare lo stack per distribuire le modifiche.

```
packages:
  yum:
    httpd: []
    php: []
    mysql: []
    php-mysql: []
    mysql-server: []
    mysql-libs: []

  ...

services:
  systemd:
    httpd:
      enabled: true
      ensureRunning: true
    cfn-hup:
      enabled: true
      ensureRunning: true
      files:
        - /etc/cfn/cfn-hup.conf
        - /etc/cfn/hooks.d/cfn-auto-reloader.conf
    mysqld:
      enabled: true
      ensureRunning: true
```

Puoi aggiornare i CloudFormation metadati per aggiornarli alle nuove versioni dei pacchetti utilizzati dall'applicazione. Negli esempi precedenti, la proprietà version per ogni pacchetto è vuota, a indicare che `cfn-init` deve installare la versione più recente del pacchetto.

```
packages:
  yum:
    httpd: []
    php: []
```

È possibile specificare una stringa di versione per un pacchetto. Se modifichi la stringa della versione nelle successive chiamate di aggiornamento dello stack, verrà distribuita la nuova versione del pacchetto. Ecco un esempio di utilizzo dei numeri di versione per RubyGems i pacchetti. Qualsiasi pacchetto che supporta il controllo delle versioni può avere versioni specifiche.

```
packages:
  rubygems:
    mysql: []
    rubygems-update:
      - "1.6.2"
    rake:
      - "0.8.7"
    rails:
      - "2.3.11"
```

## Fase 3: Aggiungere l'accesso SSH con una coppia di key pair
<a name="update-stack-add-key-pair"></a>

Puoi anche aggiornare una risorsa nel modello per aggiungere proprietà che non erano state originariamente specificate nel modello. Per illustrare ciò, aggiungeremo una coppia di EC2 chiavi Amazon a un' EC2istanza esistente e quindi apriremo la porta 22 nel gruppo di EC2 sicurezza Amazon in modo da poter utilizzare Secure Shell (SSH) per accedere all'istanza.

**Per aggiungere l'accesso SSH a un'istanza Amazon EC2 esistente**

1. Aggiungi due parametri aggiuntivi al modello per inserire il nome di una coppia di EC2 chiavi Amazon esistente e di una posizione SSH.

   ```
   Parameters:
     KeyName:
       Description: Name of an existing EC2 KeyPair to enable SSH access to the instance
       Type: AWS::EC2::KeyPair::KeyName
       ConstraintDescription: must be the name of an existing EC2 KeyPair.
   
     SSHLocation:
       Description: The IP address that can be used to SSH to the EC2 instances in CIDR format (e.g. 203.0.113.1/32)
       Type: String
       MinLength: 9
       MaxLength: 18
       Default: 0.0.0.0/0
       AllowedPattern: '^(\d{1,3}\.){3}\d{1,3}\/\d{1,2}$'
       ConstraintDescription: must be a valid IP CIDR range of the form x.x.x.x/x.
   ```

1. Aggiungi la `KeyName` proprietà all' EC2 istanza Amazon.

   ```
   WebServerInstance:
     Type: AWS::EC2::Instance
     Properties:
       ImageId: !Ref LatestAmiId
       InstanceType: !Ref InstanceType
       KeyName: !Ref KeyName
       SecurityGroupIds:
         - !Ref WebServerSecurityGroup
   ```

1. Aggiungi la porta 22 e la posizione SSH alle regole di ingresso per il gruppo di EC2 sicurezza Amazon.

   ```
   WebServerSecurityGroup:
     Type: AWS::EC2::SecurityGroup
     Properties:
       GroupDescription: Enable HTTP access via port 80 and SSH access via port 22
       SecurityGroupIngress:
         - IpProtocol: tcp
           FromPort: 80
           ToPort: 80
           CidrIp: 0.0.0.0/0
         - IpProtocol: tcp
           FromPort: 22
           ToPort: 22
           CidrIp: !Ref SSHLocation
   ```

1. Aggiorna lo stack seguendo gli stessi passaggi spiegati in. [Passaggio 2: aggiorna l'applicazione](#update-stack-update-application)

## Fase 4: Aggiornare il tipo di istanza
<a name="update-stack-update-instance-type"></a>

Ora dimostriamo come aggiornare l'infrastruttura sottostante modificando il tipo di istanza.

Lo stack che abbiamo creato finora utilizza un'istanza Amazon EC2 t3.micro. Supponiamo che il tuo sito web appena creato stia ricevendo più traffico di quanto possa gestire un'istanza t3.micro e ora desideri passare a un tipo di istanza Amazon m5.large. EC2 Se l'architettura del tipo di istanza cambia, l'istanza deve essere creata con un'AMI diversa. Tuttavia, sia t3.micro che m5.large utilizzano le stesse architetture di CPU ed eseguono Amazon Linux 2 (x86\$164). AMIs Per ulteriori informazioni, consulta la sezione [Compatibilità per la modifica del tipo di istanza](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/resize-limitations.html) nella *Amazon EC2 User Guide*.

Utilizziamo il modello che abbiamo modificato nel passaggio precedente per cambiare il tipo di istanza. Poiché `InstanceType` era un parametro di input per il modello, non è necessario modificare il modello; possiamo modificare il valore del parametro nella pagina **Specificare i dettagli dello stack**.

**Per aggiornare lo stack con un nuovo valore di parametro**

1. Nella CloudFormation console, seleziona il tuo **UpdateTutorial** stack.

1. Scegli **Aggiorna, Effettua un aggiornamento diretto**.

1. Scegli **Usa modello esistente**, quindi scegli **Avanti**.

1. Nella pagina **Specificare i dettagli dello stack**, modifica il valore della casella di **InstanceType**testo da `t3.micro` a`m5.large`. Quindi, scegli **Avanti** due volte.

1. Nella pagina **Revisione**, esamina le modifiche. In **Modifiche**, dovresti vedere che CloudFormation aggiornerà la `WebServerInstance` risorsa.

1. Seleziona **Invia**.

Puoi modificare dinamicamente il tipo di istanza di un'istanza EC2 Amazon supportata da EBS avviando e arrestando l'istanza. CloudFormation tenta di ottimizzare la modifica aggiornando il tipo di istanza e riavviando l'istanza, in modo che l'ID dell'istanza non cambi. Quando l'istanza viene riavviata, tuttavia, l'indirizzo IP pubblico dell'istanza cambia. Per garantire che l'indirizzo IP elastico sia associato correttamente dopo la modifica, CloudFormation aggiornerà anche l'indirizzo IP elastico. Puoi vedere le modifiche nella CloudFormation console nella scheda **Eventi**.

Per verificare il tipo di istanza da Console di gestione AWS, apri la EC2 console Amazon e individua l'istanza lì.

## Fase 5: Aggiornare l'AMI
<a name="update-stack-update-ami"></a>

Ora aggiorniamo il nostro stack per utilizzare Amazon Linux 2023, che è la prossima generazione di Amazon Linux. 

L'aggiornamento dell'AMI è una modifica importante che richiede la sostituzione dell'istanza. Non possiamo semplicemente avviare e fermare l'istanza per modificare l'AMI; la CloudFormation considera una modifica a una proprietà immutabile della risorsa. Per apportare una modifica a una proprietà immutabile, è CloudFormation necessario avviare una risorsa sostitutiva, in questo caso una nuova EC2 istanza Amazon che esegue la nuova AMI. 

Diamo un'occhiata a come potremmo aggiornare il nostro modello di stack per utilizzare Amazon Linux 2023. Le modifiche principali includono l'aggiornamento del parametro AMI e il passaggio `yum` da un gestore di `dnf` pacchetti.

```
AWSTemplateFormatVersion: 2010-09-09

Parameters:
  LatestAmiId:
    Description: The latest Amazon Linux 2023 AMI from the Parameter Store
    Type: AWS::SSM::Parameter::Value<AWS::EC2::Image::Id>
    Default: '/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-6.1-x86_64'

  InstanceType:
    Description: WebServer EC2 instance type
    Type: String
    Default: t3.micro
    AllowedValues:
      - t3.nano
      - t3.micro
      - t3.small
      - t3.medium
      - t3a.nano
      - t3a.micro
      - t3a.small
      - t3a.medium
      - m5.large
      - m5.xlarge
      - m5.2xlarge
      - m5a.large
      - m5a.xlarge
      - m5a.2xlarge
      - c5.large
      - c5.xlarge
      - c5.2xlarge
      - r5.large
      - r5.xlarge
      - r5.2xlarge
      - r5a.large
      - r5a.xlarge
      - r5a.2xlarge
    ConstraintDescription: must be a valid EC2 instance type.

  KeyName:
    Description: Name of an existing EC2 KeyPair to enable SSH access to the instance
    Type: AWS::EC2::KeyPair::KeyName
    ConstraintDescription: must be the name of an existing EC2 KeyPair.

  SSHLocation:
    Description: The IP address that can be used to SSH to the EC2 instances in CIDR format (e.g. 203.0.113.1/32)
    Type: String
    MinLength: 9
    MaxLength: 18
    Default: 0.0.0.0/0
    AllowedPattern: '^(\d{1,3}\.){3}\d{1,3}\/\d{1,2}$'
    ConstraintDescription: must be a valid IP CIDR range of the form x.x.x.x/x.
    
Resources:
  WebServerInstance:
    Type: AWS::EC2::Instance
    Properties:
      ImageId: !Ref LatestAmiId
      InstanceType: !Ref InstanceType
      KeyName: !Ref KeyName
      SecurityGroupIds:
        - !Ref WebServerSecurityGroup
      UserData:
        Fn::Base64: !Sub |
          #!/bin/bash -xe
          # Get the latest CloudFormation package
          dnf update -y aws-cfn-bootstrap
          # Run cfn-init
          /opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource WebServerInstance --region ${AWS::Region} || error_exit 'Failed to run cfn-init'        
          # Start up the cfn-hup daemon to listen for changes to the EC2 instance metadata
          /opt/aws/bin/cfn-hup || error_exit 'Failed to start cfn-hup'
          # Signal success or failure
          /opt/aws/bin/cfn-signal -e $? --stack ${AWS::StackName} --resource WebServerInstance --region ${AWS::Region}
    Metadata:
      AWS::CloudFormation::Init:
        config:
          packages:
            dnf:
              httpd: []
              php: []
          files:
            /var/www/html/index.php:
              content: |
                <?php
                echo "<h1>Hello World!</h1>";
                echo "<p>This is an updated version of our application.</p>";
                echo "<p>Running on Amazon Linux 2023!</p>";
                ?>
              mode: '000644'
              owner: apache
              group: apache
            /etc/cfn/cfn-hup.conf:
              content: !Sub |
                [main]
                stack=${AWS::StackId}
                region=${AWS::Region}
                # The interval used to check for changes to the resource metadata in minutes. Default is 15
                interval=2
              mode: '000400'
              owner: root
              group: root
            /etc/cfn/hooks.d/cfn-auto-reloader.conf:
              content: !Sub |
                [cfn-auto-reloader-hook]
                triggers=post.update
                path=Resources.WebServerInstance.Metadata.AWS::CloudFormation::Init
                action=/opt/aws/bin/cfn-init -s ${AWS::StackId} -r WebServerInstance --region ${AWS::Region}
                runas=root
          services:
            systemd:
              httpd:
                enabled: true
                ensureRunning: true
              cfn-hup:
                enabled: true
                ensureRunning: true
                files:
                  - /etc/cfn/cfn-hup.conf
                  - /etc/cfn/hooks.d/cfn-auto-reloader.conf
    CreationPolicy:
      ResourceSignal:
        Timeout: PT5M

  WebServerSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Enable HTTP access via port 80 and SSH access via port 22
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: 80
          ToPort: 80
          CidrIp: 0.0.0.0/0
        - IpProtocol: tcp
          FromPort: 22
          ToPort: 22
          CidrIp: !Ref SSHLocation

Outputs:
  WebsiteURL:
    Value: !Sub 'http://${WebServerInstance.PublicDnsName}'
    Description: URL of the web application
```

Aggiorna lo stack seguendo gli stessi passaggi spiegati in[Passaggio 2: aggiorna l'applicazione](#update-stack-update-application).

Dopo l'esecuzione della nuova istanza, CloudFormation aggiorna le altre risorse dello stack in modo che puntino alla nuova risorsa. Quando tutte le nuove risorse sono state create, la vecchia risorsa viene eliminata, in un processo noto come `UPDATE_CLEANUP`. Questa volta noterai che l'ID istanza e l'URL applicazione dell'istanza nello stack sono cambiati in conseguenza dell'aggiornamento. **Gli eventi nella tabella Eventi contengono una descrizione «L'aggiornamento richiesto comporta una modifica a una proprietà immutabile e quindi crea una nuova risorsa fisica» per indicare che una risorsa è stata sostituita.**

In alternativa: se hai un codice applicativo scritto nell'AMI che desideri aggiornare, puoi utilizzare lo stesso meccanismo di aggiornamento dello stack per aggiornare l'AMI e caricare la tua nuova applicazione.

**Per aggiornare l'AMI con codice applicativo personalizzato**

1. Crea la tua nuova AMI contenente le modifiche all'applicazione o al sistema operativo. *Per ulteriori informazioni, consulta [Creare un'AMI supportata da Amazon EBS nella](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/creating-an-ami-ebs.html) Amazon User Guide. EC2 *

1. Aggiorna il modello per incorporare il nuovo ID AMI.

1. Aggiorna lo stack seguendo gli stessi passaggi spiegati in[Passaggio 2: aggiorna l'applicazione](#update-stack-update-application).

Quando aggiorni lo stack, CloudFormation rileva che l'ID AMI è cambiato e quindi attiva un aggiornamento dello stack nello stesso modo in cui abbiamo avviato quello precedente.

## Considerazioni su disponibilità e impatto
<a name="update.walkthrough.impact"></a>

Diverse proprietà hanno diverso impatto sulle risorse nello stack. È possibile utilizzare CloudFormation per aggiornare qualsiasi proprietà; tuttavia, prima di apportare modifiche, è opportuno considerare le seguenti domande:

1. In che modo l'aggiornamento influisce sulla risorsa stessa? Ad esempio, l'aggiornamento di una soglia di allarme renderà l'allarme inattivo durante l'aggiornamento. Come abbiamo visto, la modifica del tipo di istanza richiede l'arresto e il riavvio dell'istanza. CloudFormation utilizza le azioni di aggiornamento o modifica delle risorse sottostanti per apportare modifiche alle risorse. Per comprendere l'impatto degli aggiornamenti, è necessario verificare la documentazione delle risorse specifiche.

1. La modifica è modificabile o non modificabile? Alcune modifiche alle proprietà delle risorse, come la modifica dell'AMI su un' EC2 istanza Amazon, non sono supportate dai servizi sottostanti. In caso di modifiche modificabili, CloudFormation utilizzerà il tipo Update o Modify APIs per le risorse sottostanti. Per le modifiche immutabili alle proprietà, CloudFormation creerà nuove risorse con le proprietà aggiornate e quindi le collegherà allo stack prima di eliminare le vecchie risorse. Sebbene CloudFormation cerchi di ridurre i tempi di inattività delle risorse dello stack, la sostituzione di una risorsa è un processo in più fasi e richiederà tempo. Durante la riconfigurazione dello stack, l'applicazione non sarà completamente operativa. Ad esempio, potrebbe non essere in grado di servire richieste o accedere a un database.

## Risorse correlate
<a name="update.walkthrough.related"></a>

Per ulteriori informazioni sull'utilizzo CloudFormation per avviare le applicazioni e sull'integrazione con altri servizi di configurazione e distribuzione come Puppet eOpscode Chef, consulta i seguenti white paper:
+ [Avvio delle applicazioni tramite CloudFormation](https://s3.amazonaws.com/cloudformation-examples/BoostrappingApplicationsWithAWSCloudFormation.pdf)
+ [Integrazione con CloudFormation Opscode Chef](https://s3.amazonaws.com/cloudformation-examples/IntegratingAWSCloudFormationWithOpscodeChef.pdf)
+ [Integrazione con CloudFormation Puppet](https://s3.amazonaws.com/cloudformation-examples/IntegratingAWSCloudFormationWithPuppet.pdf)

# Creazione di un'applicazione dimensionata e con carico bilanciato
<a name="walkthrough-autoscaling"></a>

Per questa procedura dettagliata, viene creato uno stack che aiuta a configurare un'applicazione dimensionata e con carico bilanciato. La procedura guidata fornisce un modello di esempio che potrai usare per creare lo stack. Il modello di esempio prevede un gruppo con dimensionamento automatico, un Application Load Balancer, gruppi di sicurezza che controllano il traffico verso il sistema di bilanciamento del carico e il gruppo con dimensionamento automatico e una configurazione di notifica Amazon SNS per pubblicare notifiche sulle attività di dimensionamento. 

Questo modello consente di creare una o più istanze Amazon EC2 e un Application Load Balancer. Se crei uno stack da questo modello, ti verranno addebitate le risorse AWS utilizzate. 

## Modello full stack
<a name="example-templates-autoscaling-full-stack-template"></a>

Cominciamo con il modello.

**YAML**

```
AWSTemplateFormatVersion: 2010-09-09
Parameters:
  InstanceType:
    Description: The EC2 instance type
    Type: String
    Default: t3.micro
    AllowedValues:
      - t3.micro
      - t3.small
      - t3.medium
  KeyName:
    Description: Name of an existing EC2 key pair to allow SSH access to the instances
    Type: AWS::EC2::KeyPair::KeyName
  LatestAmiId:
    Description: The latest Amazon Linux 2 AMI from the Parameter Store
    Type: AWS::SSM::Parameter::Value<AWS::EC2::Image::Id>
    Default: '/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2'
  OperatorEmail:
    Description: The email address to notify when there are any scaling activities
    Type: String
  SSHLocation:
    Description: The IP address range that can be used to SSH to the EC2 instances
    Type: String
    MinLength: 9
    MaxLength: 18
    Default: 0.0.0.0/0
    ConstraintDescription: must be a valid IP CIDR range of the form x.x.x.x/x.
  Subnets:
    Type: 'List<AWS::EC2::Subnet::Id>'
    Description: At least two public subnets in different Availability Zones in the selected VPC
  VPC:
    Type: AWS::EC2::VPC::Id
    Description: A virtual private cloud (VPC) that enables resources in public subnets to connect to the internet
Resources:
  ELBSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: ELB Security Group
      VpcId: !Ref VPC
      SecurityGroupIngress:
      - IpProtocol: tcp
        FromPort: 80
        ToPort: 80
        CidrIp: 0.0.0.0/0
  EC2SecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: EC2 Security Group
      VpcId: !Ref VPC
      SecurityGroupIngress:
      - IpProtocol: tcp
        FromPort: 80
        ToPort: 80
        SourceSecurityGroupId:
          Fn::GetAtt:
          - ELBSecurityGroup
          - GroupId
      - IpProtocol: tcp
        FromPort: 22
        ToPort: 22
        CidrIp: !Ref SSHLocation
  EC2TargetGroup:
    Type: AWS::ElasticLoadBalancingV2::TargetGroup
    Properties:
      HealthCheckIntervalSeconds: 30
      HealthCheckProtocol: HTTP
      HealthCheckTimeoutSeconds: 15
      HealthyThresholdCount: 5
      Matcher:
        HttpCode: '200'
      Name: EC2TargetGroup
      Port: 80
      Protocol: HTTP
      TargetGroupAttributes:
      - Key: deregistration_delay.timeout_seconds
        Value: '20'
      UnhealthyThresholdCount: 3
      VpcId: !Ref VPC
  ALBListener:
    Type: AWS::ElasticLoadBalancingV2::Listener
    Properties:
      DefaultActions:
        - Type: forward
          TargetGroupArn: !Ref EC2TargetGroup
      LoadBalancerArn: !Ref ApplicationLoadBalancer
      Port: 80
      Protocol: HTTP
  ApplicationLoadBalancer:
    Type: AWS::ElasticLoadBalancingV2::LoadBalancer
    Properties:
      Scheme: internet-facing
      Subnets: !Ref Subnets
      SecurityGroups:
        - !GetAtt ELBSecurityGroup.GroupId
  LaunchTemplate:
    Type: AWS::EC2::LaunchTemplate
    Properties: 
      LaunchTemplateName: !Sub ${AWS::StackName}-launch-template
      LaunchTemplateData:
        ImageId: !Ref LatestAmiId
        InstanceType: !Ref InstanceType
        KeyName: !Ref KeyName
        SecurityGroupIds: 
          - !Ref EC2SecurityGroup
        UserData:
          Fn::Base64: !Sub |
            #!/bin/bash
            yum update -y
            yum install -y httpd
            systemctl start httpd
            systemctl enable httpd
            echo "<h1>Hello World!</h1>" > /var/www/html/index.html
  NotificationTopic:
    Type: AWS::SNS::Topic
    Properties:
      Subscription:
        - Endpoint: !Ref OperatorEmail
          Protocol: email
  WebServerGroup:
    Type: AWS::AutoScaling::AutoScalingGroup
    Properties:
      LaunchTemplate:
        LaunchTemplateId: !Ref LaunchTemplate
        Version: !GetAtt LaunchTemplate.LatestVersionNumber
      MaxSize: '3'
      MinSize: '1'
      NotificationConfigurations:
        - TopicARN: !Ref NotificationTopic
          NotificationTypes: ['autoscaling:EC2_INSTANCE_LAUNCH', 'autoscaling:EC2_INSTANCE_LAUNCH_ERROR', 'autoscaling:EC2_INSTANCE_TERMINATE', 'autoscaling:EC2_INSTANCE_TERMINATE_ERROR']
      TargetGroupARNs:
        - !Ref EC2TargetGroup
      VPCZoneIdentifier: !Ref Subnets
```

**JSON**

```
{
  "AWSTemplateFormatVersion":"2010-09-09",
  "Parameters":{
    "InstanceType":{
      "Description":"The EC2 instance type",
      "Type":"String",
      "Default":"t3.micro",
      "AllowedValues":[
        "t3.micro",
        "t3.small",
        "t3.medium"
      ]
    },
    "KeyName":{
      "Description":"Name of an existing EC2 key pair to allow SSH access to the instances",
      "Type":"AWS::EC2::KeyPair::KeyName"
    },
    "LatestAmiId":{
      "Description":"The latest Amazon Linux 2 AMI from the Parameter Store",
      "Type":"AWS::SSM::Parameter::Value<AWS::EC2::Image::Id>",
      "Default":"/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2"
    },
    "OperatorEmail":{
      "Description":"The email address to notify when there are any scaling activities",
      "Type":"String"
    },
    "SSHLocation":{
      "Description":"The IP address range that can be used to SSH to the EC2 instances",
      "Type":"String",
      "MinLength":9,
      "MaxLength":18,
      "Default":"0.0.0.0/0",
      "ConstraintDescription":"Must be a valid IP CIDR range of the form x.x.x.x/x."
    },
    "Subnets":{
      "Type":"List<AWS::EC2::Subnet::Id>",
      "Description":"At least two public subnets in different Availability Zones in the selected VPC"
    },
    "VPC":{
      "Type":"AWS::EC2::VPC::Id",
      "Description":"A virtual private cloud (VPC) that enables resources in public subnets to connect to the internet"
    }
  },
  "Resources":{
    "ELBSecurityGroup":{
      "Type":"AWS::EC2::SecurityGroup",
      "Properties":{
        "GroupDescription":"ELB Security Group",
        "VpcId":{
          "Ref":"VPC"
        },
        "SecurityGroupIngress":[
          {
            "IpProtocol":"tcp",
            "FromPort":80,
            "ToPort":80,
            "CidrIp":"0.0.0.0/0"
          }
        ]
      }
    },
    "EC2SecurityGroup":{
      "Type":"AWS::EC2::SecurityGroup",
      "Properties":{
        "GroupDescription":"EC2 Security Group",
        "VpcId":{
          "Ref":"VPC"
        },
        "SecurityGroupIngress":[
          {
            "IpProtocol":"tcp",
            "FromPort":80,
            "ToPort":80,
            "SourceSecurityGroupId":{
              "Fn::GetAtt":[
                "ELBSecurityGroup",
                "GroupId"
              ]
            }
          },
          {
            "IpProtocol":"tcp",
            "FromPort":22,
            "ToPort":22,
            "CidrIp":{
              "Ref":"SSHLocation"
            }
          }
        ]
      }
    },
    "EC2TargetGroup":{
      "Type":"AWS::ElasticLoadBalancingV2::TargetGroup",
      "Properties":{
        "HealthCheckIntervalSeconds":30,
        "HealthCheckProtocol":"HTTP",
        "HealthCheckTimeoutSeconds":15,
        "HealthyThresholdCount":5,
        "Matcher":{
          "HttpCode":"200"
        },
        "Name":"EC2TargetGroup",
        "Port":80,
        "Protocol":"HTTP",
        "TargetGroupAttributes":[
          {
            "Key":"deregistration_delay.timeout_seconds",
            "Value":"20"
          }
        ],
        "UnhealthyThresholdCount":3,
        "VpcId":{
          "Ref":"VPC"
        }
      }
    },
    "ALBListener":{
      "Type":"AWS::ElasticLoadBalancingV2::Listener",
      "Properties":{
        "DefaultActions":[
          {
            "Type":"forward",
            "TargetGroupArn":{
              "Ref":"EC2TargetGroup"
            }
          }
        ],
        "LoadBalancerArn":{
          "Ref":"ApplicationLoadBalancer"
        },
        "Port":80,
        "Protocol":"HTTP"
      }
    },
    "ApplicationLoadBalancer":{
      "Type":"AWS::ElasticLoadBalancingV2::LoadBalancer",
      "Properties":{
        "Scheme":"internet-facing",
        "Subnets":{
          "Ref":"Subnets"
        },
        "SecurityGroups":[
          {
            "Fn::GetAtt":[
              "ELBSecurityGroup",
              "GroupId"
            ]
          }
        ]
      }
    },
    "LaunchTemplate":{
      "Type":"AWS::EC2::LaunchTemplate",
      "Properties":{
        "LaunchTemplateName":{
          "Fn::Sub":"${AWS::StackName}-launch-template"
        },
        "LaunchTemplateData":{
          "ImageId":{
            "Ref":"LatestAmiId"
          },
          "InstanceType":{
            "Ref":"InstanceType"
          },
          "KeyName":{
            "Ref":"KeyName"
          },
          "SecurityGroupIds":[
            {
              "Ref":"EC2SecurityGroup"
            }
          ],
          "UserData":{
            "Fn::Base64":{
              "Fn::Join":[
                "",
                [
                  "#!/bin/bash\n",
                  "yum update -y\n",
                  "yum install -y httpd\n",
                  "systemctl start httpd\n",
                  "systemctl enable httpd\n",
                  "echo \"<h1>Hello World!</h1>\" > /var/www/html/index.html"
                ]
              ]
            }
          }
        }
      }
    },
    "NotificationTopic":{
      "Type":"AWS::SNS::Topic",
      "Properties":{
        "Subscription":[
          {
            "Endpoint":{
              "Ref":"OperatorEmail"
            },
            "Protocol":"email"
          }
        ]
      }
    },
    "WebServerGroup":{
      "Type":"AWS::AutoScaling::AutoScalingGroup",
      "Properties":{
        "LaunchTemplate":{
          "LaunchTemplateId":{
            "Ref":"LaunchTemplate"
          },
          "Version":{
            "Fn::GetAtt":[
              "LaunchTemplate",
              "LatestVersionNumber"
            ]
          }
        },
        "MaxSize":"3",
        "MinSize":"1",
        "NotificationConfigurations":[
          {
            "TopicARN":{
              "Ref":"NotificationTopic"
            },
            "NotificationTypes":[
              "autoscaling:EC2_INSTANCE_LAUNCH",
              "autoscaling:EC2_INSTANCE_LAUNCH_ERROR",
              "autoscaling:EC2_INSTANCE_TERMINATE",
              "autoscaling:EC2_INSTANCE_TERMINATE_ERROR"
            ]
          }
        ],
        "TargetGroupARNs":[
          {
            "Ref":"EC2TargetGroup"
          }
        ],
        "VPCZoneIdentifier":{
          "Ref":"Subnets"
        }
      }
    }
  }
}
```

## Spiegazione passo per passo del modello
<a name="example-templates-autoscaling-description"></a>

La prima parte di questo modello specifica i `Parameters`. A ogni parametro deve essere assegnato un valore in fase di esecuzione per CloudFormation eseguire correttamente il provisioning dello stack. Le risorse specificate più avanti nel modello fanno riferimento a questi valori e utilizzano i dati.
+ `InstanceType`: il tipo di istanza EC2 fornito da Amazon EC2 Auto Scaling. Se non viene specificato, viene utilizzato il valore predefinito `t3.micro`.
+ `KeyName`: una coppia di chiavi EC2 esistente per consentire l'accesso SSH alle istanze.
+ `LatestAmiId`: l'Amazon Machine Image (AMI) per le istanze. Se non specificato, le tue istanze vengono avviate con un'AMI Amazon Linux 2, utilizzando un parametro AWS Systems Manager pubblico gestito da AWS. Per ulteriori informazioni, consulta [Ricerca dei parametri pubblici](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-store-finding-public-parameters.html) nella *Guida per l'utente di AWS Systems Manager *.
+ `OperatorEmail`: l'indirizzo e-mail a cui desideri inviare le notifiche sulle attività di dimensionamento.
+ `SSHLocation`: l'intervallo di indirizzi IP che può essere utilizzato per inviare SSH alle istanze.
+ `Subnets`: almeno due sottoreti pubbliche in diverse zone di disponibilità. 
+ `VPC`: un cloud privato virtuale (VPC) nel tuo account che consente alle risorse nelle sottoreti pubbliche di connettersi a Internet. 
**Nota**  
Puoi utilizzare il VPC e le sottoreti predefiniti per consentire alle istanze di accedere a Internet. In quest'ultimo caso, assicurati che il VPC abbia una sottorete mappata a ciascuna zona di disponibilità della Regione in cui stai lavorando. Per creare il load balancer, ti serviranno almeno due sottoreti pubbliche.

La parte successiva di questo modello specifica le `Resources`. Questa sezione specifica le risorse dello stack e le relative proprietà.

[https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html)risorsa `ELBSecurityGroup` 
+ `SecurityGroupIngress`contiene una regola di ingresso TCP che consente l'accesso da *tutti gli indirizzi IP* (» CidrIp ": «0.0.0.0/0") sulla porta 80.

[https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html)risorsa `EC2SecurityGroup` 
+ `SecurityGroupIngress` contiene due regole di ingresso: 1) una regola di ingresso TCP che consente l'accesso SSH (porta 22) dall'intervallo di indirizzi IP fornito per il parametro di input `SSHLocation` e 2) una regola di ingresso TCP che consente l'accesso dal sistema di bilanciamento del carico specificando il gruppo di sicurezza del sistema di bilanciamento del carico. La [GetAtt](resources-section-structure.md#resource-properties-getatt)funzione viene utilizzata per ottenere l'ID del gruppo di sicurezza con il nome logico`ELBSecurityGroup`.

[AWS::ElasticLoadBalancingV2::TargetGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-targetgroup.html)risorsa `EC2TargetGroup`
+ `Port`, `Protocol` e `HealthCheckProtocol` specificano la porta (80) e il protocollo (HTTP) dell'istanza EC2 verso cui `ApplicationLoadBalancer` indirizza il traffico e che Elastic Load Balancing utilizza per verificare l'integrità delle istanze EC2.
+ `HealthCheckIntervalSeconds` specifica che le istanze EC2 hanno un intervallo di 30 secondi tra un controllo dell'integrità e un altro. Per `HealthCheckTimeoutSeconds` si intende il periodo di tempo che Elastic Load Balancing attende per una risposta della destinazione del controllo dell'integrità (15 secondi in questo esempio). Al termine del periodo di timeout, Elastic Load Balancing contrassegna il controllo dell'integrità dell'istanza EC2 come non integra. Quando un'istanza EC2 non supera tre controlli di integrità consecutivi (`UnhealthyThresholdCount`), Elastic Load Balancing interrompe l'instradamento del traffico verso quell'istanza EC2 fino a quando quell'istanza non ha cinque controlli dell'integrità consecutivi (`HealthyThresholdCount`). A quel punto, Elastic Load Balancing considera l'istanza integra e ricomincia a indirizzare il traffico verso l'istanza.
+ `TargetGroupAttributes` aggiorna il valore del ritardo di annullamento della registrazione del gruppo di destinazione a 20 secondi. Per impostazione predefinita, Elastic Load Balancing attende 300 secondi prima di completare il processo di annullamento della registrazione.

[AWS::ElasticLoadBalancingV2::Listener](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-listener.html)risorsa `ALBListener`
+ `DefaultActions` specifica la porta su cui il sistema di bilanciamento del carico ascolta, il gruppo di destinazione a cui il sistema di bilanciamento del carico inoltra le richieste e il protocollo utilizzato per instradare le richieste.

[AWS::ElasticLoadBalancingV2::LoadBalancer](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-loadbalancer.html)risorsa `ApplicationLoadBalancer`
+ `Subnets` prende il valore del parametro di input `Subnets` come elenco di sottoreti pubbliche in cui verranno creati i nodi del sistema di bilanciamento del carico.
+ `SecurityGroup` ottiene l'ID del gruppo di sicurezza che funge da firewall virtuale per i nodi del sistema di bilanciamento del carico per controllare il traffico in entrata. La [GetAtt](resources-section-structure.md#resource-properties-getatt)funzione viene utilizzata per ottenere l'ID del gruppo di sicurezza con il nome logico`ELBSecurityGroup`.

[AWS::EC2::LaunchTemplate](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html)risorsa `LaunchTemplate`
+ `ImageId` prende il valore del parametro di input `LatestAmiId` come AMI da utilizzare.
+ `KeyName` prende il valore del parametro di input `KeyName` come la coppia di chiavi EC2 da usare.
+ `SecurityGroupIds` ottiene l'ID del gruppo di sicurezza con il nome logico `EC2SecurityGroup` che funge da firewall virtuale per le istanze EC2 per controllare il traffico in entrata.
+ `UserData` è uno script di configurazione che viene eseguito dopo che l'istanza è attiva e funzionante. In questo esempio, lo script installa Apache e crea un file index.html.

[AWS::SNS::Topic](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sns-topic.html)risorsa `NotificationTopic`
+ `Subscription` prende il valore del parametro di input `OperatorEmail` come indirizzo e-mail del destinatario delle notifiche in caso di attività di scalabilità. 

AWS::AutoScaling::AutoScalingRisorsa di [gruppo](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html) `WebServerGroup`
+ `MinSize` e `MaxSize` impostano il numero minimo e massimo di istanze EC2 nel gruppo con dimensionamento automatico.
+ `TargetGroupARNs` prende l'ARN del gruppo di destinazione con il nome logico `EC2TargetGroup`. Man mano che questo dimensionamento automatico si dimensiona, registra le istanze e ne annulla automaticamente la registrazione con questo gruppo di destinazione.
+ `VPCZoneIdentifier` prende il valore del parametro di input `Subnets` come elenco di sottoreti pubbliche in cui verranno create le istanze EC2.

## Fase 1: Avvio dello stack
<a name="example-templates-autoscaling-launch-stack"></a>

Prima di avviare lo stack, verifica di disporre delle autorizzazioni AWS Identity and Access Management (IAM) per utilizzare tutti i seguenti servizi: Amazon EC2, Amazon EC2 Auto Scaling, Elastic Load Balancing AWS Systems Manager, Amazon SNS e. CloudFormation

La procedura seguente prevede il caricamento del modello di stack di esempio da un file. Apri un editor di testo sul tuo computer locale e aggiungi uno dei modelli. Salva il file con il nome `sampleloadbalancedappstack.template`.

**Avvio del modello dello stack**

1. [Accedi e apri la console all'indirizzo /cloudformation. Console di gestione AWSCloudFormation https://console.aws.amazon.com](https://console.aws.amazon.com/cloudformation/)

1. Scegli **Crea stack**, **Con nuove risorse (standard)**.

1. In **Specifica modello**, seleziona **Carica un file di modello** e poi **Scegli file** per caricare il file `sampleloadbalancedappstack.template`. 

1. Scegli **Next (Successivo)**.

1. Nella pagina **Specifica i dettagli dello stack**, immetti il nome dello stack (ad esempio, **SampleLoadBalancedAppStack**).

1. **In **Parametri**, esamina i parametri per lo stack e fornisci i valori per tutti i parametri che non hanno valori predefiniti, tra cui **OperatorEmail**, **SSHLocation**KeyName****, **VPC** e sottoreti.**

1. Scegliere **Next (Successivo)** due volte.

1. Nella pagina **Rivedi**, verifica e conferma le impostazioni.

1. Seleziona **Invia**.

   **Puoi visualizzare lo stato dello stack nella CloudFormation console nella colonna Stato.** **Una volta CloudFormation creato con successo lo stack, ricevi lo stato CREATE\$1COMPLETE.**
**Nota**  
Dopo aver creato lo stack, perché l'indirizzo e-mail possa iniziare a ricevere notifiche devi confermare la sottoscrizione. Per ulteriori informazioni, consulta l'argomento relativo alla [ricezione di notifiche Amazon SNS quando il gruppo di dimensionamento automatico viene dimensionato](https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-sns-notifications.html) nella *Guida per l'utente di Amazon EC2 Auto Scaling*.

## Fase 2: Cancellazione delle risorse di esempio
<a name="example-templates-autoscaling-clean-up"></a>

Per assicurarti che non ti vengano addebitati costi per le risorse di esempio inutilizzate, elimina lo stack.

**Per eliminare lo stack**

1. Nella CloudFormation console, seleziona lo stack. **SampleLoadBalancedAppStack**

1. Scegli **Elimina**.

1. Nel messaggio di conferma, scegli **Elimina stack**.

   Lo stato delle **SampleLoadBalancedAppStack**modifiche a **DELETE\$1IN\$1PROGRESS**. Una volta CloudFormation completata l'eliminazione dello stack, lo rimuove dall'elenco.

Usa i modelli di esempio di questa procedura guidata per creare i tuoi modelli stack. Per ulteriori informazioni, consulta [Tutorial: Configurazione di un'applicazione con dimensionata e con bilanciamento del carico](https://docs.aws.amazon.com/autoscaling/ec2/userguide/tutorial-ec2-auto-scaling-load-balancer.html) nella *Guida per l'utente di Amazon EC2 Auto Scaling*.

# Peer con un VPC in un altro Account AWS
<a name="peer-with-vpc-in-another-account"></a>

È possibile effettuare il peering con un Virtual Private Cloud (VPC) in un altro utilizzando. Account AWS [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-vpcpeeringconnection.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-vpcpeeringconnection.html) In questo modo si crea una connessione di rete tra due di essi VPCs che consente di instradare il traffico tra di loro in modo che possano comunicare come se fossero all'interno della stessa rete. Una connessione peering VPC può facilitare l’accesso ai dati e il trasferimento dei dati.

Per stabilire una connessione peering VPC, devi autorizzarne due separate Account AWS all'interno di un unico stack. CloudFormation 

Per ulteriori informazioni sul peering di VPC e le sue limitazioni, consulta la [Guida al peering di Amazon VPC](https://docs.aws.amazon.com/vpc/latest/peering/). 

## Prerequisiti
<a name="peer-with-vpc-in-another-account-prerequisites"></a>

1. Per la connessione peering sono necessari un ID VPC peer, un Account AWS peer ID e [un ruolo di accesso tra account diversi](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_common-scenarios_aws-accounts.html). 
**Nota**  
Questa procedura guidata si riferisce a due account: un account che consente il peering tra più account (l’*account dell’accettante*) e un account che richiede la connessione in peering (l’*account del richiedente*).

1. Per accettare la connessione peering VPC, devi assumere il ruolo di accesso multi-account. La risorsa si comporta nello stesso modo di una risorsa di una connessione peering VPC nello stesso account. Per informazioni su come un amministratore IAM concede le autorizzazioni per assumere il ruolo di multi-account, consulta [Grant a user permissions to switch roles](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_permissions-to-switch.html) nella *Guida per l’utente di IAM*.

## Fase 1: creazione di un VPC e di un ruolo tra più account
<a name="step-1-create-vpc-and-cross-account-role"></a>

In questa fase vengono creati il VPC e il ruolo nell’*account dell’accettante*.

**Creazione di un VPC e di un ruolo di accesso multi-account**

1. [Accedi e apri la console all'indirizzo Console di gestione AWS /cloudformazione. CloudFormation https://console.aws.amazon.com](https://console.aws.amazon.com/cloudformation/)

1. Nella pagina **Stack** scegli **Crea stack** in alto a destra, quindi seleziona **Con nuove risorse (standard)**.

1. Per **Prerequisito: prepara modello**, scegli **Scegli un modello esistente**, quindi **Carica un file modello**, **Scegli file**.

1. Apri un editor di testo sul tuo computer locale e aggiungi uno dei modelli seguenti. Salva il file e torna alla console per selezionarlo come file modello.  
**Example JSON**  

   ```
   {
     "AWSTemplateFormatVersion": "2010-09-09",
     "Description": "Create a VPC and an assumable role for cross account VPC peering.",
     "Parameters": {
       "PeerRequesterAccountId": {
         "Type": "String"
       }
     },
     "Resources": {
       "vpc": {
         "Type": "AWS::EC2::VPC",
         "Properties": {
           "CidrBlock": "10.1.0.0/16",
           "EnableDnsSupport": false,
           "EnableDnsHostnames": false,
           "InstanceTenancy": "default"
         }
       },
       "peerRole": {
         "Type": "AWS::IAM::Role",
         "Properties": {
           "AssumeRolePolicyDocument": {
             "Statement": [
               {
                 "Principal": {
                   "AWS": {
                     "Ref": "PeerRequesterAccountId"
                   }
                 },
                 "Action": [
                   "sts:AssumeRole"
                 ],
                 "Effect": "Allow"
               }
             ]
           },
           "Path": "/",
           "Policies": [
             {
               "PolicyName": "root",
               "PolicyDocument": {
                 "Version": "2012-10-17",		 	 	 
                 "Statement": [
                   {
                     "Effect": "Allow",
                     "Action": "ec2:AcceptVpcPeeringConnection",
                     "Resource": "*"
                   }
                 ]
               }
             }
           ]
         }
       }
     },
     "Outputs": {
       "VPCId": {
         "Value": {
           "Ref": "vpc"
         }
       },
       "RoleARN": {
         "Value": {
           "Fn::GetAtt": [
             "peerRole",
             "Arn"
           ]
         }
       }
     }
   }
   ```  
**Example YAML**  

   ```
   AWSTemplateFormatVersion: 2010-09-09
   Description: Create a VPC and an assumable role for cross account VPC peering.
   Parameters:
     PeerRequesterAccountId:
       Type: String
   Resources:
     vpc:
       Type: AWS::EC2::VPC
       Properties:
         CidrBlock: 10.1.0.0/16
         EnableDnsSupport: false
         EnableDnsHostnames: false
         InstanceTenancy: default
     peerRole:
       Type: AWS::IAM::Role
       Properties:
         AssumeRolePolicyDocument:
           Statement:
             - Principal:
                 AWS: !Ref PeerRequesterAccountId
               Action:
                 - 'sts:AssumeRole'
               Effect: Allow
         Path: /
         Policies:
           - PolicyName: root
             PolicyDocument:
               Version: 2012-10-17 		 	 	 
               Statement:
                 - Effect: Allow
                   Action: 'ec2:AcceptVpcPeeringConnection'
                   Resource: '*'
   Outputs:
     VPCId:
       Value: !Ref vpc
     RoleARN:
       Value: !GetAtt 
         - peerRole
         - Arn
   ```

1. Scegli **Next (Successivo)**.

1. Assegna un nome allo stack (ad esempio,**VPC-owner**), quindi inserisci l' Account AWS ID dell'account *richiedente* nel campo. **PeerRequesterAccountId**

1. Accettare i valori predefiniti, quindi selezionare **Next (Avanti)**.

1. Scegli **Riconosco che CloudFormation potrebbe creare risorse IAM**, quindi scegli **Create** stack.

## Fase 2: creazione di un modello che include `AWS::EC2::VPCPeeringConnection`
<a name="step-2-create-template-for-vpc-peering-connection-owner"></a>

*Ora che hai creato il VPC e il ruolo interaccount, puoi effettuare il peer con il VPC utilizzandone un altro Account AWS (l'account richiedente).*

**Per creare un modello che includa la risorsa [AWS: :EC2:: Connection VPCPeering](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-vpcpeeringconnection.html)**

1. Torna alla home page della CloudFormation console.

1. Nella pagina **Stack** scegli **Crea stack** in alto a destra, quindi seleziona **Con nuove risorse (standard)**.

1. Per **Prerequisito: prepara modello**, scegli **Scegli un modello esistente**, quindi **Carica un file modello**, **Scegli file**.

1. Apri un editor di testo sul tuo computer locale e aggiungi uno dei modelli seguenti. Salva il file e torna alla console per selezionarlo come file modello.  
**Example JSON**  

   ```
   {
     "AWSTemplateFormatVersion": "2010-09-09",
     "Description": "Create a VPC and a VPC Peering connection using the PeerRole to accept.",
     "Parameters": {
       "PeerVPCAccountId": {
         "Type": "String"
       },
       "PeerVPCId": {
         "Type": "String"
       },
       "PeerRoleArn": {
         "Type": "String"
       }
     },
     "Resources": {
       "vpc": {
         "Type": "AWS::EC2::VPC",
         "Properties": {
           "CidrBlock": "10.2.0.0/16",
           "EnableDnsSupport": false,
           "EnableDnsHostnames": false,
           "InstanceTenancy": "default"
         }
       },
       "vpcPeeringConnection": {
         "Type": "AWS::EC2::VPCPeeringConnection",
         "Properties": {
           "VpcId": {
             "Ref": "vpc"
           },
           "PeerVpcId": {
             "Ref": "PeerVPCId"
           },
           "PeerOwnerId": {
             "Ref": "PeerVPCAccountId"
           },
           "PeerRoleArn": {
             "Ref": "PeerRoleArn"
           }
         }
       }
     },
     "Outputs": {
       "VPCId": {
         "Value": {
           "Ref": "vpc"
         }
       },
       "VPCPeeringConnectionId": {
         "Value": {
           "Ref": "vpcPeeringConnection"
         }
       }
     }
   }
   ```  
**Example YAML**  

   ```
   AWSTemplateFormatVersion: 2010-09-09
   Description: Create a VPC and a VPC Peering connection using the PeerRole to accept.
   Parameters:
     PeerVPCAccountId:
       Type: String
     PeerVPCId:
       Type: String
     PeerRoleArn:
       Type: String
   Resources:
     vpc:
       Type: AWS::EC2::VPC
       Properties:
         CidrBlock: 10.2.0.0/16
         EnableDnsSupport: false
         EnableDnsHostnames: false
         InstanceTenancy: default
     vpcPeeringConnection:
       Type: AWS::EC2::VPCPeeringConnection
       Properties:
         VpcId: !Ref vpc
         PeerVpcId: !Ref PeerVPCId
         PeerOwnerId: !Ref PeerVPCAccountId
         PeerRoleArn: !Ref PeerRoleArn
   Outputs:
     VPCId:
       Value: !Ref vpc
     VPCPeeringConnectionId:
       Value: !Ref vpcPeeringConnection
   ```

1. Scegli **Next (Successivo)**.

1. Assegnare un nome allo stack (ad esempio, **VPC-peering-connection**).

1. Accettare i valori predefiniti, quindi selezionare **Next (Avanti)**.

1. Scegli **Riconosco che CloudFormation potrebbe creare risorse IAM**, quindi scegli **Create stack**.

## Creazione di un modello con una policy altamente restrittiva
<a name="create-template-with-highly-restrictive-policy"></a>

Potresti creare una policy altamente restrittiva per collegare in peering il VPC con un altro Account AWS. 

L’esempio seguente mostra come modificare il modello del proprietario della connessione in peering del VPC (l’*account dell’accettante* creato nella fase 1 precedente) in modo che sia di livello più restrittivo.

**Example JSON**  

```
{
  "AWSTemplateFormatVersion":"2010-09-09",
  "Description":"Create a VPC and an assumable role for cross account VPC peering.",
  "Parameters":{
    "PeerRequesterAccountId":{
      "Type":"String"
    }
  },
  "Resources":{
    "peerRole":{
      "Type":"AWS::IAM::Role",
      "Properties":{
        "AssumeRolePolicyDocument":{
          "Statement":[
            {
              "Action":[
                "sts:AssumeRole"
              ],
              "Effect":"Allow",
              "Principal":{
                "AWS":{
                  "Ref":"PeerRequesterAccountId"
                }
              }
            }
          ]
        },
        "Path":"/",
        "Policies":[
          {
            "PolicyDocument":{
              "Statement":[
                {
                  "Action":"ec2:acceptVpcPeeringConnection",
                  "Effect":"Allow",
                  "Resource":{
                    "Fn::Sub":"arn:aws:ec2:${AWS::Region}:${AWS::AccountId}:vpc/${vpc}"
                  }
                },
                {
                  "Action":"ec2:acceptVpcPeeringConnection",
                  "Condition":{
                    "StringEquals":{
                      "ec2:AccepterVpc":{
                        "Fn::Sub":"arn:aws:ec2:${AWS::Region}:${AWS::AccountId}:vpc/${vpc}"
                      }
                    }
                  },
                  "Effect":"Allow",
                  "Resource":{
                    "Fn::Sub":"arn:aws:ec2:${AWS::Region}:${AWS::AccountId}:vpc-peering-connection/*"
                  }
                }
              ],
              "Version":"2012-10-17" 		 	 	 
            },
            "PolicyName":"root"
          }
        ]
      }
    },
    "vpc":{
      "Type":"AWS::EC2::VPC",
      "Properties":{
        "CidrBlock":"10.1.0.0/16",
        "EnableDnsHostnames":false,
        "EnableDnsSupport":false,
        "InstanceTenancy":"default"
      }
    }
  },
  "Outputs":{
    "RoleARN":{
      "Value":{
        "Fn::GetAtt":[
          "peerRole",
          "Arn"
        ]
      }
    },
    "VPCId":{
      "Value":{
        "Ref":"vpc"
      }
    }
  }
}
```

**Example YAML**  

```
AWSTemplateFormatVersion: 2010-09-09
Description: Create a VPC and an assumable role for cross account VPC peering.
Parameters:
  PeerRequesterAccountId:
    Type: String
Resources:
  peerRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Statement:
          - Action:
              - 'sts:AssumeRole'
            Effect: Allow
            Principal:
              AWS:
                Ref: PeerRequesterAccountId
      Path: /
      Policies:
        - PolicyDocument:
            Statement:
              - Action: 'ec2:acceptVpcPeeringConnection'
                Effect: Allow
                Resource:
                  'Fn::Sub': 'arn:aws:ec2:${AWS::Region}:${AWS::AccountId}:vpc/${vpc}'
              - Action: 'ec2:acceptVpcPeeringConnection'
                Condition:
                  StringEquals:
                    'ec2:AccepterVpc':
                      'Fn::Sub': 'arn:aws:ec2:${AWS::Region}:${AWS::AccountId}:vpc/${vpc}'
                Effect: Allow
                Resource:
                  'Fn::Sub': >-
                    arn:aws:ec2:${AWS::Region}:${AWS::AccountId}:vpc-peering-connection/*
            Version: 2012-10-17 		 	 	 
          PolicyName: root
  vpc:
    Type: AWS::EC2::VPC
    Properties:
      CidrBlock: 10.1.0.0/16
      EnableDnsHostnames: false
      EnableDnsSupport: false
      InstanceTenancy: default
Outputs:
  RoleARN:
    Value:
      'Fn::GetAtt':
        - peerRole
        - Arn
  VPCId:
    Value:
      Ref: vpc
```

Per accedere al VPC, è possibile utilizzare lo stesso modello del richiedente della fase 2 precedente.

Per ulteriori informazioni, consulta [Identity and access management for VPC peering](https://docs.aws.amazon.com/vpc/latest/peering/security-iam.html) nella *Guida al peering di Amazon VPC*.

# Esegui le blue/green implementazioni ECS tramite l'utilizzo CodeDeploy CloudFormation
<a name="blue-green"></a>

Per aggiornare un'applicazione in esecuzione su Amazon Elastic Container Service (Amazon ECS), puoi utilizzare CodeDeploy una strategia di distribuzione blu/verde. Questa strategia aiuta a ridurre al minimo le interruzioni causate dalla modifica delle versioni delle applicazioni. 

*In una blue/green distribuzione, crei un nuovo ambiente applicativo (denominato *verde*) accanto all'ambiente live corrente (denominato blu).* Ciò ti consente di monitorare e testare l’ambiente verde prima di indirizzare il traffico live dall’ambiente blu a quello verde. Dopo che l’ambiente verde ha fornito traffico live, puoi terminare l’ambiente blu in modo sicuro.

Per eseguire distribuzioni CodeDeploy blu/verdi su ECS utilizzando CloudFormation, includi le seguenti informazioni nel modello di stack:
+ Una sezione `Hooks` che descrive un hook `AWS::CodeDeploy::BlueGreen`.
+  Una sezione `Transform` che specifica la trasformazione `AWS::CodeDeployBlueGreen`.

I seguenti argomenti ti guidano nella configurazione di un CloudFormation modello per una distribuzione blu/verde su ECS.

**Topics**
+ [Informazioni sulle blue/green distribuzioni](about-blue-green-deployments.md)
+ [Considerazioni sulla gestione delle distribuzioni ECS utilizzando blue/green CloudFormation](blue-green-considerations.md)
+ [Sintassi di hook `AWS::CodeDeploy::BlueGreen`](blue-green-hook-syntax.md)
+ [Esempio di modello di implementazione blu/verde](blue-green-template-example.md)

# Informazioni sulle blue/green distribuzioni
<a name="about-blue-green-deployments"></a>

Questo argomento fornisce una panoramica di come funziona l'esecuzione blue/green delle distribuzioni con. CloudFormation Spiega inoltre come preparare il CloudFormation modello per le distribuzioni blu/verdi.

**Topics**
+ [Come funziona](#blue-green-how-it-works)
+ [Aggiornamenti delle risorse che avviano le implementazioni verdi](#blue-green-resources)
+ [Preparazione del modello](#blue-green-setup)
+ [Modellazione della distribuzione blue/green](#blue-green-required)
+ [Set di modifiche](#blue-green-changesets)
+ [Monitoraggio degli eventi dello stack](#blue-green-events)
+ [autorizzazioni IAM](#blue-green-iam)

## Come funziona
<a name="blue-green-how-it-works"></a>

Quando si utilizza CloudFormation per eseguire blue/green distribuzioni ECS tramite CodeDeploy, si inizia con la creazione di un modello di stack che definisce le risorse per gli ambienti applicativi blu e verdi, inclusa la specificazione delle impostazioni di routing e stabilizzazione del traffico da utilizzare. Successivamente, crea uno stack da quel modello. Questo genera l'applicazione blu (corrente). CloudFormation crea le risorse blu solo durante la creazione dello stack. Le risorse per una distribuzione verde non vengono create finché non sono necessarie.

Quindi, se in un futuro aggiornamento dello stack aggiorni la definizione dell'attività o le risorse del set di attività nell'applicazione blu, CloudFormation effettua le seguenti operazioni:
+ Genera tutte le risorse necessarie per l’ambiente delle applicazioni verdi
+ Sposta il traffico in base ai parametri di instradamento del traffico specificati
+ Elimina le risorse blu

Se si verifica un errore in qualsiasi momento prima che la distribuzione verde abbia esito positivo e sia finalizzata, CloudFormation ripristina lo stack allo stato precedente all'avvio dell'intera distribuzione verde.

## Aggiornamenti delle risorse che avviano le implementazioni verdi
<a name="blue-green-resources"></a>

Quando si esegue un aggiornamento dello stack che aggiorna determinate proprietà di risorse ECS specifiche, CloudFormation avvia un processo di distribuzione verde. Le risorse che avviano questo processo sono:
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskdefinition.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskdefinition.html)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskset.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskset.html) 

Tuttavia, se gli aggiornamenti a queste risorse non comportano modifiche alle proprietà che richiedono la sostituzione, non verrà avviata un’implementazione verde. Per ulteriori informazioni, consulta [Comprendere l’aggiornamento dei comportamenti delle risorse stack](using-cfn-updating-stacks-update-behaviors.md).

È importante notare che non puoi unire gli aggiornamenti delle risorse di cui sopra con gli aggiornamenti di altre risorse nella stessa operazione di aggiornamento dello stack. Se devi aggiornare sia le risorse elencate che altre risorse all’interno dello stesso stack, hai due opzioni:
+ Eseguire due operazioni di aggiornamento separate: una che include solo gli aggiornamenti delle risorse precedenti e un aggiornamento separato dello stack che include le modifiche apportate a qualsiasi altra risorsa.
+ Rimuovi le sezioni `Transform` e `Hooks` dal modello e quindi esegui l’aggiornamento dello stack. In questo caso, CloudFormation non eseguirà una distribuzione ecologica.

## Preparazione del modello per eseguire le distribuzioni ECS blue/green
<a name="blue-green-setup"></a>

Per abilitare le blue/green distribuzioni sul tuo stack, includi le seguenti sezioni nel tuo modello di stack prima di eseguire un aggiornamento dello stack.
+ Aggiungi un riferimento alla trasformazione `AWS::CodeDeployBlueGreen` al tuo modello:

  ```
  "Transform": [
    "AWS::CodeDeployBlueGreen"
  ],
  ```
+ Aggiungi una sezione `Hooks` che richiami l’hook `AWS::CodeDeploy::BlueGreen` e specifica le proprietà per la distribuzione. Per ulteriori informazioni, consulta [Sintassi di hook `AWS::CodeDeploy::BlueGreen`](blue-green-hook-syntax.md).
+ Nella sezione `Resources`, definisci le risorse blu e verdi per la distribuzione.

È possibile aggiungere queste sezioni quando si crea il modello per la prima volta o prima di creare lo stack medesimo; oppure è possibile aggiungerle a un modello esistente prima di eseguire un aggiornamento dello stack. Se specifichi la blue/green distribuzione per un nuovo stack, crea CloudFormation solo le risorse blu durante la creazione dello stack. Le risorse per la distribuzione verde non vengono create finché non sono necessarie durante un aggiornamento dello stack.

## Modellazione della distribuzione utilizzando le risorse blue/green CloudFormation
<a name="blue-green-required"></a>

Per eseguire una distribuzione CodeDeploy blu/verde su ECS, il CloudFormation modello deve includere le risorse che modellano la distribuzione, come un servizio Amazon ECS e un sistema di bilanciamento del carico. Per ulteriori dettagli su cosa rappresentano queste risorse, consulta [Prima di iniziare una distribuzione Amazon ECS](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-steps-ecs.html#deployment-steps-prerequisites-ecs) nella *Guida per l’utente di AWS CodeDeploy *.


| Requisito | Risorsa | Obbligatorio/facoltativo | Avvia la distribuzione in caso di sostituzione? blue/green  | 
| --- | --- | --- | --- | 
| Cluster Amazon ECS | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-cluster.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-cluster.html) | Opzionale. Puoi utilizzare il cluster predefinito. | No | 
| Servizio Amazon ECS | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-service.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-service.html) | Obbligatorio. | No | 
| Applicazione o Network Load Balancer | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-ecs-service-loadbalancer.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-ecs-service-loadbalancer.html) | Obbligatorio. | No | 
| Listener di produzione | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-listener.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-listener.html) | Obbligatorio. | No | 
| Listener di prova  | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-listener.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-listener.html) | Opzionale. | No | 
| Due gruppi target | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-targetgroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-targetgroup.html) | Obbligatorio. | No | 
| Definizione dell’attività di Amazon ECS  | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskdefinition.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskdefinition.html) | Obbligatorio. | Sì | 
| Container per l’applicazione Amazon ECS | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-ecs-taskdefinition-containerdefinition.html#cfn-ecs-taskdefinition-containerdefinition-name](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-ecs-taskdefinition-containerdefinition.html#cfn-ecs-taskdefinition-containerdefinition-name) | Obbligatorio. | No | 
| Porta per il set di attività di sostituzione | [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-ecs-taskdefinition-portmapping.html#cfn-ecs-taskdefinition-portmapping-containerport](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-ecs-taskdefinition-portmapping.html#cfn-ecs-taskdefinition-portmapping-containerport) | Obbligatorio. | No | 

## Set di modifiche
<a name="blue-green-changesets"></a>

Consigliamo vivamente di creare un set di modifiche prima di eseguire un aggiornamento dello stack che inizierà una distribuzione verde. Ciò ti consente di visualizzare le modifiche effettive che verranno apportate allo stack prima di procedere con l’aggiornamento. Tieni presente che le modifiche alle risorse potrebbero non essere elencate nell’ordine in cui verranno eseguite durante l’aggiornamento dello stack. Per ulteriori informazioni, consulta [Aggiorna CloudFormation gli stack utilizzando i set di modifiche](using-cfn-updating-stacks-changesets.md).

## Monitoraggio degli eventi dello stack
<a name="blue-green-events"></a>

È possibile visualizzare gli eventi stack generati in ogni fase dell’implementazione ECS nella scheda **Events** (Eventi) della pagina **Stack** oppure utilizzando AWS CLI. Per ulteriori informazioni, consulta [Monitoraggio dell’avanzamento dello stack](monitor-stack-progress.md).

## Autorizzazioni IAM per le distribuzioni blue/green
<a name="blue-green-iam"></a>

 CloudFormation Per eseguire correttamente le distribuzioni blu-verdi, devi disporre delle seguenti autorizzazioni: CodeDeploy 
+ `codedeploy:Get*`
+ `codedeploy:CreateCloudFormationDeployment`

Per ulteriori informazioni, consulta [Operazioni, risorse e chiavi di condizione per CodeDeploy](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awscodedeploy.html) nella *Documentiazione di riferimento per l'autorizzazione al servizio*.

# Considerazioni sulla gestione delle distribuzioni ECS utilizzando blue/green CloudFormation
<a name="blue-green-considerations"></a>

Il processo di utilizzo CloudFormation per eseguire le blue/green distribuzioni ECS CodeDeploy è diverso da quello di una distribuzione ECS standard che utilizza just. CodeDeploy *Per una comprensione dettagliata di queste differenze, consulta [Differenze tra le blue/green distribuzioni di Amazon ECS tramite CodeDeploy e CloudFormation](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployments-create-ecs-cfn.html#differences-ecs-bg-cfn) nella Guida per l'AWS CodeDeploy utente.* 

Quando si gestisce la blue/green distribuzione utilizzando CloudFormation, ci sono alcune limitazioni e considerazioni da tenere a mente:
+ Solo gli aggiornamenti di determinate risorse inizieranno un’implementazione verde. Per ulteriori informazioni, consulta [Aggiornamenti delle risorse che avviano le implementazioni verdi](about-blue-green-deployments.md#blue-green-resources).
+ Non puoi includere gli aggiornamenti delle risorse che iniziano implementazioni verdi e aggiornamenti ad altre risorse nello stesso aggiornamento dello stack. Per ulteriori informazioni, consulta [Aggiornamenti delle risorse che avviano le implementazioni verdi](about-blue-green-deployments.md#blue-green-resources).
+ Puoi specificare solo una singola applicazione ECS come target di distribuzione.
+ I parametri i cui valori sono offuscati non CloudFormation possono essere aggiornati CodeDeploy durante una distribuzione ecologica e causeranno un errore e un errore di aggiornamento dello stack. Ciò include:
  + Parametri definiti con l’attributo `NoEcho`.
  + Parametri che utilizzano riferimenti dinamici per recuperare i loro valori da servizi esterni. Per ulteriori informazioni sui riferimenti dinamici, consulta [Ottenimento di valori archiviati in altri servizi utilizzando riferimenti dinamici](dynamic-references.md).
+ Per annullare una distribuzione ecologica ancora in corso, annulla lo stack update in CloudFormation, not o ECS. CodeDeploy Per ulteriori informazioni, consulta [Annulla l’aggiornamento di uno stack](using-cfn-stack-update-cancel.md). Dopo che un aggiornamento è terminato, non è possibile annullarlo. Tuttavia, puoi aggiornare uno stack di nuovo con le impostazioni precedenti.
+ Le seguenti CloudFormation funzionalità non sono attualmente supportate per i modelli che definiscono le distribuzioni ECS blue/green :
  + Dichiarazione degli [output](outputs-section-structure.md) o utilizzo di [Fn:: ImportValue](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-importvalue.html) per importare valori da altri stack.
  + Importare risorse Per ulteriori informazioni sull’importazione delle risorse, consulta [Importa AWS risorse in una CloudFormation pila](import-resources.md).
  + Utilizzare l’hook `AWS::CodeDeploy::BlueGreen` in un modello che include risorse di stack nidificate. Per ulteriori informazioni sugli stack nidificati, consulta [Dividi un modello in pezzi riutilizzabili usando stack nidificati](using-cfn-nested-stacks.md).
  + Utilizzo dell’hook `AWS::CodeDeploy::BlueGreen` in uno stack nidificato.

# Sintassi di hook `AWS::CodeDeploy::BlueGreen`
<a name="blue-green-hook-syntax"></a>

La sintassi seguente descrive la struttura di un `AWS::CodeDeploy::BlueGreen` hook per le distribuzioni ECS. blue/green 

## Sintassi
<a name="cfn-blue-green-hook-syntax"></a>

```
"Hooks": {
  "Logical ID": {
    "Type": "AWS::CodeDeploy::BlueGreen",
    "Properties": {
      "TrafficRoutingConfig": {
        "Type": "Traffic routing type",
        "TimeBasedCanary": {
          "StepPercentage": Integer,
          "BakeTimeMins": Integer
        },
        "TimeBasedLinear": {
          "StepPercentage": Integer,
          "BakeTimeMins": Integer
        }
      },
      "AdditionalOptions": {"TerminationWaitTimeInMinutes": Integer},
      "LifecycleEventHooks": {
        "BeforeInstall": "FunctionName",
        "AfterInstall": "FunctionName",
        "AfterAllowTestTraffic": "FunctionName",
        "BeforeAllowTraffic": "FunctionName",
        "AfterAllowTraffic": "FunctionName"
      },
      "ServiceRole": "CodeDeployServiceRoleName",
      "Applications": [
        {
          "Target": {
            "Type": "AWS::ECS::Service",
            "LogicalID": "Logical ID of AWS::ECS::Service"
          },
          "ECSAttributes": {
            "TaskDefinitions": [
              "Logical ID of AWS::ECS::TaskDefinition (Blue)",
              "Logical ID of AWS::ECS::TaskDefinition (Green)"
            ],
            "TaskSets": [
              "Logical ID of AWS::ECS::TaskSet (Blue)",
              "Logical ID of AWS::ECS::TaskSet (Green)"
            ],
            "TrafficRouting": {
              "ProdTrafficRoute": {
                "Type": "AWS::ElasticLoadBalancingV2::Listener",
                "LogicalID": "Logical ID of AWS::ElasticLoadBalancingV2::Listener (Production)"
              },
              "TestTrafficRoute": {
                "Type": "AWS::ElasticLoadBalancingV2::Listener",
                "LogicalID": "Logical ID of AWS::ElasticLoadBalancingV2::Listener (Test)"
              },
              "TargetGroups": [
                "Logical ID of AWS::ElasticLoadBalancingV2::TargetGroup (Blue)",
                "Logical ID of AWS::ElasticLoadBalancingV2::TargetGroup (Green)"
              ]
            }
          }
        }
      ]
    }
  }
}
```

## Properties
<a name="cfn-blue-green-hook-properties"></a>

ID logico (chiamato anche *nome logico)*  
L’ID logico di un hook dichiarato nella sezione `Hooks` del modello. L’ID logico deve essere un valore alfanumerico (A-Z, a-z, 0-9) univoco all’interno del modello.  
*Obbligatorio:* sì    
`Type`  
Il tipo di hook. `AWS::CodeDeploy::BlueGreen`  
*Obbligatorio:* sì  
`Properties`  
Proprietà dell’hook.  
*Obbligatorio:* sì    
`TrafficRoutingConfig`  
Impostazioni di configurazione dell’instradamento del traffico.  
*Obbligatorio:* no  
La configurazione predefinita è lo spostamento del traffico canary basato sul tempo, con una percentuale di fasi del 15% e un tempo di cottura di cinque minuti.    
`Type`  
Tipo di spostamento del traffico utilizzato dalla configurazione di distribuzione.  
Valori validi: \$1 \$1 AllAtOnce TimeBasedCanary TimeBasedLinear  
*Obbligatorio:* sì    
`TimeBasedCanary`  
Specifica una configurazione che sposta il traffico da una versione della distribuzione a un’altra con due incrementi.  
*Obbligatorio*: condizionale: se si specifica `TimeBasedCanary` come tipo di instradamento del traffico, è necessario includere il parametro `TimeBasedCanary`.    
`StepPercentage`  
Percentuale di traffico da spostare nel primo incremento di una distribuzione `TimeBasedCanary`. La percentuale di fasi deve essere pari o superiore al 14%.  
*Obbligatorio:* no  
`BakeTimeMins`  
Numero di minuti tra il primo e il secondo spostamento di traffico di una distribuzione `TimeBasedCanary`.  
*Obbligatorio:* no  
`TimeBasedLinear`  
Specifica una configurazione che sposta il traffico da una versione della distribuzione a un’altra con incrementi uguali, con un numero uguale di minuti tra ciascun incremento.  
*Obbligatorio*: condizionale: se si specifica `TimeBasedLinear` come tipo di instradamento del traffico, è necessario includere il parametro `TimeBasedLinear`.    
`StepPercentage`  
Percentuale di traffico spostata all’inizio di ogni incremento di una distribuzione `TimeBasedLinear`. La percentuale di fasi deve essere pari o superiore al 14%.  
*Obbligatorio:* no  
`BakeTimeMins`  
Numero di minuti tra ogni spostamento incrementale del traffico di una distribuzione `TimeBasedLinear`.  
*Obbligatorio:* no  
`AdditionalOptions`  
Opzioni aggiuntive per la blue/green distribuzione.  
*Obbligatorio:* no    
`TerminationWaitTimeInMinutes`  
Specifica il tempo di attesa, in minuti, prima di terminare le risorse blu.  
*Obbligatorio:* no  
`LifecycleEventHooks`  
Usa gli hook degli eventi del ciclo di vita per specificare una funzione Lambda che CodeDeploy può chiamare per convalidare una distribuzione. Puoi utilizzare la stessa funzione o un’altra per gli eventi del ciclo di vita di distribuzione. Dopo il completamento dei test di convalida, la funzione `AfterAllowTraffic` Lambda CodeDeploy richiama e fornisce il risultato `Succeeded` di o. `Failed` *Per ulteriori informazioni, consulta la [sezione AppSpec 'hook'](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file-structure-hooks.html) nella Guida per l'AWS CodeDeploy utente.*  
*Obbligatorio:* no    
`BeforeInstall`  
Funzione utilizzata per eseguire attività prima della creazione del set di attività di sostituzione.  
*Obbligatorio:* no  
`AfterInstall`  
Funzione utilizzata per eseguire attività dopo che il set di attività di sostituzione è stato creato e a esso è stato associato uno dei gruppi target.  
*Obbligatorio:* no  
`AfterAllowTestTraffic`  
Funzione utilizzata per eseguire attività dopo che il listener di test ha indirizzato il traffico verso il set di attività di sostituzione.  
*Obbligatorio:* no  
`BeforeAllowTraffic`  
Funzione utilizzata per eseguire attività dopo che il secondo gruppo target è stato associato al set di attività di sostituzione, ma prima che il traffico venga reindirizzato al set di attività di sostituzione.  
*Obbligatorio:* no  
`AfterAllowTraffic`  
Funzione utilizzata per eseguire attività dopo che il secondo gruppo target ha indirizzato il traffico verso il set di attività di sostituzione.  
*Obbligatorio:* no  
`ServiceRole`  
Il ruolo di esecuzione CloudFormation da utilizzare per eseguire le distribuzioni blu-verdi. Per un elenco delle autorizzazioni necessarie, consulta [Autorizzazioni IAM per le distribuzioni blue/green](about-blue-green-deployments.md#blue-green-iam).  
*Obbligatorio:* no  
`Applications`  
Specifica le proprietà dell’applicazione Amazon ECS.  
*Obbligatorio:* sì    
`Target`  
  
*Obbligatorio:* sì    
`Type`  
Il tipo di risorsa.  
*Obbligatorio:* sì  
`LogicalID`  
L’ID logico della risorsa.  
*Obbligatorio:* sì  
`ECSAttributes`  
Le risorse che rappresentano i vari requisiti della distribuzione dell’applicazione Amazon ECS.  
*Obbligatorio:* sì    
`TaskDefinitions`  
ID logico della risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskdefinition.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskdefinition.html) per eseguire il container Docker che contiene l’applicazione Amazon ECS.  
*Obbligatorio:* sì  
`TaskSets`  
La logica IDs delle [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskset.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-taskset.html)risorse da utilizzare come set di attività per l'applicazione.  
*Obbligatorio:* sì  
`TrafficRouting`  
Specifica le risorse utilizzate per l’instradamento del traffico.  
*Obbligatorio:* sì    
`ProdTrafficRoute`  
Il listener che viene utilizzato dal load balancer per indirizzare il traffico verso i gruppi target.  
*Obbligatorio:* sì    
`Type`  
Il tipo di risorsa. `AWS::ElasticLoadBalancingV2::Listener`  
*Obbligatorio:* sì  
`LogicalID`  
L’ID logico della risorsa.  
*Obbligatorio:* sì  
`TestTrafficRoute`  
Il listener che viene utilizzato dal load balancer per indirizzare il traffico verso i gruppi target.  
*Obbligatorio:* sì    
`Type`  
Il tipo di risorsa. `AWS::ElasticLoadBalancingV2::Listener`  
*Obbligatorio:* sì  
`LogicalID`  
L’ID logico della risorsa.  
*Obbligatorio:* no  
`TargetGroups`  
ID logico delle risorse da utilizzare come target per instradare il traffico al target registrato.  
*Obbligatorio:* sì

# Esempio di modello di implementazione blu/verde
<a name="blue-green-template-example"></a>

Il modello di esempio seguente configura una distribuzione CodeDeploy blu/verde su ECS, con un avanzamento del routing del traffico del 15% per fase e un periodo di stabilizzazione di 5 minuti tra ogni passaggio. 

La creazione di uno stack con il modello prevede il provisioning della configurazione iniziale dell’implementazione. Se in seguito sono state apportate modifiche alle proprietà della `BlueTaskSet` risorsa che richiedono la sostituzione di tale risorsa, CloudFormation verrà avviata una distribuzione ecologica come parte dell'aggiornamento dello stack.

## JSON
<a name="blue-green-template-example.json"></a>

```
{
  "AWSTemplateFormatVersion":"2010-09-09",
  "Parameters":{
    "Vpc":{ "Type":"AWS::EC2::VPC::Id" },
    "Subnet1":{ "Type":"AWS::EC2::Subnet::Id" },
    "Subnet2":{ "Type":"AWS::EC2::Subnet::Id" }
  },
  "Transform":[ "AWS::CodeDeployBlueGreen" ],
  "Hooks":{
    "CodeDeployBlueGreenHook":{
      "Type":"AWS::CodeDeploy::BlueGreen",
      "Properties":{
        "TrafficRoutingConfig":{
          "Type":"TimeBasedCanary",
          "TimeBasedCanary":{
            "StepPercentage":15,
            "BakeTimeMins":5
          }
        },
        "Applications":[
          {
            "Target":{
              "Type":"AWS::ECS::Service",
              "LogicalID":"ECSDemoService"
            },
            "ECSAttributes":{
              "TaskDefinitions":[ "BlueTaskDefinition","GreenTaskDefinition" ],
              "TaskSets":[ "BlueTaskSet","GreenTaskSet" ],
              "TrafficRouting":{
                "ProdTrafficRoute":{
                  "Type":"AWS::ElasticLoadBalancingV2::Listener",
                  "LogicalID":"ALBListenerProdTraffic"
                },
                "TargetGroups":[ "ALBTargetGroupBlue","ALBTargetGroupGreen" ]
              }
            }
          }
        ]
      }
    }
  },
  "Resources":{
    "ExampleSecurityGroup":{
      "Type":"AWS::EC2::SecurityGroup",
      "Properties":{
        "GroupDescription":"Security group for ec2 access",
        "VpcId":{ "Ref":"Vpc" },
        "SecurityGroupIngress":[
          {
            "IpProtocol":"tcp",
            "FromPort":80,
            "ToPort":80,
            "CidrIp":"0.0.0.0/0"
          },
          {
            "IpProtocol":"tcp",
            "FromPort":8080,
            "ToPort":8080,
            "CidrIp":"0.0.0.0/0"
          },
          {
            "IpProtocol":"tcp",
            "FromPort":22,
            "ToPort":22,
            "CidrIp":"0.0.0.0/0"
          }
        ]
      }
    },
    "ALBTargetGroupBlue":{
      "Type":"AWS::ElasticLoadBalancingV2::TargetGroup",
      "Properties":{
        "HealthCheckIntervalSeconds":5,
        "HealthCheckPath":"/",
        "HealthCheckPort":"80",
        "HealthCheckProtocol":"HTTP",
        "HealthCheckTimeoutSeconds":2,
        "HealthyThresholdCount":2,
        "Matcher":{ "HttpCode":"200" },
        "Port":80,
        "Protocol":"HTTP",
        "Tags":[{ "Key":"Group","Value":"Example" }],
        "TargetType":"ip",
        "UnhealthyThresholdCount":4,
        "VpcId":{ "Ref":"Vpc" }
      }
    },
    "ALBTargetGroupGreen":{
      "Type":"AWS::ElasticLoadBalancingV2::TargetGroup",
      "Properties":{
        "HealthCheckIntervalSeconds":5,
        "HealthCheckPath":"/",
        "HealthCheckPort":"80",
        "HealthCheckProtocol":"HTTP",
        "HealthCheckTimeoutSeconds":2,
        "HealthyThresholdCount":2,
        "Matcher":{ "HttpCode":"200" },
        "Port":80,
        "Protocol":"HTTP",
        "Tags":[{ "Key":"Group","Value":"Example" }],
        "TargetType":"ip",
        "UnhealthyThresholdCount":4,
        "VpcId":{ "Ref":"Vpc" }
      }
    },
    "ExampleALB":{
      "Type":"AWS::ElasticLoadBalancingV2::LoadBalancer",
      "Properties":{
        "Scheme":"internet-facing",
        "SecurityGroups":[{ "Ref":"ExampleSecurityGroup" }],
        "Subnets":[{ "Ref":"Subnet1" },{ "Ref":"Subnet2" }],
        "Tags":[{ "Key":"Group","Value":"Example" }],
        "Type":"application",
        "IpAddressType":"ipv4"
      }
    },
    "ALBListenerProdTraffic":{
      "Type":"AWS::ElasticLoadBalancingV2::Listener",
      "Properties":{
        "DefaultActions":[
          {
            "Type":"forward",
            "ForwardConfig":{
              "TargetGroups":[
                {
                  "TargetGroupArn":{ "Ref":"ALBTargetGroupBlue" },
                  "Weight":1
                }
              ]
            }
          }
        ],
        "LoadBalancerArn":{ "Ref":"ExampleALB" },
        "Port":80,
        "Protocol":"HTTP"
      }
    },
    "ALBListenerProdRule":{
      "Type":"AWS::ElasticLoadBalancingV2::ListenerRule",
      "Properties":{
        "Actions":[
          {
            "Type":"forward",
            "ForwardConfig":{
              "TargetGroups":[
                {
                  "TargetGroupArn":{ "Ref":"ALBTargetGroupBlue" },
                  "Weight":1
                }
              ]
            }
          }
        ],
        "Conditions":[
          {
            "Field":"http-header",
            "HttpHeaderConfig":{
              "HttpHeaderName":"User-Agent",
              "Values":[ "Mozilla" ]
            }
          }
        ],
        "ListenerArn":{ "Ref":"ALBListenerProdTraffic" },
        "Priority":1
      }
    },
    "ECSTaskExecutionRole":{
      "Type":"AWS::IAM::Role",
      "Properties":{
        "AssumeRolePolicyDocument":{
          "Version": "2012-10-17",		 	 	 
          "Statement":[
            {
              "Sid":"",
              "Effect":"Allow",
              "Principal":{
                "Service":"ecs-tasks.amazonaws.com"
              },
              "Action":"sts:AssumeRole"
            }
          ]
        },
        "ManagedPolicyArns":[ "arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy" ]
      }
    },
    "BlueTaskDefinition":{
      "Type":"AWS::ECS::TaskDefinition",
      "Properties":{
        "ExecutionRoleArn":{
          "Fn::GetAtt":[ "ECSTaskExecutionRole","Arn" ]
        },
        "ContainerDefinitions":[
          {
            "Name":"DemoApp",
            "Image":"nginxdemos/hello:latest",
            "Essential":true,
            "PortMappings":[
              {
                "HostPort":80,
                "Protocol":"tcp",
                "ContainerPort":80
              }
            ]
          }
        ],
        "RequiresCompatibilities":[ "FARGATE" ],
        "NetworkMode":"awsvpc",
        "Cpu":"256",
        "Memory":"512",
        "Family":"ecs-demo"
      }
    },
    "ECSDemoCluster":{
      "Type":"AWS::ECS::Cluster",
      "Properties":{}
    },
    "ECSDemoService":{
      "Type":"AWS::ECS::Service",
      "Properties":{
        "Cluster":{ "Ref":"ECSDemoCluster" },
        "DesiredCount":1,
        "DeploymentController":{ "Type":"EXTERNAL" }
      }
    },
    "BlueTaskSet":{
      "Type":"AWS::ECS::TaskSet",
      "Properties":{
        "Cluster":{ "Ref":"ECSDemoCluster" },
        "LaunchType":"FARGATE",
        "NetworkConfiguration":{
          "AwsVpcConfiguration":{
            "AssignPublicIp":"ENABLED",
            "SecurityGroups":[{ "Ref":"ExampleSecurityGroup" }],
            "Subnets":[{ "Ref":"Subnet1" },{ "Ref":"Subnet2" }]
          }
        },
        "PlatformVersion":"1.4.0",
        "Scale":{
          "Unit":"PERCENT",
          "Value":100
        },
        "Service":{ "Ref":"ECSDemoService"},
        "TaskDefinition":{ "Ref":"BlueTaskDefinition" },
        "LoadBalancers":[
          {
            "ContainerName":"DemoApp",
            "ContainerPort":80,
            "TargetGroupArn":{ "Ref":"ALBTargetGroupBlue" }
          }
        ]
      }
    },
    "PrimaryTaskSet":{
      "Type":"AWS::ECS::PrimaryTaskSet",
      "Properties":{
        "Cluster":{ "Ref":"ECSDemoCluster" },
        "Service":{ "Ref":"ECSDemoService" },
        "TaskSetId":{ "Fn::GetAtt":[ "BlueTaskSet","Id" ]
        }
      }
    }
  }
}
```

## YAML
<a name="blue-green-template-example.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
Parameters:
  Vpc:
    Type: AWS::EC2::VPC::Id
  Subnet1:
    Type: AWS::EC2::Subnet::Id
  Subnet2:
    Type: AWS::EC2::Subnet::Id
Transform:
  - 'AWS::CodeDeployBlueGreen'
Hooks:
  CodeDeployBlueGreenHook:
    Type: AWS::CodeDeploy::BlueGreen
    Properties:
      TrafficRoutingConfig:
        Type: TimeBasedCanary
        TimeBasedCanary:
          StepPercentage: 15
          BakeTimeMins: 5
      Applications:
        - Target:
            Type: AWS::ECS::Service
            LogicalID: ECSDemoService
          ECSAttributes:
            TaskDefinitions:
              - BlueTaskDefinition
              - GreenTaskDefinition
            TaskSets:
              - BlueTaskSet
              - GreenTaskSet
            TrafficRouting:
              ProdTrafficRoute:
                Type: AWS::ElasticLoadBalancingV2::Listener
                LogicalID: ALBListenerProdTraffic
              TargetGroups:
                - ALBTargetGroupBlue
                - ALBTargetGroupGreen
Resources:
  ExampleSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Security group for ec2 access
      VpcId: !Ref Vpc
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: 80
          ToPort: 80
          CidrIp: 0.0.0.0/0
        - IpProtocol: tcp
          FromPort: 8080
          ToPort: 8080
          CidrIp: 0.0.0.0/0
        - IpProtocol: tcp
          FromPort: 22
          ToPort: 22
          CidrIp: 0.0.0.0/0
  ALBTargetGroupBlue:
    Type: AWS::ElasticLoadBalancingV2::TargetGroup
    Properties:
      HealthCheckIntervalSeconds: 5
      HealthCheckPath: /
      HealthCheckPort: '80'
      HealthCheckProtocol: HTTP
      HealthCheckTimeoutSeconds: 2
      HealthyThresholdCount: 2
      Matcher:
        HttpCode: '200'
      Port: 80
      Protocol: HTTP
      Tags:
        - Key: Group
          Value: Example
      TargetType: ip
      UnhealthyThresholdCount: 4
      VpcId: !Ref Vpc
  ALBTargetGroupGreen:
    Type: AWS::ElasticLoadBalancingV2::TargetGroup
    Properties:
      HealthCheckIntervalSeconds: 5
      HealthCheckPath: /
      HealthCheckPort: '80'
      HealthCheckProtocol: HTTP
      HealthCheckTimeoutSeconds: 2
      HealthyThresholdCount: 2
      Matcher:
        HttpCode: '200'
      Port: 80
      Protocol: HTTP
      Tags:
        - Key: Group
          Value: Example
      TargetType: ip
      UnhealthyThresholdCount: 4
      VpcId: !Ref Vpc
  ExampleALB:
    Type: AWS::ElasticLoadBalancingV2::LoadBalancer
    Properties:
      Scheme: internet-facing
      SecurityGroups:
        - !Ref ExampleSecurityGroup
      Subnets:
        - !Ref Subnet1
        - !Ref Subnet2
      Tags:
        - Key: Group
          Value: Example
      Type: application
      IpAddressType: ipv4
  ALBListenerProdTraffic:
    Type: AWS::ElasticLoadBalancingV2::Listener
    Properties:
      DefaultActions:
        - Type: forward
          ForwardConfig:
            TargetGroups:
              - TargetGroupArn: !Ref ALBTargetGroupBlue
                Weight: 1
      LoadBalancerArn: !Ref ExampleALB
      Port: 80
      Protocol: HTTP
  ALBListenerProdRule:
    Type: AWS::ElasticLoadBalancingV2::ListenerRule
    Properties:
      Actions:
        - Type: forward
          ForwardConfig:
            TargetGroups:
              - TargetGroupArn: !Ref ALBTargetGroupBlue
                Weight: 1
      Conditions:
        - Field: http-header
          HttpHeaderConfig:
            HttpHeaderName: User-Agent
            Values:
              - Mozilla
      ListenerArn: !Ref ALBListenerProdTraffic
      Priority: 1
  ECSTaskExecutionRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: 2012-10-17
        Statement:
          - Sid: ''
            Effect: Allow
            Principal:
              Service: ecs-tasks.amazonaws.com
            Action: 'sts:AssumeRole'
      ManagedPolicyArns:
        - 'arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy'
  BlueTaskDefinition:
    Type: AWS::ECS::TaskDefinition
    Properties:
      ExecutionRoleArn: !GetAtt 
        - ECSTaskExecutionRole
        - Arn
      ContainerDefinitions:
        - Name: DemoApp
          Image: 'nginxdemos/hello:latest'
          Essential: true
          PortMappings:
            - HostPort: 80
              Protocol: tcp
              ContainerPort: 80
      RequiresCompatibilities:
        - FARGATE
      NetworkMode: awsvpc
      Cpu: '256'
      Memory: '512'
      Family: ecs-demo
  ECSDemoCluster:
    Type: AWS::ECS::Cluster
    Properties: {}
  ECSDemoService:
    Type: AWS::ECS::Service
    Properties:
      Cluster: !Ref ECSDemoCluster
      DesiredCount: 1
      DeploymentController:
        Type: EXTERNAL
  BlueTaskSet:
    Type: AWS::ECS::TaskSet
    Properties:
      Cluster: !Ref ECSDemoCluster
      LaunchType: FARGATE
      NetworkConfiguration:
        AwsVpcConfiguration:
          AssignPublicIp: ENABLED
          SecurityGroups:
            - !Ref ExampleSecurityGroup
          Subnets:
            - !Ref Subnet1
            - !Ref Subnet2
      PlatformVersion: 1.4.0
      Scale:
        Unit: PERCENT
        Value: 100
      Service: !Ref ECSDemoService
      TaskDefinition: !Ref BlueTaskDefinition
      LoadBalancers:
        - ContainerName: DemoApp
          ContainerPort: 80
          TargetGroupArn: !Ref ALBTargetGroupBlue
  PrimaryTaskSet:
    Type: AWS::ECS::PrimaryTaskSet
    Properties:
      Cluster: !Ref ECSDemoCluster
      Service: !Ref ECSDemoService
      TaskSetId: !GetAtt 
        - BlueTaskSet
        - Id
```

# CloudFormation frammenti di modello
<a name="template-snippets"></a>

Questa sezione fornisce una serie di scenari di esempio che ti aiutano a capire come dichiarare varie parti del modello CloudFormation . Puoi anche utilizzare i frammenti come punto di partenza per le sezioni dei tuoi modelli personalizzati.

**Topics**
+ [Frammenti di modello generale](quickref-general.md)
+ [frammenti di CloudFormation modello con ridimensionamento automatico](quickref-autoscaling.md)
+ [AWS Frammenti di modello della Billing Console](quickref-billingconductor.md)
+ [CloudFormation frammenti di modello](quickref-cloudformation.md)
+ [Frammenti CloudFront di modello Amazon](quickref-cloudfront.md)
+ [Frammenti CloudWatch di modello Amazon](quickref-cloudwatch.md)
+ [Frammenti di modello Amazon CloudWatch Logs](quickref-cloudwatchlogs.md)
+ [Frammenti di modello Amazon DynamoDB](quickref-dynamodb.md)
+ [Frammenti EC2 CloudFormation di modello Amazon](quickref-ec2.md)
+ [Modelli di esempio di Amazon Elastic Container Service](quickref-ecs.md)
+ [Modello di esempio Amazon Elastic File System](quickref-efs.md)
+ [Frammenti di modello Elastic Beanstalk](quickref-elasticbeanstalk.md)
+ [Frammenti di modello Elastic Load Balancing](quickref-elb.md)
+ [AWS Identity and Access Management frammenti di modello](quickref-iam.md)
+ [AWS Lambda modello](quickref-lambda.md)
+ [Frammenti di modello Amazon Redshift](quickref-redshift.md)
+ [Frammenti di modello Amazon RDS](quickref-rds.md)
+ [Frammenti di modello Route 53](quickref-route53.md)
+ [Frammenti di modello Amazon S3](quickref-s3.md)
+ [Frammenti di modello Amazon SNS](quickref-sns.md)
+ [Frammenti di modello Amazon SQS](scenario-sqs-queue.md)
+ [Frammenti di modello Amazon Timestream](scenario-timestream-queue.md)

# Frammenti di modello generale
<a name="quickref-general"></a>

Gli esempi seguenti mostrano diverse funzionalità dei CloudFormation modelli che non sono specifiche di un AWS servizio.

**Topics**
+ [Proprietà UserData codificata Base64](#scenario-userdata-base64)
+ [Proprietà UserData codificata Base64 con AccessKey e SecretKey](#scenario-userdata-base64-with-keys)
+ [Sezione Parameters con un parametro di stringa letterale](#scenario-one-string-parameter)
+ [Sezione Parameters con parametro di stringa con vincolo di espressione regolare](#scenario-constraint-string-parameter)
+ [Sezione Parameters con parametri numerici con vincoli MinValue e MaxValue](#scenario-one-number-min-parameter)
+ [Parameterssezione con parametro numerico con AllowedValues vincolo](#scenario-one-number-parameter)
+ [Sezione Parameters con un parametro letterale CommaDelimitedList](#scenario-one-list-parameter)
+ [Sezione Parameters con valore di parametro basato su uno pseudo parametro](#scenario-one-pseudo-parameter)
+ [Sezione Mapping con tre mappature](#scenario-mapping-with-four-maps)
+ [Description basata sulla stringa letterale](#scenario-description-from-literal-string)
+ [Sezione Outputs con un output di stringa letterale](#scenario-output-with-literal-string)
+ [Sezione Outputs con un output di riferimento della risorsa e un output di pseudo riferimento](#scenario-output-with-ref-and-pseudo-ref)
+ [Sezione Outputs con un output basato su una funzione, una stringa letterale, un riferimento e uno pseudo parametro](#scenario-output-with-complex-spec)
+ [Versione del modello](#scenario-format-version)
+ [ProprietàAWS Tags](#scenario-format-aws-tag)

## Proprietà UserData codificata Base64
<a name="scenario-userdata-base64"></a>

Questo esempio illustra l’assemblaggio di una proprietà `UserData` utilizzando le funzioni `Fn::Base64` e `Fn::Join`. I riferimenti `MyValue` e `MyName` sono i parametri che devono essere definiti nella sezione `Parameters` del modello. La stringa letterale `Hello World` è solo un altro valore che questo esempio trasferisce come parte di `UserData`.

### JSON
<a name="quickref-general-example-1.json"></a>

```
1. "UserData" : {
2.     "Fn::Base64" : {
3.         "Fn::Join" : [ ",", [
4.             { "Ref" : "MyValue" },
5.             { "Ref" : "MyName" },
6.             "Hello World" ] ]
7.     }
8. }
```

### YAML
<a name="quickref-general-example-1.yaml"></a>

```
1. UserData:
2.   Fn::Base64: !Sub |
3.      Ref: MyValue
4.      Ref: MyName
5.      Hello World
```

## Proprietà UserData codificata Base64 con AccessKey e SecretKey
<a name="scenario-userdata-base64-with-keys"></a>

Questo esempio illustra l’assemblaggio di una proprietà `UserData` utilizzando le funzioni `Fn::Base64` e `Fn::Join`. Include le informazioni `AccessKey` e `SecretKey`. I riferimenti `AccessKey` e `SecretKey` sono i parametri che devono essere definiti nella sezione Parametri del modello.

### JSON
<a name="quickref-general-example-2.json"></a>

```
1. "UserData" : {
2.     "Fn::Base64" : {
3.         "Fn::Join" : [ "", [
4.             "ACCESS_KEY=", { "Ref" : "AccessKey" },
5.             "SECRET_KEY=", { "Ref" : "SecretKey" } ]
6.         ]
7.     }
8. }
```

### YAML
<a name="quickref-general-example-2.yaml"></a>

```
1. UserData:
2.   Fn::Base64: !Sub |
3.      ACCESS_KEY=${AccessKey}
4.      SECRET_KEY=${SecretKey}
```

## Sezione Parameters con un parametro di stringa letterale
<a name="scenario-one-string-parameter"></a>

Il seguente esempio illustra una dichiarazione della sezione parametri valida in cui viene dichiarato un singolo tipo di parametro `String`.

### JSON
<a name="quickref-general-example-3.json"></a>

```
1. "Parameters" : {
2.     "UserName" : {
3.         "Type" : "String",
4.         "Default" : "nonadmin",
5.         "Description" : "Assume a vanilla user if no command-line spec provided"
6.     }
7. }
```

### YAML
<a name="quickref-general-example-3.yaml"></a>

```
1. Parameters:
2.   UserName:
3.     Type: String
4.     Default: nonadmin
5.     Description: Assume a vanilla user if no command-line spec provided
```

## Sezione Parameters con parametro di stringa con vincolo di espressione regolare
<a name="scenario-constraint-string-parameter"></a>

Il seguente esempio illustra una dichiarazione della sezione parametri valida in cui viene dichiarato un singolo tipo di parametro `String`. Il parametro `AdminUserAccount` ha un valore predefinito di `admin`. Il valore di parametro deve avere una lunghezza minima di 1 e una massima di 16 e contiene caratteri alfabetici e numeri, ma deve iniziare con un carattere alfabetico.

### JSON
<a name="quickref-general-example-4.json"></a>

```
 1. "Parameters" : {
 2.     "AdminUserAccount": {
 3.       "Default": "admin",
 4.       "NoEcho": "true",
 5.       "Description" : "The admin account user name",
 6.       "Type": "String",
 7.       "MinLength": "1",
 8.       "MaxLength": "16",
 9.       "AllowedPattern" : "[a-zA-Z][a-zA-Z0-9]*"
10.     }
11. }
```

### YAML
<a name="quickref-general-example-4.yaml"></a>

```
1. Parameters:
2.   AdminUserAccount:
3.     Default: admin
4.     NoEcho: true
5.     Description: The admin account user name
6.     Type: String
7.     MinLength: 1
8.     MaxLength: 16
9.     AllowedPattern: '[a-zA-Z][a-zA-Z0-9]*'
```

## Sezione Parameters con parametri numerici con vincoli MinValue e MaxValue
<a name="scenario-one-number-min-parameter"></a>

Il seguente esempio illustra una dichiarazione della sezione parametri valida in cui viene dichiarato un singolo tipo di parametro `Number`. Il parametro `WebServerPort` ha un valore predefinito di 80 e un valore minimo di 1 e un valore massimo di 65535.

### JSON
<a name="quickref-general-example-5.json"></a>

```
1. "Parameters" : {
2.     "WebServerPort": {
3.       "Default": "80",
4.       "Description" : "TCP/IP port for the web server",
5.       "Type": "Number",
6.       "MinValue": "1",
7.       "MaxValue": "65535"
8.     }
9. }
```

### YAML
<a name="quickref-general-example-5.yaml"></a>

```
1. Parameters:
2.   WebServerPort:
3.     Default: 80
4.     Description: TCP/IP port for the web server
5.     Type: Number
6.     MinValue: 1
7.     MaxValue: 65535
```

## Parameterssezione con parametro numerico con AllowedValues vincolo
<a name="scenario-one-number-parameter"></a>

Il seguente esempio illustra una dichiarazione della sezione parametri valida in cui viene dichiarato un singolo tipo di parametro `Number`. Il parametro `WebServerPort` ha un valore predefinito di 80 e consente soltanto i valori di 80 e 8888.

### JSON
<a name="quickref-general-example-6.json"></a>

```
1. "Parameters" : {
2.     "WebServerPortLimited": {
3.       "Default": "80",
4.       "Description" : "TCP/IP port for the web server",
5.       "Type": "Number",
6.       "AllowedValues" : ["80", "8888"]
7.     }
8. }
```

### YAML
<a name="quickref-general-example-6.yaml"></a>

```
1. Parameters:
2.   WebServerPortLimited:
3.     Default: 80
4.     Description: TCP/IP port for the web server
5.     Type: Number
6.     AllowedValues:
7.     - 80
8.     - 8888
```

## Sezione Parameters con un parametro letterale CommaDelimitedList
<a name="scenario-one-list-parameter"></a>

Il seguente esempio illustra una dichiarazione della sezione `Parameters` valida in cui viene dichiarato un singolo tipo di parametro `CommaDelimitedList`. La proprietà `NoEcho` è impostata su `TRUE`, che maschererà il suo valore con asterischi (\$1\$1\$1\$1\$1) nell’output **describe-stacks**, ad eccezione delle informazioni memorizzate nelle posizioni specificate di seguito.

**Importante**  
L’utilizzo dell’attributo `NoEcho` non maschera le informazioni memorizzate nei seguenti elementi:  
La sezione dei `Metadata` modelli. CloudFormation non trasforma, modifica o oscura le informazioni incluse nella `Metadata` sezione. Per ulteriori informazioni, vedere [Metadati](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/metadata-section-structure.html).
Sezione dei modelli `Outputs`. Per ulteriori informazioni, consulta [Output](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/outputs-section-structure.html).
Attributo `Metadata` di una definizione di risorsa. Per ulteriori informazioni, consulta [Attributo `Metadata`](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-metadata.html).
Si consiglia vivamente di non utilizzare questi meccanismi per includere informazioni sensibili, come password o segreti.

**Importante**  
Anziché incorporare informazioni riservate direttamente nei CloudFormation modelli, consigliamo di utilizzare parametri dinamici nel modello di pila per fare riferimento a informazioni sensibili archiviate e gestite all'esterno CloudFormation, ad esempio nel AWS Systems Manager Parameter Store o. Gestione dei segreti AWS  
Per ulteriori informazioni, consulta la best practice [Non incorporare le credenziali nei modelli](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/security-best-practices.html#creds).

### JSON
<a name="quickref-general-example-7.json"></a>

```
1. "Parameters" : {
2.     "UserRoles" : {
3.         "Type" : "CommaDelimitedList",
4.         "Default" : "guest,newhire",
5.         "NoEcho" : "TRUE"
6.     }
7. }
```

### YAML
<a name="quickref-general-example-7.yaml"></a>

```
1. Parameters:
2.   UserRoles:
3.     Type: CommaDelimitedList
4.     Default: "guest,newhire"
5.     NoEcho: true
```

## Sezione Parameters con valore di parametro basato su uno pseudo parametro
<a name="scenario-one-pseudo-parameter"></a>

L’esempio seguente mostra i comandi dei dati utente EC2 che utilizzano gli pseudo parametri `AWS::StackName` e `AWS::Region`. Per ulteriori informazioni sugli pseudoparametri, consulta [Ottieni AWS valori usando pseudo parametri](pseudo-parameter-reference.md).

### JSON
<a name="quickref-general-example-10.json"></a>

```
 1.           "UserData"       : { "Fn::Base64" : { "Fn::Join" : ["", [
 2.              "#!/bin/bash -xe\n",
 3.              "yum install -y aws-cfn-bootstrap\n",
 4. 
 5.              "/opt/aws/bin/cfn-init -v ",
 6.              "         --stack ", { "Ref" : "AWS::StackName" },
 7.              "         --resource LaunchConfig ",
 8.              "         --region ", { "Ref" : "AWS::Region" }, "\n",
 9. 
10.              "/opt/aws/bin/cfn-signal -e $? ",
11.              "         --stack ", { "Ref" : "AWS::StackName" },
12.              "         --resource WebServerGroup ",
13.              "         --region ", { "Ref" : "AWS::Region" }, "\n"
14.         ]]}}
15.       }
```

### YAML
<a name="quickref-general-example-10.yaml"></a>

```
1. UserData:
2.   Fn::Base64: !Sub |
3.      #!/bin/bash -xe
4.      yum update -y aws-cfn-bootstrap
5.      /opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource LaunchConfig --region ${AWS::Region}
6.      /opt/aws/bin/cfn-signal -e $? --stack ${AWS::StackName} --resource WebServerGroup --region ${AWS::Region}
```

## Sezione Mapping con tre mappature
<a name="scenario-mapping-with-four-maps"></a>

L’esempio seguente mostra una dichiarazione di sezione di `Mapping` valida che contiene tre mappature. La mappa, quando abbinata a una chiave di mappatura `Stop`, `SlowDown` oppure `Go`, fornisce i valori RGB assegnati all’attributo corrispondente `RGBColor`.

### JSON
<a name="quickref-general-example-11.json"></a>

```
 1. "Mappings" : {
 2.     "LightColor" : {
 3.         "Stop" : {
 4.             "Description" : "red",
 5.             "RGBColor" : "RED 255 GREEN 0 BLUE 0"
 6.         },
 7.         "SlowDown" : {
 8.             "Description" : "yellow",
 9.             "RGBColor" : "RED 255 GREEN 255 BLUE 0"
10.         },
11.         "Go" : {
12.             "Description" : "green",
13.             "RGBColor" : "RED 0 GREEN 128 BLUE 0"
14.         }
15.     }
16. }
```

### YAML
<a name="quickref-general-example-11.yaml"></a>

```
 1. Mappings:
 2.   LightColor:
 3.     Stop:
 4.       Description: red
 5.       RGBColor: "RED 255 GREEN 0 BLUE 0"
 6.     SlowDown:
 7.       Description: yellow
 8.       RGBColor: "RED 255 GREEN 255 BLUE 0"
 9.     Go:
10.       Description: green
11.       RGBColor: "RED 0 GREEN 128 BLUE 0"
```

## Description basata sulla stringa letterale
<a name="scenario-description-from-literal-string"></a>

L’esempio seguente mostra una dichiarazione della sezione `Description` valida in cui il valore si basa su una stringa letterale. Questo frammento può essere per modelli, parametri, risorse, proprietà o output.

### JSON
<a name="quickref-general-example-8.json"></a>

```
1. "Description" : "Replace this value"
```

### YAML
<a name="quickref-general-example-8.yaml"></a>

```
1. Description: "Replace this value"
```

## Sezione Outputs con un output di stringa letterale
<a name="scenario-output-with-literal-string"></a>

Questo esempio illustra un’assegnazione di output basata su una stringa letterale.

### JSON
<a name="quickref-general-example-12.json"></a>

```
1. "Outputs" : {
2.     "MyPhone" : {
3.         "Value" : "Please call 555-5555",
4.         "Description" : "A random message for aws cloudformation describe-stacks"
5.     }
6. }
```

### YAML
<a name="quickref-general-example-12.yaml"></a>

```
1. Outputs:
2.   MyPhone:
3.     Value: Please call 555-5555
4.     Description: A random message for aws cloudformation describe-stacks
```

## Sezione Outputs con un output di riferimento della risorsa e un output di pseudo riferimento
<a name="scenario-output-with-ref-and-pseudo-ref"></a>

Questo esempio illustra una sezione `Outputs` con due assegnazioni di output. Una si basa su una risorsa e l’altra si basa su uno pseudoriferimento.

### JSON
<a name="quickref-general-example-13.json"></a>

```
1. "Outputs" : {
2.    "SNSTopic" : { "Value" : { "Ref" : "MyNotificationTopic" } },
3.    "StackName" : { "Value" : { "Ref" : "AWS::StackName" } }
4. }
```

### YAML
<a name="quickref-general-example-13.yaml"></a>

```
1. Outputs:
2.   SNSTopic:
3.     Value: !Ref MyNotificationTopic
4.   StackName:
5.     Value: !Ref AWS::StackName
```

## Sezione Outputs con un output basato su una funzione, una stringa letterale, un riferimento e uno pseudo parametro
<a name="scenario-output-with-complex-spec"></a>

Questo esempio illustra una sezione output con un’assegnazione di output. La funzione Join viene utilizzata per concatenare il valore, utilizzando un segno di percentuale come delimitatore.

### JSON
<a name="quickref-general-example-14.json"></a>

```
1. "Outputs" : {
2.     "MyOutput" : {
3.         "Value" : { "Fn::Join" :
4.             [ "%", [ "A-string", {"Ref" : "AWS::StackName" } ] ]
5.         }
6.     }
7. }
```

### YAML
<a name="quickref-general-example-14.yaml"></a>

```
1. Outputs:
2.   MyOutput:
3.     Value: !Join [ %, [ 'A-string', !Ref 'AWS::StackName' ]]
```

## Versione del modello
<a name="scenario-format-version"></a>

Il seguente frammento illustra una dichiarazione di sezione della `AWSTemplateFormatVersion` valida.

### JSON
<a name="quickref-general-example-9.json"></a>

```
1. "AWSTemplateFormatVersion" : "2010-09-09"
```

### YAML
<a name="quickref-general-example-9.yaml"></a>

```
1. AWSTemplateFormatVersion: '2010-09-09'
```

## ProprietàAWS Tags
<a name="scenario-format-aws-tag"></a>

Questo esempio mostra una AWS `Tags` proprietà. Devi specificare questa proprietà all’interno della sezione proprietà di una risorsa. Quando la risorsa viene creata, verrà contrassegnata con i tag dichiarati.

### JSON
<a name="quickref-general-example-15.json"></a>

```
 1. "Tags" : [
 2.       {
 3.         "Key" : "keyname1",
 4.         "Value" : "value1"
 5.       },
 6.       {
 7.         "Key" : "keyname2",
 8.         "Value" : "value2"
 9.       }
10.     ]
```

### YAML
<a name="quickref-general-example-15.yaml"></a>

```
1. Tags: 
2.   - 
3.     Key: "keyname1"
4.     Value: "value1"
5.   - 
6.     Key: "keyname2"
7.     Value: "value2"
```

# frammenti di CloudFormation modello con ridimensionamento automatico
<a name="quickref-autoscaling"></a>

Con Amazon EC2 Auto Scaling, puoi scalare automaticamente EC2 le istanze Amazon, con politiche di scalabilità o con scalabilità programmata. I gruppi Auto Scaling sono raccolte di EC2 istanze Amazon che abilitano funzionalità di scalabilità automatica e gestione del parco veicoli, come politiche di scalabilità, azioni pianificate, controlli dello stato, ganci del ciclo di vita e bilanciamento del carico. 

Application Auto Scaling fornisce il ridimensionamento automatico di diverse risorse oltre Amazon EC2, con politiche di scalabilità o con scalabilità programmata.

Puoi creare e configurare gruppi di Auto Scaling, policy di scaling, azioni pianificate e altre risorse di auto scaling come parte della tua infrastruttura utilizzando modelli. CloudFormation I modelli semplificano la gestione e l’automazione dell’implementazione delle risorse di dimensionamento automatico in modo ripetibile e ottimizzato. 

I seguenti frammenti di modello di esempio descrivono CloudFormation risorse o componenti per Amazon Auto EC2 Scaling e Application Auto Scaling. Questi frammenti sono progettati per essere integrati in un modello e non sono destinati a essere eseguiti in modo indipendente.

**Topics**
+ [Configurazione delle risorse Amazon EC2 Auto Scaling](quickref-ec2-auto-scaling.md)
+ [Configurazione di risorse Application Auto Scaling](quickref-application-auto-scaling.md)

# Configura le risorse di Amazon EC2 Auto Scaling con CloudFormation
<a name="quickref-ec2-auto-scaling"></a>

Negli esempi seguenti vengono illustrati frammenti diversi da includere nei modelli da utilizzare con Amazon EC2 Auto Scaling.

**Topics**
+ [Creazione di un gruppo Auto Scaling con una singola istanza](#scenario-single-instance-as-group)
+ [Creazione di un gruppo Auto Scaling con un bilanciatore del carico allegato](#scenario-as-group)
+ [Creazione di un gruppo Auto Scaling con notifiche](#scenario-as-notification)
+ [Creazione di un gruppo Auto Scaling usando una `CreationPolicy` e una `UpdatePolicy`](#scenario-as-updatepolicy)
+ [Creazione di una policy di dimensionamento per fasi](#scenario-step-scaling-policy)
+ [Esempi di gruppi di istanze miste](#scenario-mixed-instances-group-template-examples)
+ [Esempi di configurazione di avvio](#scenario-launch-config-template-examples)

## Creazione di un gruppo Auto Scaling con una singola istanza
<a name="scenario-single-instance-as-group"></a>

Questo esempio mostra una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html) con una singola istanza per aiutarti a iniziare. La proprietà `VPCZoneIdentifier` del gruppo Auto Scaling specifica un elenco di sottoreti esistenti in diverse zone di disponibilità. Devi specificare la sottorete applicabile IDs dal tuo account prima di creare lo stack. La proprietà `LaunchTemplate` fa riferimento a una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html) con il nome logico `myLaunchTemplate` definito altrove nel modello.

**Nota**  
Per altri esempi di modelli di avvio, consulta [Crea modelli di lancio con CloudFormation](quickref-ec2-launch-templates.md) nella sezione relativa ai frammenti Amazon EC2 e la sezione [Esempi](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html#aws-resource-ec2-launchtemplate--examples) nella risorsa `AWS::EC2::LaunchTemplate`.

### JSON
<a name="quickref-autoscaling-example-1.json"></a>

```
 1. "myASG" : {
 2.    "Type" : "AWS::AutoScaling::AutoScalingGroup",
 3.    "Properties" : {
 4.       "VPCZoneIdentifier" : [ "subnetIdAz1", "subnetIdAz2", "subnetIdAz3" ],
 5.       "LaunchTemplate" : {
 6.         "LaunchTemplateId" : {
 7.           "Ref" : "myLaunchTemplate"
 8.         },
 9.         "Version" : {
10.           "Fn::GetAtt" : [
11.             "myLaunchTemplate",
12.             "LatestVersionNumber"
13.           ]
14.         }
15.       },
16.       "MaxSize" : "1",
17.       "MinSize" : "1"
18.    }
19. }
```

### YAML
<a name="quickref-autoscaling-example-1.yaml"></a>

```
 1. myASG:
 2.   Type: AWS::AutoScaling::AutoScalingGroup
 3.   Properties:
 4.     VPCZoneIdentifier:
 5.       - subnetIdAz1
 6.       - subnetIdAz2
 7.       - subnetIdAz3
 8.     LaunchTemplate:
 9.       LaunchTemplateId: !Ref myLaunchTemplate
10.       Version: !GetAtt myLaunchTemplate.LatestVersionNumber
11.     MaxSize: '1'
12.     MinSize: '1'
```

## Creazione di un gruppo Auto Scaling con un bilanciatore del carico allegato
<a name="scenario-as-group"></a>

Questo esempio mostra una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html) per il bilanciamento del carico su più server. Specifica i nomi logici delle AWS risorse dichiarate altrove nello stesso modello.

1. La proprietà `VPCZoneIdentifier` specifica i nomi logici di due risorse [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-subnet.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-subnet.html) in cui verranno create le istanze EC2 del gruppo Auto Scaling: `myPublicSubnet1` e `myPublicSubnet2`.

1. La proprietà `LaunchTemplate` specifica una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html) con il nome logico `myLaunchTemplate`.

1. La proprietà `TargetGroupARNs` elenca i gruppi di destinazione per Application Load Balancer o Network Load Balancer utilizzati per instradare il traffico al gruppo Auto Scaling. In questo esempio viene specificato un gruppo di destinazione, una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-targetgroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-targetgroup.html) con il nome logico `myTargetGroup`.

### JSON
<a name="quickref-autoscaling-example-2.json"></a>

```
 1. "myServerGroup" : {
 2.    "Type" : "AWS::AutoScaling::AutoScalingGroup",
 3.    "Properties" : {
 4.       "VPCZoneIdentifier" : [ { "Ref" : "myPublicSubnet1" }, { "Ref" : "myPublicSubnet2" } ],
 5.       "LaunchTemplate" : {
 6.         "LaunchTemplateId" : {
 7.           "Ref" : "myLaunchTemplate"
 8.         },
 9.         "Version" : {
10.           "Fn::GetAtt" : [
11.             "myLaunchTemplate",
12.             "LatestVersionNumber"
13.           ]
14.         }
15.       },
16.       "MaxSize" : "5",
17.       "MinSize" : "1",
18.       "TargetGroupARNs" : [ { "Ref" : "myTargetGroup" } ]
19.    }
20. }
```

### YAML
<a name="quickref-autoscaling-example-2.yaml"></a>

```
 1. myServerGroup:
 2.   Type: AWS::AutoScaling::AutoScalingGroup
 3.   Properties:
 4.     VPCZoneIdentifier:
 5.       - !Ref myPublicSubnet1
 6.       - !Ref myPublicSubnet2
 7.     LaunchTemplate:
 8.       LaunchTemplateId: !Ref myLaunchTemplate
 9.       Version: !GetAtt myLaunchTemplate.LatestVersionNumber
10.     MaxSize: '5'
11.     MinSize: '1'
12.     TargetGroupARNs:
13.       - !Ref myTargetGroup
```

### Consulta anche
<a name="scenario-as-group-see-also"></a>

Per un esempio dettagliato nel quale viene creato un gruppo Auto Scaling con una policy di dimensionamento di tracciamento della destinazione basato sul parametro predefinito `ALBRequestCountPerTarget` per Application Load Balancer, consulta la sezione [Esempi](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-scalingpolicy.html#aws-resource-autoscaling-scalingpolicy--examples) nella risorsa `AWS::AutoScaling::ScalingPolicy`.

## Creazione di un gruppo Auto Scaling con notifiche
<a name="scenario-as-notification"></a>

Questo esempio illustra una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html) che invia notifiche Amazon SNS quando hanno luogo gli eventi specificati. La `NotificationConfigurations` proprietà specifica l'argomento SNS a cui CloudFormation invia una notifica e gli eventi che CloudFormation provocheranno l'invio delle notifiche. Quando si `NotificationTypes` verificano gli eventi specificati da, CloudFormation invierà una notifica all'argomento SNS specificato da. `TopicARN` Quando avvii lo stack, CloudFormation crea una [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sns-subscription.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sns-subscription.html)risorsa (`snsTopicForAutoScalingGroup`) dichiarata all'interno dello stesso modello.

La proprietà `VPCZoneIdentifier` del gruppo Auto Scaling specifica un elenco di sottoreti esistenti in diverse zone di disponibilità. È necessario specificare la sottorete applicabile IDs dal vostro account prima di creare lo stack. La proprietà `LaunchTemplate` fa riferimento al nome logico di una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html) dichiarata altrove nello stesso modello.

### JSON
<a name="quickref-autoscaling-example-3.json"></a>

```
 1. "myASG" : {
 2.   "Type" : "AWS::AutoScaling::AutoScalingGroup",
 3.   "DependsOn": [
 4.     "snsTopicForAutoScalingGroup"
 5.   ],
 6.   "Properties" : {
 7.     "VPCZoneIdentifier" : [ "subnetIdAz1", "subnetIdAz2", "subnetIdAz3" ],
 8.     "LaunchTemplate" : {
 9.       "LaunchTemplateId" : {
10.         "Ref" : "logicalName"
11.       },
12.       "Version" : {
13.         "Fn::GetAtt" : [
14.           "logicalName",
15.           "LatestVersionNumber"
16.         ]
17.       }
18.     },
19.     "MaxSize" : "5",
20.     "MinSize" : "1",
21.     "NotificationConfigurations" : [
22.       {
23.         "TopicARN" : { "Ref" : "snsTopicForAutoScalingGroup" },
24.         "NotificationTypes" : [
25.           "autoscaling:EC2_INSTANCE_LAUNCH",
26.           "autoscaling:EC2_INSTANCE_LAUNCH_ERROR",
27.           "autoscaling:EC2_INSTANCE_TERMINATE",
28.           "autoscaling:EC2_INSTANCE_TERMINATE_ERROR",
29.           "autoscaling:TEST_NOTIFICATION"
30.         ]
31.       }
32.     ]
33.   }
34. }
```

### YAML
<a name="quickref-autoscaling-example-3.yaml"></a>

```
 1. myASG:
 2.   Type: AWS::AutoScaling::AutoScalingGroup
 3.   DependsOn:
 4.     - snsTopicForAutoScalingGroup
 5.   Properties:
 6.     VPCZoneIdentifier:
 7.       - subnetIdAz1
 8.       - subnetIdAz2
 9.       - subnetIdAz3
10.     LaunchTemplate:
11.       LaunchTemplateId: !Ref logicalName
12.       Version: !GetAtt logicalName.LatestVersionNumber
13.     MaxSize: '5'
14.     MinSize: '1'
15.     NotificationConfigurations:
16.       - TopicARN: !Ref snsTopicForAutoScalingGroup
17.         NotificationTypes:
18.           - autoscaling:EC2_INSTANCE_LAUNCH
19.           - autoscaling:EC2_INSTANCE_LAUNCH_ERROR
20.           - autoscaling:EC2_INSTANCE_TERMINATE
21.           - autoscaling:EC2_INSTANCE_TERMINATE_ERROR
22.           - autoscaling:TEST_NOTIFICATION
```

## Creazione di un gruppo Auto Scaling usando una `CreationPolicy` e una `UpdatePolicy`
<a name="scenario-as-updatepolicy"></a>

L’esempio seguente mostra come aggiungere attributi `CreationPolicy` e `UpdatePolicy` a una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html).

La politica di creazione del campione impedisce al gruppo Auto Scaling di raggiungere `CREATE_COMPLETE` lo stato finché non CloudFormation riceve un `Count` numero di segnali di successo quando il gruppo è pronto. Per segnalare che il gruppo Auto Scaling è pronto, sulle istanze viene eseguito uno script helper `cfn-signal` aggiunto ai dati utente del modello di avvio (non visualizzato). Se le istanze non inviano un segnale entro il limite specificato`Timeout`, CloudFormation presuppone che le istanze non siano state create, la creazione della risorsa fallisce e ripristina lo stack CloudFormation .

La politica di aggiornamento di esempio indica di CloudFormation eseguire un aggiornamento continuo utilizzando la proprietà. `AutoScalingRollingUpdate` L’aggiornamento in sequenza modifica il gruppo Auto Scaling in piccoli batch (per questo esempio, istanza per istanza) in base a `MaxBatchSize` e alla pausa che intercorre tra i batch di aggiornamento in base al `PauseTime`. L'`MinInstancesInService`attributo specifica il numero minimo di istanze che devono essere in servizio all'interno del gruppo Auto Scaling CloudFormation durante l'aggiornamento delle vecchie istanze.

L’attributo `WaitOnResourceSignals` viene impostato su `true`. CloudFormation deve ricevere un segnale da ogni nuova istanza entro il `PauseTime` specificato prima di procedere con l'aggiornamento. Durante l’aggiornamento dello stack, vengono sospesi i seguenti processi di EC2 Auto Scaling: `HealthCheck`, `ReplaceUnhealthy`, `AZRebalance`, `AlarmNotification` e `ScheduledActions`. Nota: non sospendere i tipi di processo `Launch`, `Terminate`, o `AddToLoadBalancer` (se il gruppo Auto Scaling viene utilizzato con Elastic Load Balancing) perché in tal modo è possibile impedire il corretto funzionamento dell’aggiornamento in sequenza.

La proprietà `VPCZoneIdentifier` del gruppo Auto Scaling specifica un elenco di sottoreti esistenti in diverse zone di disponibilità. È necessario specificare la sottorete applicabile IDs dal proprio account prima di creare lo stack. La proprietà `LaunchTemplate` fa riferimento al nome logico di una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html) dichiarata altrove nello stesso modello.

Per ulteriori informazioni sugli attributi `CreationPolicy` e `UpdatePolicy`, consulta [Riferimento attributo della risorsa](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-product-attribute-reference.html).

### JSON
<a name="quickref-autoscaling-example-4.json"></a>

```
{
  "Resources":{
    "myASG":{
      "CreationPolicy":{
        "ResourceSignal":{
          "Count":"3",
          "Timeout":"PT15M"
        }
      },
      "UpdatePolicy":{
        "AutoScalingRollingUpdate":{
          "MinInstancesInService":"3",
          "MaxBatchSize":"1",
          "PauseTime":"PT12M5S",
          "WaitOnResourceSignals":"true",
          "SuspendProcesses":[
            "HealthCheck",
            "ReplaceUnhealthy",
            "AZRebalance",
            "AlarmNotification",
            "ScheduledActions",
            "InstanceRefresh"
          ]
        }
      },
      "Type":"AWS::AutoScaling::AutoScalingGroup",
      "Properties":{
        "VPCZoneIdentifier":[ "subnetIdAz1", "subnetIdAz2", "subnetIdAz3" ],
        "LaunchTemplate":{
          "LaunchTemplateId":{
            "Ref":"logicalName"
          },
          "Version":{
            "Fn::GetAtt":[
              "logicalName",
              "LatestVersionNumber"
            ]
          }
        },
        "MaxSize":"5",
        "MinSize":"3"
      }
    }
  }
}
```

### YAML
<a name="quickref-autoscaling-example-4.yaml"></a>

```
---
Resources:
  myASG:
    CreationPolicy:
      ResourceSignal:
        Count: '3'
        Timeout: PT15M
    UpdatePolicy:
      AutoScalingRollingUpdate:
        MinInstancesInService: '3'
        MaxBatchSize: '1'
        PauseTime: PT12M5S
        WaitOnResourceSignals: true
        SuspendProcesses:
          - HealthCheck
          - ReplaceUnhealthy
          - AZRebalance
          - AlarmNotification
          - ScheduledActions
          - InstanceRefresh
    Type: AWS::AutoScaling::AutoScalingGroup
    Properties:
      VPCZoneIdentifier:
        - subnetIdAz1
        - subnetIdAz2
        - subnetIdAz3
      LaunchTemplate:
        LaunchTemplateId: !Ref logicalName
        Version: !GetAtt logicalName.LatestVersionNumber
      MaxSize: '5'
      MinSize: '3'
```

## Creazione di una policy di dimensionamento per fasi
<a name="scenario-step-scaling-policy"></a>

Questo esempio illustra una [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-scalingpolicy.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-scalingpolicy.html) che aumenta orizzontalmente il gruppo Auto Scaling utilizzando una semplice policy di dimensionamento. La proprietà `AdjustmentType` specifica `ChangeInCapacity`, il che significa che `ScalingAdjustment` rappresenta il numero di istanze da aggiungere (se `ScalingAdjustment` è positiva) o eliminare (se è negativa). In questo esempio, `ScalingAdjustment` corrisponde a 1, perciò la policy aumenta il numero di istanze EC2 nel gruppo di 1 quando viene toccata la soglia dell’allarme.

La risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudwatch-alarm.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudwatch-alarm.html) `CPUAlarmHigh` specifica la policy di dimensionamento `ASGScalingPolicyHigh` come operazione da eseguire quando l’allarme è in uno stato ALARM (`AlarmActions`). La proprietà `Dimensions` fa riferimento al nome logico di una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html) dichiarata altrove nello stesso modello.

### JSON
<a name="quickref-autoscaling-example-5.json"></a>

```
 1. {
 2.   "Resources":{
 3.     "ASGScalingPolicyHigh":{
 4.       "Type":"AWS::AutoScaling::ScalingPolicy",
 5.       "Properties":{
 6.         "AutoScalingGroupName":{ "Ref":"logicalName" },
 7.         "PolicyType":"StepScaling",
 8.         "AdjustmentType":"ChangeInCapacity",
 9.         "StepAdjustments":[
10.           {
11.             "MetricIntervalLowerBound":0,
12.             "ScalingAdjustment":1
13.           }
14.         ]
15.       }
16.     },
17.     "CPUAlarmHigh":{
18.       "Type":"AWS::CloudWatch::Alarm",
19.       "Properties":{
20.         "EvaluationPeriods":"2",
21.         "Statistic":"Average",
22.         "Threshold":"90",
23.         "AlarmDescription":"Scale out if CPU > 90% for 2 minutes",
24.         "Period":"60",
25.         "AlarmActions":[ { "Ref":"ASGScalingPolicyHigh" } ],
26.         "Namespace":"AWS/EC2",
27.         "Dimensions":[
28.           {
29.             "Name":"AutoScalingGroupName",
30.             "Value":{ "Ref":"logicalName" }
31.           }
32.         ],
33.         "ComparisonOperator":"GreaterThanThreshold",
34.         "MetricName":"CPUUtilization"
35.       }
36.     }
37.   }
38. }
```

### YAML
<a name="quickref-autoscaling-example-5.yaml"></a>

```
 1. ---
 2. Resources:
 3.   ASGScalingPolicyHigh:
 4.     Type: AWS::AutoScaling::ScalingPolicy
 5.     Properties:
 6.       AutoScalingGroupName: !Ref logicalName
 7.       PolicyType: StepScaling
 8.       AdjustmentType: ChangeInCapacity
 9.       StepAdjustments: 
10.         - MetricIntervalLowerBound: 0
11.           ScalingAdjustment: 1
12.   CPUAlarmHigh:
13.     Type: AWS::CloudWatch::Alarm
14.     Properties:
15.       EvaluationPeriods: 2
16.       Statistic: Average
17.       Threshold: 90
18.       AlarmDescription: 'Scale out if CPU > 90% for 2 minutes'
19.       Period: 60
20.       AlarmActions:
21.         - !Ref ASGScalingPolicyHigh
22.       Namespace: AWS/EC2
23.       Dimensions:
24.         - Name: AutoScalingGroupName
25.           Value:
26.             !Ref logicalName
27.       ComparisonOperator: GreaterThanThreshold
28.       MetricName: CPUUtilization
```

### Consulta anche
<a name="scenario-as-policy-see-also"></a>

Per altri modelli di esempio per le policy di dimensionamento, consulta la sezione [Esempi](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-scalingpolicy.html#aws-resource-autoscaling-scalingpolicy--examples) nella risorsa `AWS::AutoScaling::ScalingPolicy`.

## Esempi di gruppi di istanze miste
<a name="scenario-mixed-instances-group-template-examples"></a>

### Crea un gruppo Auto Scaling utilizzando la selezione del tipo di istanza basata su attributi
<a name="scenario-mixed-instances-group-instance-requirements"></a>

Questo esempio mostra una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html) che contiene le informazioni per avviare un gruppo di istanze miste utilizzando la selezione del tipo di istanza basata su attributi. Puoi specificare il valore minimo e massimo per la proprietà `VCpuCount` e il valore minimo per la proprietà `MemoryMiB`. Tutti i tipi di istanza utilizzati dal gruppo Auto Scaling devono rispettare agli attributi dell’istanza richiesti. 

La proprietà `VPCZoneIdentifier` del gruppo Auto Scaling specifica un elenco di sottoreti esistenti in diverse zone di disponibilità. È necessario specificare la sottorete applicabile IDs dal proprio account prima di creare lo stack. La proprietà `LaunchTemplate` fa riferimento al nome logico di una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html) dichiarata altrove nello stesso modello.

#### JSON
<a name="quickref-mixed-instances-group-example-2.json"></a>

```
 1. {
 2.   "Resources":{
 3.     "myASG":{
 4.       "Type":"AWS::AutoScaling::AutoScalingGroup",
 5.       "Properties":{
 6.         "VPCZoneIdentifier":[
 7.           "subnetIdAz1",
 8.           "subnetIdAz2",
 9.           "subnetIdAz3"
10.         ],
11.         "MixedInstancesPolicy":{
12.           "LaunchTemplate":{
13.             "LaunchTemplateSpecification":{
14.               "LaunchTemplateId":{
15.                 "Ref":"logicalName"
16.               },
17.               "Version":{
18.                 "Fn::GetAtt":[
19.                   "logicalName",
20.                   "LatestVersionNumber"
21.                 ]
22.               }
23.             },
24.             "Overrides":[
25.               {
26.                 "InstanceRequirements":{
27.                   "VCpuCount":{
28.                     "Min":2,
29.                     "Max":4
30.                   },
31.                   "MemoryMiB":{
32.                     "Min":2048
33.                   }
34.                 }
35.               }
36.             ]
37.           }
38.         },
39.         "MaxSize":"5",
40.         "MinSize":"1"
41.       }
42.     }
43.   }
44. }
```

#### YAML
<a name="quickref-mixed-instances-group-example-1.yaml"></a>

```
 1. ---
 2. Resources:
 3.   myASG:
 4.     Type: AWS::AutoScaling::AutoScalingGroup
 5.     Properties:
 6.       VPCZoneIdentifier:
 7.         - subnetIdAz1
 8.         - subnetIdAz2
 9.         - subnetIdAz3
10.       MixedInstancesPolicy:
11.         LaunchTemplate:
12.           LaunchTemplateSpecification:
13.             LaunchTemplateId: !Ref logicalName
14.             Version: !GetAtt logicalName.LatestVersionNumber
15.           Overrides:
16.             - InstanceRequirements:
17.                 VCpuCount:
18.                   Min: 2
19.                   Max: 4
20.                 MemoryMiB:
21.                   Min: 2048
22.       MaxSize: '5'
23.       MinSize: '1'
```

## Esempi di configurazione di avvio
<a name="scenario-launch-config-template-examples"></a>

### Creazione di una configurazione di avvio
<a name="scenario-as-launch-config"></a>

Questo esempio illustra una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-launchconfiguration.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-launchconfiguration.html) per un gruppo Auto Scaling nel quale vengono specificati valori per le proprietà `ImageId`, `InstanceType` e `SecurityGroups`. La proprietà `SecurityGroups` specifica sia il nome logico di una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html) definita altrove nel modello, che un gruppo di sicurezza EC2 esistente denominato `myExistingEC2SecurityGroup`.

#### JSON
<a name="quickref-launch-config-example-1.json"></a>

```
1. "mySimpleConfig" : {
2.    "Type" : "AWS::AutoScaling::LaunchConfiguration",
3.    "Properties" : {
4.       "ImageId" : "ami-02354e95b3example",
5.       "InstanceType" : "t3.micro",
6.       "SecurityGroups" : [ { "Ref" : "logicalName" }, "myExistingEC2SecurityGroup" ]
7.    }
8. }
```

#### YAML
<a name="quickref-launch-config-example-1.yaml"></a>

```
1. mySimpleConfig:
2.   Type: AWS::AutoScaling::LaunchConfiguration
3.   Properties:
4.     ImageId: ami-02354e95b3example
5.     InstanceType: t3.micro
6.     SecurityGroups:
7.       - !Ref logicalName
8.       - myExistingEC2SecurityGroup
```

### Creazione di un gruppo Auto Scaling utilizzando una configurazione di avvio
<a name="scenario-single-instance-as-group-launch-configuration"></a>

Questo esempio mostra una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html) con una singola istanza. La proprietà `VPCZoneIdentifier` del gruppo Auto Scaling specifica un elenco di sottoreti esistenti in diverse zone di disponibilità. È necessario specificare la sottorete applicabile IDs dal proprio account prima di creare lo stack. La proprietà `LaunchConfigurationName` fa riferimento a una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-launchconfiguration.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-launchconfiguration.html) con il nome logico `mySimpleConfig` definito nel modello.

#### JSON
<a name="quickref-launch-config-example-2.json"></a>

```
1. "myASG" : {
2.    "Type" : "AWS::AutoScaling::AutoScalingGroup",
3.    "Properties" : {
4.       "VPCZoneIdentifier" : [ "subnetIdAz1", "subnetIdAz2", "subnetIdAz3" ],
5.       "LaunchConfigurationName" : { "Ref" : "mySimpleConfig" },
6.       "MaxSize" : "1",
7.       "MinSize" : "1"
8.    }
9. }
```

#### YAML
<a name="quickref-launch-config-example-2.yaml"></a>

```
 1. myASG:
 2.   Type: AWS::AutoScaling::AutoScalingGroup
 3.   Properties:
 4.     VPCZoneIdentifier:
 5.       - subnetIdAz1
 6.       - subnetIdAz2
 7.       - subnetIdAz3
 8.     LaunchConfigurationName: !Ref mySimpleConfig
 9.     MaxSize: '1'
10.     MinSize: '1'
```

# Configura le risorse di Application Auto Scaling con CloudFormation
<a name="quickref-application-auto-scaling"></a>

Questa sezione fornisce esempi di CloudFormation modelli per le politiche di scalabilità di Application Auto Scaling e le azioni pianificate per diverse risorse. AWS 

**Importante**  
Quando un frammento di Application Auto Scaling è incluso nel modello, potrebbe essere necessario dichiarare una dipendenza dalla risorsa scalabile specifica creata tramite il modello utilizzando l’attributo `DependsOn`. Questo sovrascrive il parallelismo predefinito e indirizza CloudFormation a operare sulle risorse in un ordine specifico. In caso contrario, la configurazione di ridimensionamento potrebbe essere applicata prima che la risorsa sia stata configurata completamente.  
Per ulteriori informazioni, consulta [Attributo DependsOn](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-dependson.html).

**Topics**
+ [Crea una politica di scalabilità per una flotta AppStream](#w2aac11c41c15c19b9)
+ [Creazione di una policy di dimensionamento per un cluster Aurora DB](#w2aac11c41c15c19c11)
+ [Creazione di una policy di dimensionamento per una tabella DynamoDB](#w2aac11c41c15c19c13)
+ [Creazione di una policy di dimensionamento per un servizio Amazon ECS (parametri: CPU e memoria medie)](#w2aac11c41c15c19c15)
+ [Creazione di una policy di dimensionamento per un servizio Amazon ECS (metrica: numero medio di richieste per destinazione)](#w2aac11c41c15c19c17)
+ [Creazione di un’operazione pianificata con una espressione Cron per una funzione Lambda](#w2aac11c41c15c19c19)
+ [Creazione di un’operazione pianificata con una espressione `at` per un parco istanze spot](#w2aac11c41c15c19c21)

## Crea una politica di scalabilità per una flotta AppStream
<a name="w2aac11c41c15c19b9"></a>

Questo frammento mostra come creare una policy e applicarla a una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-appstream-fleet.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-appstream-fleet.html) utilizzando la risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalingpolicy.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalingpolicy.html). La risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalabletarget.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalabletarget.html) dichiara una destinazione scalabile a cui viene applicata questa policy. Application Auto Scaling può scalare il numero di istanze del parco istanze a un minimo di un’istanza e un massimo di 20. La policy mantiene l’utilizzo medio della capacità del parco istanze al 75%, con tempi di raffreddamento delle operazioni di dimensionamento di 300 secondi (5 minuti).

Utilizza le funzioni intrinseche `Fn::Join` e `Rev` per costruire la proprietà `ResourceId` con il nome logico della risorsa `AWS::AppStream::Fleet` specificata nello stesso modello. Per ulteriori informazioni, consulta [Riferimento funzione intrinseca](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference.html).

### JSON
<a name="quickref-autoscaling-example-6.json"></a>

```
{
  "Resources" : {
    "ScalableTarget" : {
      "Type" : "AWS::ApplicationAutoScaling::ScalableTarget",
      "Properties" : {
        "MaxCapacity" : 20,
        "MinCapacity" : 1,
        "RoleARN" : { "Fn::Sub" : "arn:aws:iam::${AWS::AccountId}:role/aws-service-role/appstream.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_AppStreamFleet" },
        "ServiceNamespace" : "appstream",
        "ScalableDimension" : "appstream:fleet:DesiredCapacity",
        "ResourceId" : {
          "Fn::Join" : [
            "/",
            [
              "fleet",
              {
                "Ref" : "logicalName"
              }
            ]
          ]
        }
      }
    },
    "ScalingPolicyAppStreamFleet" : {
      "Type" : "AWS::ApplicationAutoScaling::ScalingPolicy",
      "Properties" : {
        "PolicyName" : { "Fn::Sub" : "${AWS::StackName}-target-tracking-cpu75" },
        "PolicyType" : "TargetTrackingScaling",
        "ServiceNamespace" : "appstream",
        "ScalableDimension" : "appstream:fleet:DesiredCapacity",
        "ResourceId" : {
          "Fn::Join" : [
            "/",
            [
              "fleet",
              {
                "Ref" : "logicalName"
              }
            ]
          ]
        },
        "TargetTrackingScalingPolicyConfiguration" : {
          "TargetValue" : 75,
          "PredefinedMetricSpecification" : {
            "PredefinedMetricType" : "AppStreamAverageCapacityUtilization"
          },
          "ScaleInCooldown" : 300,
          "ScaleOutCooldown" : 300
        }
      }
    } 
  }
}
```

### YAML
<a name="quickref-autoscaling-example-6.yaml"></a>

```
---
Resources:
  ScalableTarget:
    Type: AWS::ApplicationAutoScaling::ScalableTarget
    Properties:
      MaxCapacity: 20
      MinCapacity: 1
      RoleARN: 
        Fn::Sub: 'arn:aws:iam::${AWS::AccountId}:role/aws-service-role/appstream.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_AppStreamFleet'
      ServiceNamespace: appstream
      ScalableDimension: appstream:fleet:DesiredCapacity
      ResourceId: !Join
        - /
        - - fleet
          - !Ref logicalName
  ScalingPolicyAppStreamFleet:
    Type: AWS::ApplicationAutoScaling::ScalingPolicy
    Properties:
      PolicyName: !Sub ${AWS::StackName}-target-tracking-cpu75
      PolicyType: TargetTrackingScaling
      ServiceNamespace: appstream
      ScalableDimension: appstream:fleet:DesiredCapacity
      ResourceId: !Join
        - /
        - - fleet
          - !Ref logicalName
      TargetTrackingScalingPolicyConfiguration:
        TargetValue: 75
        PredefinedMetricSpecification:
          PredefinedMetricType: AppStreamAverageCapacityUtilization
        ScaleInCooldown: 300
        ScaleOutCooldown: 300
```

## Creazione di una policy di dimensionamento per un cluster Aurora DB
<a name="w2aac11c41c15c19c11"></a>

In questo frammento registri una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbcluster.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbcluster.html). La registrazione [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalabletarget.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalabletarget.html) indica che il cluster DB deve essere dimensionato dinamicamente per avere da uno a otto repliche Aurora. Puoi inoltre applicare al cluster una policy di scalabilità di rilevamento di destinazione utilizzando la risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalingpolicy.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalingpolicy.html).

In questa configurazione, il parametro predefinito `RDSReaderAverageCPUUtilization` viene utilizzato per regolare un cluster di database Aurora; in base a un utilizzo medio della CPU del 40 per cento in tutte le repliche Aurora; in quel cluster di database Aurora. La configurazione fornisce un tempo di raffreddamento di riduzione di 10 minuti e un tempo di raffreddamento di aumento di 5 minuti.

Questo esempio utilizza la funzione intrinseca `Fn::Sub` per costruire la proprietà `ResourceId` con il nome logico della risorsa `AWS::RDS::DBCluster` specificata nello stesso modello. Per ulteriori informazioni, consulta [Riferimento funzione intrinseca](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference.html).

### JSON
<a name="quickref-autoscaling-example-7.json"></a>

```
{
  "Resources" : {
    "ScalableTarget" : {
      "Type" : "AWS::ApplicationAutoScaling::ScalableTarget",
      "Properties" : {
        "MaxCapacity" : 8,
        "MinCapacity" : 1,
        "RoleARN" : { "Fn::Sub" : "arn:aws:iam::${AWS::AccountId}:role/aws-service-role/rds.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_RDSCluster" },
        "ServiceNamespace" : "rds",
        "ScalableDimension" : "rds:cluster:ReadReplicaCount",
        "ResourceId" : { "Fn::Sub" : "cluster:${logicalName}" }
      }
    },
    "ScalingPolicyDBCluster" : {
      "Type" : "AWS::ApplicationAutoScaling::ScalingPolicy",
      "Properties" : {
        "PolicyName" : { "Fn::Sub" : "${AWS::StackName}-target-tracking-cpu40" },
        "PolicyType" : "TargetTrackingScaling",
        "ServiceNamespace" : "rds",
        "ScalableDimension" : "rds:cluster:ReadReplicaCount",
        "ResourceId" : { "Fn::Sub" : "cluster:${logicalName}" }, 
        "TargetTrackingScalingPolicyConfiguration" : {
          "TargetValue" : 40,
          "PredefinedMetricSpecification" : {
            "PredefinedMetricType" : "RDSReaderAverageCPUUtilization"
          },
          "ScaleInCooldown" : 600,
          "ScaleOutCooldown" : 300
        }
      }
    }
  }
}
```

### YAML
<a name="quickref-autoscaling-example-7.yaml"></a>

```
---
Resources:
  ScalableTarget:
    Type: AWS::ApplicationAutoScaling::ScalableTarget
    Properties:
      MaxCapacity: 8
      MinCapacity: 1
      RoleARN: 
        Fn::Sub: 'arn:aws:iam::${AWS::AccountId}:role/aws-service-role/rds.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_RDSCluster'
      ServiceNamespace: rds
      ScalableDimension: rds:cluster:ReadReplicaCount
      ResourceId: !Sub cluster:${logicalName}
  ScalingPolicyDBCluster:
    Type: AWS::ApplicationAutoScaling::ScalingPolicy
    Properties:
      PolicyName: !Sub ${AWS::StackName}-target-tracking-cpu40
      PolicyType: TargetTrackingScaling
      ServiceNamespace: rds
      ScalableDimension: rds:cluster:ReadReplicaCount
      ResourceId: !Sub cluster:${logicalName}
      TargetTrackingScalingPolicyConfiguration:
        TargetValue: 40
        PredefinedMetricSpecification:
          PredefinedMetricType: RDSReaderAverageCPUUtilization
        ScaleInCooldown: 600
        ScaleOutCooldown: 300
```

## Creazione di una policy di dimensionamento per una tabella DynamoDB
<a name="w2aac11c41c15c19c13"></a>

Questo frammento mostra come creare una policy con il tipo di policy `TargetTrackingScaling` e applicarla a una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-dynamodb-table.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-dynamodb-table.html) utilizzando la risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalingpolicy.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalingpolicy.html). La risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalabletarget.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalabletarget.html) dichiara una destinazione scalabile a cui viene applicata questa policy, con un minimo di cinque unità di capacità di scrittura e un massimo di 15. La policy di dimensionamento ridimensiona la capacità di throughput di scrittura della tabella per mantenere l’utilizzo target al 50% in base al parametro predefinito `DynamoDBWriteCapacityUtilization`.

Utilizza le funzioni intrinseche `Fn::Join` e `Ref` per costruire la proprietà `ResourceId` con il nome logico della risorsa `AWS::DynamoDB::Table` specificata nello stesso modello. Per ulteriori informazioni, consulta [Intrinsic function reference](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference.html).

**Nota**  
Per ulteriori informazioni su come creare un CloudFormation modello per le risorse DynamoDB, consulta il [post del blog How to use CloudFormation to configure auto scaling for Amazon DynamoDB tables and index on the Database Blog](https://aws.amazon.com/blogs/database/how-to-use-aws-cloudformation-to-configure-auto-scaling-for-amazon-dynamodb-tables-and-indexes/). AWS 

### JSON
<a name="quickref-autoscaling-example-8.json"></a>

```
{
  "Resources" : {
    "WriteCapacityScalableTarget" : {
      "Type" : "AWS::ApplicationAutoScaling::ScalableTarget",
      "Properties" : {
        "MaxCapacity" : 15,
        "MinCapacity" : 5,
        "RoleARN" : { "Fn::Sub" : "arn:aws:iam::${AWS::AccountId}:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable" },
        "ServiceNamespace" : "dynamodb",
        "ScalableDimension" : "dynamodb:table:WriteCapacityUnits",
        "ResourceId" : {
          "Fn::Join" : [
            "/",
            [
              "table",
              {
                "Ref" : "logicalName"
              }
            ]
          ]
        }
      }
    },
    "WriteScalingPolicy" : {
      "Type" : "AWS::ApplicationAutoScaling::ScalingPolicy",
      "Properties" : {
        "PolicyName" : "WriteScalingPolicy",
        "PolicyType" : "TargetTrackingScaling",
        "ScalingTargetId" : { "Ref" : "WriteCapacityScalableTarget" },
        "TargetTrackingScalingPolicyConfiguration" : {
          "TargetValue" : 50.0,
          "ScaleInCooldown" : 60,
          "ScaleOutCooldown" : 60,
          "PredefinedMetricSpecification" : {
            "PredefinedMetricType" : "DynamoDBWriteCapacityUtilization"
          }
        }
      }
    }
  }
}
```

### YAML
<a name="quickref-autoscaling-example-8.yaml"></a>

```
---
Resources:
  WriteCapacityScalableTarget:
    Type: AWS::ApplicationAutoScaling::ScalableTarget
    Properties:
      MaxCapacity: 15
      MinCapacity: 5
      RoleARN: 
        Fn::Sub: 'arn:aws:iam::${AWS::AccountId}:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable'
      ServiceNamespace: dynamodb
      ScalableDimension: dynamodb:table:WriteCapacityUnits
      ResourceId: !Join
        - /
        - - table
          - !Ref logicalName
  WriteScalingPolicy:
    Type: AWS::ApplicationAutoScaling::ScalingPolicy
    Properties:
      PolicyName: WriteScalingPolicy
      PolicyType: TargetTrackingScaling
      ScalingTargetId: !Ref WriteCapacityScalableTarget
      TargetTrackingScalingPolicyConfiguration:
        TargetValue: 50.0
        ScaleInCooldown: 60
        ScaleOutCooldown: 60
        PredefinedMetricSpecification:
          PredefinedMetricType: DynamoDBWriteCapacityUtilization
```

## Creazione di una policy di dimensionamento per un servizio Amazon ECS (parametri: CPU e memoria medie)
<a name="w2aac11c41c15c19c15"></a>

Questo frammento mostra come creare una policy e applicarla a una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-service.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-service.html) utilizzando la risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalingpolicy.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalingpolicy.html). La risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalabletarget.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalabletarget.html) dichiara una destinazione scalabile a cui viene applicata questa policy. Application Auto Scaling può scalare il numero di attività a un minimo di 1 e un massimo di 6.

Vengono creati due criteri di ridimensionamento con il tipo di criterio `TargetTrackingScaling`. Le policy vengono utilizzate per scalare il servizio ECS in base all’utilizzo medio della CPU e della memoria del servizio. Utilizza le funzioni intrinseche `Fn::Join` e `Ref` per costruire la proprietà `ResourceId` con i nomi logici delle risorse [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-cluster.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ecs-cluster.html) (`myContainerCluster`) e `AWS::ECS::Service` (`myService`) specificate nello stesso modello. Per ulteriori informazioni, consulta [Intrinsic function reference](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference.html).

### JSON
<a name="quickref-autoscaling-example-9.json"></a>

```
{
  "Resources" : {
    "ECSScalableTarget" : {
      "Type" : "AWS::ApplicationAutoScaling::ScalableTarget",
      "Properties" : {
        "MaxCapacity" : "6",
        "MinCapacity" : "1",
        "RoleARN" : { "Fn::Sub" : "arn:aws:iam::${AWS::AccountId}:role/aws-service-role/ecs.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_ECSService" },
        "ServiceNamespace" : "ecs",
        "ScalableDimension" : "ecs:service:DesiredCount",
        "ResourceId" : {
          "Fn::Join" : [
            "/",
            [
              "service",
              {
                "Ref" : "myContainerCluster"
              },
              {
                "Fn::GetAtt" : [
                  "myService",
                  "Name"
                ]
              }
            ]
          ]
        }
      }
    },
    "ServiceScalingPolicyCPU" : {
      "Type" : "AWS::ApplicationAutoScaling::ScalingPolicy",
      "Properties" : {
        "PolicyName" : { "Fn::Sub" : "${AWS::StackName}-target-tracking-cpu70" },
        "PolicyType" : "TargetTrackingScaling",
        "ScalingTargetId" : { "Ref" : "ECSScalableTarget" },
        "TargetTrackingScalingPolicyConfiguration" : {
          "TargetValue" : 70.0,
          "ScaleInCooldown" : 180,
          "ScaleOutCooldown" : 60,
          "PredefinedMetricSpecification" : {
            "PredefinedMetricType" : "ECSServiceAverageCPUUtilization"
          }
        }
      }
    },
    "ServiceScalingPolicyMem" : {
      "Type" : "AWS::ApplicationAutoScaling::ScalingPolicy",
      "Properties" : {
        "PolicyName" : { "Fn::Sub" : "${AWS::StackName}-target-tracking-mem90" },
        "PolicyType" : "TargetTrackingScaling",
        "ScalingTargetId" : { "Ref" : "ECSScalableTarget" },
        "TargetTrackingScalingPolicyConfiguration" : {
          "TargetValue" : 90.0,
          "ScaleInCooldown" : 180,
          "ScaleOutCooldown" : 60,
          "PredefinedMetricSpecification" : {
            "PredefinedMetricType" : "ECSServiceAverageMemoryUtilization"
          }
        }
      }
    }
  }
}
```

### YAML
<a name="quickref-autoscaling-example-9.yaml"></a>

```
---
Resources:
  ECSScalableTarget:
    Type: AWS::ApplicationAutoScaling::ScalableTarget
    Properties:
      MaxCapacity: 6
      MinCapacity: 1  
      RoleARN: 
        Fn::Sub: 'arn:aws:iam::${AWS::AccountId}:role/aws-service-role/ecs.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_ECSService'
      ServiceNamespace: ecs
      ScalableDimension: 'ecs:service:DesiredCount'
      ResourceId: !Join 
        - /
        - - service
          - !Ref myContainerCluster
          - !GetAtt myService.Name
  ServiceScalingPolicyCPU:
    Type: AWS::ApplicationAutoScaling::ScalingPolicy
    Properties:
      PolicyName: !Sub ${AWS::StackName}-target-tracking-cpu70
      PolicyType: TargetTrackingScaling
      ScalingTargetId: !Ref ECSScalableTarget
      TargetTrackingScalingPolicyConfiguration:
        TargetValue: 70.0
        ScaleInCooldown: 180
        ScaleOutCooldown: 60
        PredefinedMetricSpecification:
          PredefinedMetricType: ECSServiceAverageCPUUtilization
  ServiceScalingPolicyMem:
    Type: AWS::ApplicationAutoScaling::ScalingPolicy
    Properties:
      PolicyName: !Sub ${AWS::StackName}-target-tracking-mem90
      PolicyType: TargetTrackingScaling
      ScalingTargetId: !Ref ECSScalableTarget
      TargetTrackingScalingPolicyConfiguration:
        TargetValue: 90.0
        ScaleInCooldown: 180
        ScaleOutCooldown: 60
        PredefinedMetricSpecification:
          PredefinedMetricType: ECSServiceAverageMemoryUtilization
```

## Creazione di una policy di dimensionamento per un servizio Amazon ECS (metrica: numero medio di richieste per destinazione)
<a name="w2aac11c41c15c19c17"></a>

Nell’esempio seguente viene applicato a un servizio ECS un criterio di scalabilità di tracciamento della destinazione con il parametro predefinito `ALBRequestCountPerTarget`. La policy viene utilizzata per aggiungere capacità al servizio ECS quando il conteggio di richieste per target (al minuto) supera il valore previsto. Poiché il valore di `DisableScaleIn` è impostato su `true`, la policy di monitoraggio target non rimuoverà capacità dal target scalabile.

Utilizza le funzioni intrinseche `Fn::Join` e `Fn::GetAtt` per costruire la proprietà `ResourceLabel` con i nomi logici delle risorse [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-loadbalancer.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-loadbalancer.html) (`myLoadBalancer`) e [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-targetgroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-targetgroup.html) (`myTargetGroup`) specificate nello stesso modello. Per ulteriori informazioni, consulta [Intrinsic function reference](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference.html).

Le proprietà `MaxCapacity` e `MinCapacity` della destinazione scalabile e la proprietà `TargetValue` dei valori dei parametri di riferimento del criterio di ridimensionamento che vengono passati al modello durante la creazione o l’aggiornamento di uno stack.

### JSON
<a name="quickref-autoscaling-example-10.json"></a>

```
{
  "Resources" : {
    "ECSScalableTarget" : {
      "Type" : "AWS::ApplicationAutoScaling::ScalableTarget",
      "Properties" : {
        "MaxCapacity" : { "Ref" : "MaxCount" },
        "MinCapacity" : { "Ref" : "MinCount" },
        "RoleARN" : { "Fn::Sub" : "arn:aws:iam::${AWS::AccountId}:role/aws-service-role/ecs.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_ECSService" },
        "ServiceNamespace" : "ecs",
        "ScalableDimension" : "ecs:service:DesiredCount",
        "ResourceId" : {
          "Fn::Join" : [
            "/",
            [
              "service",
              {
                "Ref" : "myContainerCluster"
              },
              {
                "Fn::GetAtt" : [
                  "myService",
                  "Name"
                ]
              }
            ]
          ]
        }
      }
    },
    "ServiceScalingPolicyALB" : {
      "Type" : "AWS::ApplicationAutoScaling::ScalingPolicy",
      "Properties" : {
        "PolicyName" : "alb-requests-per-target-per-minute",
        "PolicyType" : "TargetTrackingScaling",
        "ScalingTargetId" : { "Ref" : "ECSScalableTarget" },
        "TargetTrackingScalingPolicyConfiguration" : {
          "TargetValue" : { "Ref" : "ALBPolicyTargetValue" },
          "ScaleInCooldown" : 180,
          "ScaleOutCooldown" : 30,
          "DisableScaleIn" : true,
          "PredefinedMetricSpecification" : {
            "PredefinedMetricType" : "ALBRequestCountPerTarget",
            "ResourceLabel" : {
              "Fn::Join" : [
                "/",
                [
                  {
                    "Fn::GetAtt" : [
                      "myLoadBalancer",
                      "LoadBalancerFullName"
                    ]
                  },
                  {
                    "Fn::GetAtt" : [
                      "myTargetGroup",
                      "TargetGroupFullName"
                    ]
                  }
                ]
              ]
            }
          }
        }
      }
    }
  }
}
```

### YAML
<a name="quickref-autoscaling-example-10.yaml"></a>

```
---
Resources:
  ECSScalableTarget:
    Type: AWS::ApplicationAutoScaling::ScalableTarget
    Properties:
      MaxCapacity: !Ref MaxCount
      MinCapacity: !Ref MinCount  
      RoleARN: 
        Fn::Sub: 'arn:aws:iam::${AWS::AccountId}:role/aws-service-role/ecs.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_ECSService'
      ServiceNamespace: ecs
      ScalableDimension: 'ecs:service:DesiredCount'
      ResourceId: !Join 
        - /
        - - service
          - !Ref myContainerCluster
          - !GetAtt myService.Name
  ServiceScalingPolicyALB:
    Type: AWS::ApplicationAutoScaling::ScalingPolicy
    Properties:
      PolicyName: alb-requests-per-target-per-minute
      PolicyType: TargetTrackingScaling
      ScalingTargetId: !Ref ECSScalableTarget
      TargetTrackingScalingPolicyConfiguration:
        TargetValue: !Ref ALBPolicyTargetValue
        ScaleInCooldown: 180
        ScaleOutCooldown: 30
        DisableScaleIn: true
        PredefinedMetricSpecification:
          PredefinedMetricType: ALBRequestCountPerTarget
          ResourceLabel: !Join 
            - '/' 
            - - !GetAtt myLoadBalancer.LoadBalancerFullName
              - !GetAtt myTargetGroup.TargetGroupFullName
```

## Creazione di un’operazione pianificata con una espressione Cron per una funzione Lambda
<a name="w2aac11c41c15c19c19"></a>

Questo frammento registra la concorrenza fornita per una funzione alias ([https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-lambda-alias.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-lambda-alias.html)) denominata `BLUE` utilizzando la risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalabletarget.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalabletarget.html). Viene creata anche un’operazione pianificata con una pianificazione ricorrente utilizzando un’espressione Cron. Il fuso orario per la pianificazione ricorrente è UTC.

In questo esempio vengono utilizzate le funzioni intrinseche `Fn::Join` e `Ref` nella proprietà `RoleARN` per specificare l’ARN del ruolo collegato al servizio. Utilizza la funzione intrinseca `Fn::Sub` per costruire la proprietà `ResourceId` con il nome logico della risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-lambda-function.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-lambda-function.html) o [https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html) specificata nello stesso modello. Per ulteriori informazioni, consulta [Riferimento funzione intrinseca](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference.html).

**Nota**  
Non puoi allocare la simultaneità fornita su un alias che punta alla versione non pubblicata (`$LATEST`).  
Per ulteriori informazioni su come creare un CloudFormation modello per le risorse Lambda, consulta il post di blog [Scheduling AWS Lambda Provisioned Concurrency for recurring](https://aws.amazon.com/blogs/compute/scheduling-aws-lambda-provisioned-concurrency-for-recurring-peak-usage/) peak usage on the Compute Blog. AWS 

### JSON
<a name="quickref-autoscaling-example-11.json"></a>

```
{
  "ScalableTarget" : {
    "Type" : "AWS::ApplicationAutoScaling::ScalableTarget",
    "Properties" : {
      "MaxCapacity" : 250,
      "MinCapacity" : 0,
      "RoleARN" : {
        "Fn::Join" : [
          ":",
          [
            "arn:aws:iam:",
            {
              "Ref" : "AWS::AccountId"
            },
            "role/aws-service-role/lambda.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_LambdaConcurrency"
          ]
        ]
      },
      "ServiceNamespace" : "lambda",
      "ScalableDimension" : "lambda:function:ProvisionedConcurrency",
      "ResourceId" : { "Fn::Sub" : "function:${logicalName}:BLUE" },
      "ScheduledActions" : [
        {
          "ScalableTargetAction" : {
            "MinCapacity" : "250"
          },
          "ScheduledActionName" : "my-scale-out-scheduled-action",
          "Schedule" : "cron(0 18 * * ? *)",
          "EndTime" : "2022-12-31T12:00:00.000Z"
        }
      ]
    }
  }
}
```

### YAML
<a name="quickref-autoscaling-example-11.yaml"></a>

```
ScalableTarget:
  Type: AWS::ApplicationAutoScaling::ScalableTarget
  Properties:
    MaxCapacity: 250
    MinCapacity: 0
    RoleARN: !Join 
      - ':'
      - - 'arn:aws:iam:'
        - !Ref 'AWS::AccountId'
        - role/aws-service-role/lambda.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_LambdaConcurrency
    ServiceNamespace: lambda
    ScalableDimension: lambda:function:ProvisionedConcurrency
    ResourceId: !Sub function:${logicalName}:BLUE
    ScheduledActions:
      - ScalableTargetAction:
          MinCapacity: 250
        ScheduledActionName: my-scale-out-scheduled-action
        Schedule: 'cron(0 18 * * ? *)'
        EndTime: '2022-12-31T12:00:00.000Z'
```

## Creazione di un’operazione pianificata con una espressione `at` per un parco istanze spot
<a name="w2aac11c41c15c19c21"></a>

Questo frammento mostra come creare due azioni pianificate che si verificano una sola volta per una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-spotfleet.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-spotfleet.html) che utilizza la risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalabletarget.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-applicationautoscaling-scalabletarget.html). Il fuso orario per ogni operazione pianificata occasionale è UTC.

Utilizza le funzioni intrinseche `Fn::Join` e `Ref` per costruire la proprietà `ResourceId` con il nome logico della risorsa `AWS::EC2::SpotFleet` specificata nello stesso modello. Per ulteriori informazioni, consulta [Intrinsic function reference](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference.html).

**Nota**  
La richiesta del parco istanze spot deve avere un tipo di richiesta di `maintain`. La scalabilità automatica non è supportata per le richieste una tantum o i blocchi Spot.

### JSON
<a name="quickref-autoscaling-example-12.json"></a>

```
{
  "Resources" : {
    "SpotFleetScalableTarget" : {
      "Type" : "AWS::ApplicationAutoScaling::ScalableTarget",
      "Properties" : {
        "MaxCapacity" : 0,
        "MinCapacity" : 0,
        "RoleARN" : { "Fn::Sub" : "arn:aws:iam::${AWS::AccountId}:role/aws-service-role/ec2.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_EC2SpotFleetRequest" },
        "ServiceNamespace" : "ec2",
        "ScalableDimension" : "ec2:spot-fleet-request:TargetCapacity",
        "ResourceId" : {
          "Fn::Join" : [
            "/",
            [
              "spot-fleet-request",
              {
                "Ref" : "logicalName"
              }
            ]
          ]
        },
        "ScheduledActions" : [
          {
            "ScalableTargetAction" : {
              "MaxCapacity" : "10",
              "MinCapacity" : "10"
            },
            "ScheduledActionName" : "my-scale-out-scheduled-action",
            "Schedule" : "at(2022-05-20T13:00:00)"
          },
          {
            "ScalableTargetAction" : {
              "MaxCapacity" : "0",
              "MinCapacity" : "0"
            },
            "ScheduledActionName" : "my-scale-in-scheduled-action",
            "Schedule" : "at(2022-05-20T21:00:00)"
          }
        ]
      }
    }
  }
}
```

### YAML
<a name="quickref-autoscaling-example-12.yaml"></a>

```
---
Resources:
  SpotFleetScalableTarget:
    Type: AWS::ApplicationAutoScaling::ScalableTarget
    Properties:
      MaxCapacity: 0
      MinCapacity: 0
      RoleARN: 
        Fn::Sub: 'arn:aws:iam::${AWS::AccountId}:role/aws-service-role/ec2.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_EC2SpotFleetRequest'
      ServiceNamespace: ec2
      ScalableDimension: 'ec2:spot-fleet-request:TargetCapacity'
      ResourceId: !Join 
        - /
        - - spot-fleet-request
          - !Ref logicalName
      ScheduledActions:
        - ScalableTargetAction:
            MaxCapacity: 10
            MinCapacity: 10
          ScheduledActionName: my-scale-out-scheduled-action
          Schedule: 'at(2022-05-20T13:00:00)'
        - ScalableTargetAction:
            MaxCapacity: 0
            MinCapacity: 0
          ScheduledActionName: my-scale-in-scheduled-action
          Schedule: 'at(2022-05-20T21:00:00)'
```

# AWS Frammenti di modello della Billing Console
<a name="quickref-billingconductor"></a>

Questo esempio crea un piano tariffario con una regola di determinazione del prezzo di markup globale del 10%. Questo piano tariffario è collegato al gruppo di fatturazione. Il gruppo di fatturazione presenta anche due voci personalizzate che applicano un addebito di \$1 10 e un addebito del 10% oltre al costo totale del gruppo di fatturazione.

## JSON
<a name="quickref-billingconductor-example-1.json"></a>

```
 1. {
 2.    "Parameters": {
 3.       "LinkedAccountIds": {
 4.          "Type": "ListNumber"
 5.       },
 6.       "PrimaryAccountId": {
 7.          "Type": "Number"
 8.       }
 9.    },
10.    "Resources": {
11.       "TestPricingRule": {
12.          "Type": "AWS::BillingConductor::PricingRule",
13.          "Properties": {
14.             "Name": "TestPricingRule",
15.             "Description": "Test pricing rule created through Cloudformation. Mark everything by 10%.",
16.             "Type": "MARKUP",
17.             "Scope": "GLOBAL",
18.             "ModifierPercentage": 10
19.          }
20.       },
21.       "TestPricingPlan": {
22.          "Type": "AWS::BillingConductor::PricingPlan",
23.          "Properties": {
24.             "Name": "TestPricingPlan",
25.             "Description": "Test pricing plan created through Cloudformation.",
26.             "PricingRuleArns": [
27.                {"Fn::GetAtt": ["TestPricingRule", "Arn"]}
28.             ]
29.          }
30.       },
31.       "TestBillingGroup": {
32.          "Type": "AWS::BillingConductor::BillingGroup",
33.          "Properties": {
34.             "Name": "TestBillingGroup",
35.             "Description": "Test billing group created through Cloudformation with 1 linked account. The linked account is also the primary account.",
36.             "PrimaryAccountId": {
37.                "Ref": "PrimaryAccountId"
38.             },
39.             "AccountGrouping": {
40.                "LinkedAccountIds": null
41.             },
42.             "ComputationPreference": {
43.                "PricingPlanArn": {
44.                  "Fn::GetAtt": ["TestPricingPlan", "Arn"]
45.                }
46.             }
47.          }
48.       },
49.       "TestFlatCustomLineItem": {
50.          "Type": "AWS::BillingConductor::CustomLineItem",
51.          "Properties": {
52.             "Name": "TestFlatCustomLineItem",
53.             "Description": "Test flat custom line item created through Cloudformation for a $10 charge.",
54.             "BillingGroupArn": {
55.               "Fn::GetAtt": ["TestBillingGroup", "Arn"]
56.             },
57.             "CustomLineItemChargeDetails": {
58.                "Flat": {
59.                   "ChargeValue": 10
60.                },
61.                "Type": "FEE"
62.             }
63.          }
64.       },
65.       "TestPercentageCustomLineItem": {
66.          "Type": "AWS::BillingConductor::CustomLineItem",
67.          "Properties": {
68.             "Name": "TestPercentageCustomLineItem",
69.             "Description": "Test percentage custom line item created through Cloudformation for a %10 additional charge on the overall total bill of the billing group.",
70.             "BillingGroupArn": {
71.               "Fn::GetAtt": ["TestBillingGroup", "Arn"]
72.             },
73.             "CustomLineItemChargeDetails": {
74.                "Percentage": {
75.                   "PercentageValue": 10,
76.                   "ChildAssociatedResources": [
77.                      {"Fn::GetAtt": ["TestBillingGroup", "Arn"]}
78.                   ]
79.                },
80.                "Type": "FEE"
81.             }
82.          }
83.       }
84.    }
85. }
```

## YAML
<a name="quickref-billingconductor-example-1.yaml"></a>

```
 1. Parameters:
 2.   LinkedAccountIds:
 3.     Type: ListNumber
 4.   PrimaryAccountId:
 5.     Type: Number
 6. Resources:
 7.   TestPricingRule:
 8.     Type: AWS::BillingConductor::PricingRule
 9.     Properties:
10.       Name: 'TestPricingRule'
11.       Description: 'Test pricing rule created through Cloudformation. Mark everything by 10%.'
12.       Type: 'MARKUP'
13.       Scope: 'GLOBAL'
14.       ModifierPercentage: 10
15.   TestPricingPlan:
16.     Type: AWS::BillingConductor::PricingPlan
17.     Properties:
18.       Name: 'TestPricingPlan'
19.       Description: 'Test pricing plan created through Cloudformation.'
20.       PricingRuleArns:
21.         - !GetAtt TestPricingRule.Arn
22.   TestBillingGroup:
23.     Type: AWS::BillingConductor::BillingGroup
24.     Properties:
25.       Name: 'TestBillingGroup'
26.       Description: 'Test billing group created through Cloudformation with 1 linked account. The linked account is also the primary account.'
27.       PrimaryAccountId: !Ref PrimaryAccountId
28.       AccountGrouping:
29.         LinkedAccountIds: !Ref LinkedAccountIds
30.       ComputationPreference:
31.         PricingPlanArn: !GetAtt TestPricingPlan.Arn
32.   TestFlatCustomLineItem:
33.     Type: AWS::BillingConductor::CustomLineItem
34.     Properties:
35.       Name: 'TestFlatCustomLineItem'
36.       Description: 'Test flat custom line item created through Cloudformation for a $10 charge.'
37.       BillingGroupArn: !GetAtt TestBillingGroup.Arn
38.       CustomLineItemChargeDetails:
39.         Flat:
40.           ChargeValue: 10
41.         Type: 'FEE'
42.   TestPercentageCustomLineItem:
43.     Type: AWS::BillingConductor::CustomLineItem
44.     Properties:
45.       Name: 'TestPercentageCustomLineItem'
46.       Description: 'Test percentage custom line item created through Cloudformation for a %10 additional charge on the overall total bill of the billing group.'
47.       BillingGroupArn: !GetAtt TestBillingGroup.Arn
48.       CustomLineItemChargeDetails:
49.         Percentage:
50.           PercentageValue: 10
51.           ChildAssociatedResources:
52.             - !GetAtt TestBillingGroup.Arn
53.         Type: 'FEE'
```

# CloudFormation frammenti di modello
<a name="quickref-cloudformation"></a>

**Topics**
+ [Stack nidificati](#w2aac11c41c23b5)
+ [Condizione di attesa](#w2aac11c41c23b7)

## Stack nidificati
<a name="w2aac11c41c23b5"></a>

### Nidificazione di uno stack in un modello
<a name="scenario-stack"></a>

Questo modello di esempio contiene una risorsa stack nidificata denominata `myStack`. Quando CloudFormation crea uno stack dal modello, crea il`myStack`, il cui modello è specificato nella `TemplateURL` proprietà. Il valore di output `StackRef` restituisce l’ID dello stack per `myStack` e il valore `OutputFromNestedStack` restituisce il valore di output `BucketName` dalla risorsa `myStack`. Il formato `Outputs.nestedstackoutputname` è riservato alla specifica di valori di output dagli stack nidificati e può essere utilizzato ovunque all’interno del modello.

Per ulteriori informazioni, consulta [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-stack.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-stack.html).

#### JSON
<a name="quickref-cloudformation-example-1.json"></a>

```
 1. {
 2.     "AWSTemplateFormatVersion" : "2010-09-09",
 3.     "Resources" : {
 4.         "myStack" : {
 5. 	       "Type" : "AWS::CloudFormation::Stack",
 6. 	       "Properties" : {
 7. 	        "TemplateURL" : "https://s3.amazonaws.com/cloudformation-templates-us-east-1/S3_Bucket.template",
 8.               "TimeoutInMinutes" : "60"
 9. 	       }
10.         }
11.     },
12.     "Outputs": {
13.        "StackRef": {"Value": { "Ref" : "myStack"}},
14.        "OutputFromNestedStack" : {
15.              "Value" : { "Fn::GetAtt" : [ "myStack", "Outputs.BucketName" ] }
16.        }
17.     }
18. }
```

#### YAML
<a name="quickref-cloudformation-example-1.yaml"></a>

```
 1. AWSTemplateFormatVersion: '2010-09-09'
 2. Resources:
 3.   myStack:
 4.     Type: AWS::CloudFormation::Stack
 5.     Properties:
 6.       TemplateURL: https://s3.amazonaws.com/cloudformation-templates-us-east-1/S3_Bucket.template
 7.       TimeoutInMinutes: '60'
 8. Outputs:
 9.   StackRef:
10.     Value: !Ref myStack
11.   OutputFromNestedStack:
12.     Value: !GetAtt myStack.Outputs.BucketName
```

### Nidificazione di un stack con i parametri di input in un modello
<a name="scenario-stack-parameters"></a>

In questo esempio il modello contiene una risorsa di stack che specifica i parametri di input. Quando CloudFormation crea uno stack da questo modello, utilizza le coppie di valori dichiarate all'interno della `Parameters` proprietà come parametri di input per il modello utilizzato per creare lo `myStackWithParams` stack. In questo esempio vengono specificati i parametri `InstanceType` e `KeyName`.

Per ulteriori informazioni, consulta [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-stack.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-stack.html).

#### JSON
<a name="quickref-cloudformation-example-2.json"></a>

```
 1. {
 2.     "AWSTemplateFormatVersion" : "2010-09-09",
 3.     "Resources" : {
 4.         "myStackWithParams" : {
 5.   	       "Type" : "AWS::CloudFormation::Stack",
 6. 	       "Properties" : {
 7. 	           "TemplateURL" : "https://s3.amazonaws.com/cloudformation-templates-us-east-1/EC2ChooseAMI.template",
 8. 	           "Parameters" : {
 9. 	               "InstanceType" : "t2.micro",
10. 	               "KeyName" : "mykey"
11. 	           }
12.    	       }
13.         }
14.     }
15. }
```

#### YAML
<a name="quickref-cloudformation-example-2.yaml"></a>

```
1. AWSTemplateFormatVersion: '2010-09-09'
2. Resources:
3.   myStackWithParams:
4.     Type: AWS::CloudFormation::Stack
5.     Properties:
6.       TemplateURL: https://s3.amazonaws.com/cloudformation-templates-us-east-1/EC2ChooseAMI.template
7.       Parameters:
8.         InstanceType: t2.micro
9.         KeyName: mykey
```

## Condizione di attesa
<a name="w2aac11c41c23b7"></a>

### Utilizzo di una condizione di attesa con un’istanza Amazon EC2
<a name="scenario-waitcondition"></a>

**Importante**  
Per le risorse Amazon EC2 e Auto Scaling, consigliamo di utilizzare CreationPolicy un attributo anziché condizioni di attesa. Aggiungi un CreationPolicy attributo a tali risorse e utilizza lo script di supporto cfn-signal per segnalare quando il processo di creazione di un'istanza è stato completato con successo.

Se non riesci a utilizzare una policy di creazione, puoi visualizzare il seguente modello di esempio, che dichiara un’istanza Amazon EC2 con una condizione di attesa. La condizione di attesa `myWaitCondition` utilizza `myWaitConditionHandle` per le segnalazioni, l’attributo `DependsOn` per specificare che la condizione di attesa si attiverà dopo che la risorsa dell’istanza Amazon EC2 è stata creata e la proprietà `Timeout` per specificare una durata di 4.500 secondi per la condizione di attesa. Inoltre, l’URL prefirmato che segnala la condizione di attesa viene passato all’istanza Amazon EC2 con la proprietà `UserData` della risorsa `Ec2Instance`, consentendo a un’applicazione o a uno script in esecuzione su quell’istanza Amazon EC2 di recuperare l’URL prefirmato e di utilizzarlo per segnalare l’esito positivo o negativo alla condizione di attesa. Devi utilizzare `cfn-signal` o creare l’applicazione o lo script che segnala la condizione di attesa. Il valore di output `ApplicationData` contiene i dati trasferiti dal segnale della condizione di attesa.

Per ulteriori informazioni, consulta [Creare condizioni di attesa in un CloudFormation modello](using-cfn-waitcondition.md).

#### JSON
<a name="quickref-cloudformation-example-3.json"></a>

```
 1. {
 2.     "AWSTemplateFormatVersion" : "2010-09-09",
 3.     "Mappings" : {
 4.         "RegionMap" : {
 5.             "us-east-1" : {
 6.                 "AMI" : "ami-0123456789abcdef0"
 7.             },
 8.             "us-west-1" : {
 9.                 "AMI" : "ami-0987654321fedcba0"
10.             },
11.             "eu-west-1" : {
12.                 "AMI" : "ami-0abcdef123456789a"
13.             },
14.             "ap-northeast-1" : {
15.                 "AMI" : "ami-0fedcba987654321b"
16.             },
17.             "ap-southeast-1" : {
18.                 "AMI" : "ami-0c1d2e3f4a5b6c7d8"
19.             }
20.         }
21.     },
22.     "Resources" : {
23.         "Ec2Instance" : {
24.             "Type" : "AWS::EC2::Instance",
25.             "Properties" : {
26.                 "UserData" : { "Fn::Base64" : {"Ref" : "myWaitHandle"}},
27.                 "ImageId" : { "Fn::FindInMap" : [ "RegionMap", { "Ref" : "AWS::Region" }, "AMI" ]}
28.             }
29.         },
30.         "myWaitHandle" : {
31.             "Type" : "AWS::CloudFormation::WaitConditionHandle",
32.             "Properties" : {
33.             }
34.         },
35.         "myWaitCondition" : {
36.             "Type" : "AWS::CloudFormation::WaitCondition",
37.             "DependsOn" : "Ec2Instance",
38.             "Properties" : {
39.                 "Handle" : { "Ref" : "myWaitHandle" },
40.                 "Timeout" : "4500"
41.             }
42.         }
43.     },
44.     "Outputs" : {
45.         "ApplicationData" : {
46.             "Value" : { "Fn::GetAtt" : [ "myWaitCondition", "Data" ]},
47.             "Description" : "The data passed back as part of signalling the WaitCondition."
48.         }
49.     }
50. }
```

#### YAML
<a name="quickref-cloudformation-example-3.yaml"></a>

```
 1. AWSTemplateFormatVersion: '2010-09-09'
 2. Mappings:
 3.   RegionMap:
 4.     us-east-1:
 5.       AMI: ami-0123456789abcdef0
 6.     us-west-1:
 7.       AMI: ami-0987654321fedcba0
 8.     eu-west-1:
 9.       AMI: ami-0abcdef123456789a
10.     ap-northeast-1:
11.       AMI: ami-0fedcba987654321b
12.     ap-southeast-1:
13.       AMI: ami-0c1d2e3f4a5b6c7d8
14. Resources:
15.   Ec2Instance:
16.     Type: AWS::EC2::Instance
17.     Properties:
18.       UserData:
19.         Fn::Base64: !Ref myWaitHandle
20.       ImageId:
21.         Fn::FindInMap:
22.         - RegionMap
23.         - Ref: AWS::Region
24.         - AMI
25.   myWaitHandle:
26.     Type: AWS::CloudFormation::WaitConditionHandle
27.     Properties: {}
28.   myWaitCondition:
29.     Type: AWS::CloudFormation::WaitCondition
30.     DependsOn: Ec2Instance
31.     Properties:
32.       Handle: !Ref myWaitHandle
33.       Timeout: '4500'
34. Outputs:
35.   ApplicationData:
36.     Value: !GetAtt myWaitCondition.Data
37.     Description: The data passed back as part of signalling the WaitCondition.
```

### Utilizzo dello script helper cfn-signal per segnalare una condizione di attesa
<a name="scenario-waitcondition-cfn-signal"></a>

Nell’esempio seguente viene mostrata una riga di comando `cfn-signal` che segnala l’operazione riuscita di una condizione di attesa. È necessario definire la riga di comando nella proprietà `UserData` dell’istanza EC2.

#### JSON
<a name="w2aac11c41c23b7b4b4"></a>

```
"UserData": {
  "Fn::Base64": {
    "Fn::Join": [
      "", 
      [
         "#!/bin/bash -xe\n",
         "/opt/aws/bin/cfn-signal --exit-code 0 '", 
         {
           "Ref": "myWaitHandle"
         },
         "'\n"
      ]   
    ]
  }
}
```

#### YAML
<a name="w2aac11c41c23b7b4b6"></a>

```
UserData:
  Fn::Base64: !Sub |
    #!/bin/bash -xe
    /opt/aws/bin/cfn-signal --exit-code 0 '${myWaitHandle}'
```

### Utilizzo di Curl per segnalare una condizione di attesa
<a name="scenario-waitcondition-curl"></a>

Nell’esempio seguente viene mostrata una riga di comando Curl che segnala l’operazione riuscita a una condizione di attesa.

```
1. curl -T /tmp/a "https://cloudformation-waitcondition-test.s3.amazonaws.com/arn%3Aaws%3Acloudformation%3Aus-east-1%3A034017226601%3Astack%2Fstack-gosar-20110427004224-test-stack-with-WaitCondition--VEYW%2Fe498ce60-70a1-11e0-81a7-5081d0136786%2FmyWaitConditionHandle?Expires=1303976584&AWSAccessKeyId=AKIAIOSFODNN7EXAMPLE&Signature=ik1twT6hpS4cgNAw7wyOoRejVoo%3D"
```

Dove il file /tmp/a contiene la seguente struttura JSON:

```
1. {
2.   "Status" : "SUCCESS",
3.   "Reason" : "Configuration Complete",
4.   "UniqueId" : "ID1234",
5.   "Data" : "Application has completed configuration."
6. }
```

In questo esempio viene mostrata una riga di comando Curl che invia lo stesso segnale di operazione riuscita, con la differenza che come parametro invia la struttura JSON sulla riga di comando.

```
1. curl -X PUT -H 'Content-Type:' --data-binary '{"Status" : "SUCCESS","Reason" : "Configuration Complete","UniqueId" : "ID1234","Data" : "Application has completed configuration."}' "https://cloudformation-waitcondition-test.s3.amazonaws.com/arn%3Aaws%3Acloudformation%3Aus-east-1%3A034017226601%3Astack%2Fstack-gosar-20110427004224-test-stack-with-WaitCondition--VEYW%2Fe498ce60-70a1-11e0-81a7-5081d0136786%2FmyWaitConditionHandle?Expires=1303976584&AWSAccessKeyId=AKIAIOSFODNN7EXAMPLE&Signature=ik1twT6hpS4cgNAw7wyOoRejVoo%3D"
```

# Frammenti CloudFront di modello Amazon
<a name="quickref-cloudfront"></a>

Usa questi frammenti di modello di esempio con la tua risorsa di CloudFront distribuzione Amazon in. CloudFormation Per ulteriori informazioni, consulta il [riferimento ai tipi di CloudFront risorse Amazon](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/AWS_CloudFront.html).

**Topics**
+ [Risorsa di CloudFront distribuzione Amazon con origine Amazon S3](#scenario-cloudfront-s3origin)
+ [Risorsa CloudFront di distribuzione Amazon con origine personalizzata](#scenario-cloudfront-customorigin)
+ [CloudFront Distribuzione Amazon con supporto multiorigine](#scenario-cloudfront-multiorigin)
+ [CloudFront Distribuzione Amazon con una funzione Lambda come origine](#scenario-cloudfront-lambda-origin)
+ [Consulta anche](#w2aac11c41c27c15)

## Risorsa di CloudFront distribuzione Amazon con origine Amazon S3
<a name="scenario-cloudfront-s3origin"></a>

Il seguente modello di esempio mostra una CloudFront [distribuzione](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudfront-distribution.html) Amazon che utilizza un [S3Origin e una legacy Origin](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-cloudfront-distribution-s3originconfig.html) Access Identity (OAI). Per informazioni sull'utilizzo del controllo dell'accesso all'origine (OAC), consulta [Restricting access to an Amazon Simple Storage Service origin (Limitazione dell'accesso a un'origine di Amazon Simple Storage Service](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/private-content-restricting-access-to-s3.html)) nella *Amazon CloudFront Developer Guide*.

### JSON
<a name="quickref-cloudfront-example-1.json"></a>

```
 1. {
 2.     "AWSTemplateFormatVersion" : "2010-09-09",
 3.     "Resources" : {
 4.         "myDistribution" : {
 5.             "Type" : "AWS::CloudFront::Distribution",
 6.             "Properties" : {
 7.                 "DistributionConfig" : {
 8.                     "Origins" : [ {
 9.                         "DomainName" : "amzn-s3-demo-bucket.s3.amazonaws.com",
10.                         "Id" : "myS3Origin",
11.                         "S3OriginConfig" : {
12.                             "OriginAccessIdentity" : "origin-access-identity/cloudfront/E127EXAMPLE51Z"
13.                         }
14.                     }],
15.                     "Enabled" : "true",
16.                     "Comment" : "Some comment",
17.                     "DefaultRootObject" : "index.html",
18.                     "Logging" : {
19.                         "IncludeCookies" : "false",
20.                         "Bucket" : "amzn-s3-demo-logging-bucket.s3.amazonaws.com",
21.                         "Prefix" : "myprefix"
22.                     },
23.                     "Aliases" : [ "mysite.example.com", "yoursite.example.com" ],
24.                     "DefaultCacheBehavior" : {
25.                         "AllowedMethods" : [ "DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT" ],  
26.                         "TargetOriginId" : "myS3Origin",
27.                         "ForwardedValues" : {
28.                             "QueryString" : "false",
29.                             "Cookies" : { "Forward" : "none" }
30.                         },
31.                         "TrustedSigners" : [ "1234567890EX", "1234567891EX" ],
32.                         "ViewerProtocolPolicy" : "allow-all"
33.                     },
34.                    "PriceClass" : "PriceClass_200",
35.                    "Restrictions" : {
36.                        "GeoRestriction" : {
37.                            "RestrictionType" : "whitelist",
38.                            "Locations" : [ "AQ", "CV" ]
39.                        }
40.                    },
41.                    "ViewerCertificate" : { "CloudFrontDefaultCertificate" : "true" }  
42.                 }
43.             }
44.         }
45.     }
46. }
```

### YAML
<a name="quickref-cloudfront-example-1.yaml"></a>

```
 1. AWSTemplateFormatVersion: '2010-09-09'
 2. Resources:
 3.   myDistribution:
 4.     Type: AWS::CloudFront::Distribution
 5.     Properties:
 6.       DistributionConfig:
 7.         Origins:
 8.         - DomainName: amzn-s3-demo-bucket.s3.amazonaws.com
 9.           Id: myS3Origin
10.           S3OriginConfig:
11.             OriginAccessIdentity: origin-access-identity/cloudfront/E127EXAMPLE51Z
12.         Enabled: 'true'
13.         Comment: Some comment
14.         DefaultRootObject: index.html
15.         Logging:
16.           IncludeCookies: 'false'
17.           Bucket: amzn-s3-demo-logging-bucket.s3.amazonaws.com
18.           Prefix: myprefix
19.         Aliases:
20.         - mysite.example.com
21.         - yoursite.example.com
22.         DefaultCacheBehavior:
23.           AllowedMethods:
24.           - DELETE
25.           - GET
26.           - HEAD
27.           - OPTIONS
28.           - PATCH
29.           - POST
30.           - PUT
31.           TargetOriginId: myS3Origin
32.           ForwardedValues:
33.             QueryString: 'false'
34.             Cookies:
35.               Forward: none
36.           TrustedSigners:
37.           - 1234567890EX
38.           - 1234567891EX
39.           ViewerProtocolPolicy: allow-all
40.         PriceClass: PriceClass_200
41.         Restrictions:
42.           GeoRestriction:
43.             RestrictionType: whitelist
44.             Locations:
45.             - AQ
46.             - CV
47.         ViewerCertificate:
48.           CloudFrontDefaultCertificate: 'true'
```

## Risorsa CloudFront di distribuzione Amazon con origine personalizzata
<a name="scenario-cloudfront-customorigin"></a>

Il seguente modello di esempio mostra una CloudFront [distribuzione](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudfront-distribution.html) Amazon che utilizza un [CustomOrigin](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-cloudfront-distribution-customoriginconfig.html).

### JSON
<a name="quickref-cloudfront-example-2.json"></a>

```
 1. {
 2.     "AWSTemplateFormatVersion" : "2010-09-09",
 3.     "Resources" : {
 4.         "myDistribution" : {
 5.             "Type" : "AWS::CloudFront::Distribution",
 6.             "Properties" : {
 7.                 "DistributionConfig" : {
 8.                     "Origins" : [ {
 9.                             "DomainName" : "www.example.com",
10.                             "Id" : "myCustomOrigin",
11.                             "CustomOriginConfig" : {
12.                                 "HTTPPort" : "80",
13.                                 "HTTPSPort" : "443",
14.                                 "OriginProtocolPolicy" : "http-only"
15.                             }
16.                     } ],
17.                     "Enabled" : "true",
18.                     "Comment" : "Somecomment",
19.                     "DefaultRootObject" : "index.html",
20.                     "Logging" : {
21.                         "IncludeCookies" : "true",
22.                         "Bucket" : "amzn-s3-demo-logging-bucket.s3.amazonaws.com",
23.                         "Prefix": "myprefix"
24.                     },
25.                     "Aliases" : [
26.                         "mysite.example.com",
27.                         "*.yoursite.example.com"
28.                     ],
29.                     "DefaultCacheBehavior" : {
30.                         "TargetOriginId" : "myCustomOrigin",
31.                         "SmoothStreaming" : "false",  
32.                         "ForwardedValues" : {
33.                             "QueryString" : "false",
34.                             "Cookies" : { "Forward" : "all" }
35.                         },
36.                         "TrustedSigners" : [
37.                             "1234567890EX",
38.                             "1234567891EX"
39.                         ],
40.                         "ViewerProtocolPolicy" : "allow-all"
41.                     },
42.                     "CustomErrorResponses" : [ {
43.                         "ErrorCode" : "404",
44.                         "ResponsePagePath" : "/error-pages/404.html",
45.                         "ResponseCode" : "200",
46.                         "ErrorCachingMinTTL" : "30"
47.                     } ],
48.                    "PriceClass" : "PriceClass_200",
49.                    "Restrictions" : {
50.                        "GeoRestriction" : {
51.                            "RestrictionType" : "whitelist",
52.                            "Locations" : [ "AQ", "CV" ]
53.                        }
54.                    },
55.                    "ViewerCertificate": { "CloudFrontDefaultCertificate" : "true" }
56.                 }
57.             }
58.         }
59.     }
60. }
```

### YAML
<a name="quickref-cloudfront-example-2.yaml"></a>

```
 1. AWSTemplateFormatVersion: '2010-09-09'
 2. Resources:
 3.   myDistribution:
 4.     Type: AWS::CloudFront::Distribution
 5.     Properties:
 6.       DistributionConfig:
 7.         Origins:
 8.         - DomainName: www.example.com
 9.           Id: myCustomOrigin
10.           CustomOriginConfig:
11.             HTTPPort: '80'
12.             HTTPSPort: '443'
13.             OriginProtocolPolicy: http-only
14.         Enabled: 'true'
15.         Comment: Somecomment
16.         DefaultRootObject: index.html
17.         Logging:
18.           IncludeCookies: 'true'
19.           Bucket: amzn-s3-demo-logging-bucket.s3.amazonaws.com
20.           Prefix: myprefix
21.         Aliases:
22.         - mysite.example.com
23.         - "*.yoursite.example.com"
24.         DefaultCacheBehavior:
25.           TargetOriginId: myCustomOrigin
26.           SmoothStreaming: 'false'
27.           ForwardedValues:
28.             QueryString: 'false'
29.             Cookies:
30.               Forward: all
31.           TrustedSigners:
32.           - 1234567890EX
33.           - 1234567891EX
34.           ViewerProtocolPolicy: allow-all
35.         CustomErrorResponses:
36.         - ErrorCode: '404'
37.           ResponsePagePath: "/error-pages/404.html"
38.           ResponseCode: '200'
39.           ErrorCachingMinTTL: '30'
40.         PriceClass: PriceClass_200
41.         Restrictions:
42.           GeoRestriction:
43.             RestrictionType: whitelist
44.             Locations:
45.             - AQ
46.             - CV
47.         ViewerCertificate:
48.           CloudFrontDefaultCertificate: 'true'
```

## CloudFront Distribuzione Amazon con supporto multiorigine
<a name="scenario-cloudfront-multiorigin"></a>

Il seguente modello di esempio mostra come dichiarare una CloudFront [distribuzione con supporto](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudfront-distribution.html) multiorigine. In [DistributionConfig](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-cloudfront-distribution-distributionconfig.html), viene fornito un elenco di origini e viene impostato un [DefaultCacheBehavior](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-cloudfront-distribution-defaultcachebehavior.html).

### JSON
<a name="quickref-cloudfront-example-3.json"></a>

```
{
    "AWSTemplateFormatVersion" : "2010-09-09",
    "Resources" : {
        "myDistribution" : {
            "Type" : "AWS::CloudFront::Distribution",
            "Properties" : {
                "DistributionConfig" : {
                    "Origins" : [ {
                        "Id" : "myS3Origin",
                        "DomainName" : "amzn-s3-demo-bucket.s3.amazonaws.com",
                        "S3OriginConfig" : {
                            "OriginAccessIdentity" : "origin-access-identity/cloudfront/E127EXAMPLE51Z"
                        }
                     }, 
                     {
                         "Id" : "myCustomOrigin",
                         "DomainName" : "www.example.com",
                         "CustomOriginConfig" : {
                             "HTTPPort" : "80",
                             "HTTPSPort" : "443",
                             "OriginProtocolPolicy" : "http-only"
                         }
                     }
                   ],
                   "Enabled" : "true",
                   "Comment" : "Some comment",
                   "DefaultRootObject" : "index.html", 
                   "Logging" : {
                       "IncludeCookies" : "true",
                       "Bucket" : "amzn-s3-demo-logging-bucket.s3.amazonaws.com",
                       "Prefix" : "myprefix"
                   },            
                   "Aliases" : [ "mysite.example.com", "yoursite.example.com" ],
                   "DefaultCacheBehavior" : {
                       "TargetOriginId" : "myS3Origin",
                       "ForwardedValues" : {
                           "QueryString" : "false",
                           "Cookies" : { "Forward" : "all" }
                        },
                       "TrustedSigners" : [ "1234567890EX", "1234567891EX"  ],
                       "ViewerProtocolPolicy" : "allow-all",
                       "MinTTL" : "100",
                       "SmoothStreaming" : "true"
                   },
                   "CacheBehaviors" : [ {
                            "AllowedMethods" : [ "DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT" ],  
                            "TargetOriginId" : "myS3Origin",
                            "ForwardedValues" : {
                                "QueryString" : "true",
                                "Cookies" : { "Forward" : "none" }
                            },
                            "TrustedSigners" : [ "1234567890EX", "1234567891EX" ],
                            "ViewerProtocolPolicy" : "allow-all",
                            "MinTTL" : "50",
                            "PathPattern" : "images1/*.jpg"
                        }, 
                        {
                            "AllowedMethods" : [ "DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT" ],  
                            "TargetOriginId" : "myCustomOrigin",
                            "ForwardedValues" : {
                                "QueryString" : "true",
                                "Cookies" : { "Forward" : "none" }
                            },
                            "TrustedSigners" : [ "1234567890EX", "1234567891EX"  ],
                            "ViewerProtocolPolicy" : "allow-all",
                            "MinTTL" : "50",
                            "PathPattern" : "images2/*.jpg"
                        }
                   ],
                   "CustomErrorResponses" : [ {
                       "ErrorCode" : "404",
                       "ResponsePagePath" : "/error-pages/404.html",
                       "ResponseCode" : "200",
                       "ErrorCachingMinTTL" : "30"
                   } ],
                   "PriceClass" : "PriceClass_All",
                   "ViewerCertificate" : { "CloudFrontDefaultCertificate" : "true" }
                }
            }
        }
    }
}
```

### YAML
<a name="quickref-cloudfront-example-3.yaml"></a>

```
AWSTemplateFormatVersion: '2010-09-09'
Resources:
  myDistribution:
    Type: AWS::CloudFront::Distribution
    Properties:
      DistributionConfig:
        Origins:
        - Id: myS3Origin
          DomainName: amzn-s3-demo-bucket.s3.amazonaws.com
          S3OriginConfig:
            OriginAccessIdentity: origin-access-identity/cloudfront/E127EXAMPLE51Z
        - Id: myCustomOrigin
          DomainName: www.example.com
          CustomOriginConfig:
            HTTPPort: '80'
            HTTPSPort: '443'
            OriginProtocolPolicy: http-only
        Enabled: 'true'
        Comment: Some comment
        DefaultRootObject: index.html
        Logging:
          IncludeCookies: 'true'
          Bucket: amzn-s3-demo-logging-bucket.s3.amazonaws.com
          Prefix: myprefix
        Aliases:
        - mysite.example.com
        - yoursite.example.com
        DefaultCacheBehavior:
          TargetOriginId: myS3Origin
          ForwardedValues:
            QueryString: 'false'
            Cookies:
              Forward: all
          TrustedSigners:
          - 1234567890EX
          - 1234567891EX
          ViewerProtocolPolicy: allow-all
          MinTTL: '100'
          SmoothStreaming: 'true'
        CacheBehaviors:
        - AllowedMethods:
          - DELETE
          - GET
          - HEAD
          - OPTIONS
          - PATCH
          - POST
          - PUT
          TargetOriginId: myS3Origin
          ForwardedValues:
            QueryString: 'true'
            Cookies:
              Forward: none
          TrustedSigners:
          - 1234567890EX
          - 1234567891EX
          ViewerProtocolPolicy: allow-all
          MinTTL: '50'
          PathPattern: images1/*.jpg
        - AllowedMethods:
          - DELETE
          - GET
          - HEAD
          - OPTIONS
          - PATCH
          - POST
          - PUT
          TargetOriginId: myCustomOrigin
          ForwardedValues:
            QueryString: 'true'
            Cookies:
              Forward: none
          TrustedSigners:
          - 1234567890EX
          - 1234567891EX
          ViewerProtocolPolicy: allow-all
          MinTTL: '50'
          PathPattern: images2/*.jpg
        CustomErrorResponses:
        - ErrorCode: '404'
          ResponsePagePath: "/error-pages/404.html"
          ResponseCode: '200'
          ErrorCachingMinTTL: '30'
        PriceClass: PriceClass_All
        ViewerCertificate:
          CloudFrontDefaultCertificate: 'true'
```

## CloudFront Distribuzione Amazon con una funzione Lambda come origine
<a name="scenario-cloudfront-lambda-origin"></a>

L'esempio seguente crea una CloudFront distribuzione che fronteggia l'URL di una funzione Lambda specificato (fornito come parametro), abilitando l'accesso, la memorizzazione nella cache, la compressione e la consegna globale solo tramite HTTPS. Configura l'URL Lambda come origine HTTPS personalizzata e applica una politica di memorizzazione nella cache AWS standard. La distribuzione è ottimizzata per le prestazioni con HTTP/2 e IPv6 supporta e restituisce il nome di CloudFront dominio, consentendo agli utenti di accedere alla funzione Lambda tramite un endpoint sicuro supportato da CDN. Per ulteriori informazioni, consulta [Usare Amazon CloudFront with AWS Lambda as origin per accelerare le tue applicazioni web](https://aws.amazon.com/blogs/networking-and-content-delivery/using-amazon-cloudfront-with-aws-lambda-as-origin-to-accelerate-your-web-applications/) sul AWS blog.

### JSON
<a name="quickref-cloudfront-example-lambda-origin.json"></a>

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Parameters": {
        "LambdaEndpoint": {
            "Type": "String",
            "Description": "The Lambda function URL endpoint without the 'https://'"
        }
    },
    "Resources": {
        "MyDistribution": {
            "Type": "AWS::CloudFront::Distribution",
            "Properties": {
                "DistributionConfig": {
                    "PriceClass": "PriceClass_All",
                    "HttpVersion": "http2",
                    "IPV6Enabled": true,
                    "Origins": [
                        {
                            "DomainName": {
                                "Ref": "LambdaEndpoint"
                            },
                            "Id": "LambdaOrigin",
                            "CustomOriginConfig": {
                                "HTTPSPort": 443,
                                "OriginProtocolPolicy": "https-only"
                            }
                        }
                    ],
                    "Enabled": "true",
                    "DefaultCacheBehavior": {
                        "TargetOriginId": "LambdaOrigin",
                        "CachePolicyId": "658327ea-f89d-4fab-a63d-7e88639e58f6",
                        "ViewerProtocolPolicy": "redirect-to-https",
                        "SmoothStreaming": "false",
                        "Compress": "true"
                    }
                }
            }
        }
    },
    "Outputs": {
        "CloudFrontDomain": {
            "Description": "CloudFront default domain name configured",
            "Value": {
                "Fn::Sub": "https://${MyDistribution.DomainName}/"
            }
        }
    }
}
```

### YAML
<a name="quickref-cloudfront-example-lambda-origin.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
Parameters:
  LambdaEndpoint:
    Type: String
    Description: The Lambda function URL endpoint without the 'https://'
Resources:
  MyDistribution:
    Type: AWS::CloudFront::Distribution
    Properties:
      DistributionConfig:
        PriceClass: PriceClass_All
        HttpVersion: http2
        IPV6Enabled: true
        Origins:
        - DomainName: !Ref LambdaEndpoint
          Id: LambdaOrigin
          CustomOriginConfig:
            HTTPSPort: 443
            OriginProtocolPolicy: https-only
        Enabled: 'true'
        DefaultCacheBehavior:
          TargetOriginId: LambdaOrigin
          CachePolicyId: '658327ea-f89d-4fab-a63d-7e88639e58f6'
          ViewerProtocolPolicy: redirect-to-https
          SmoothStreaming: 'false'
          Compress: 'true'
Outputs:
  CloudFrontDomain:
    Description: CloudFront default domain name configured
    Value: !Sub https://${MyDistribution.DomainName}/
```

## Consulta anche
<a name="w2aac11c41c27c15"></a>

Per un esempio di aggiunta di un alias personalizzato a un record di Route 53 per creare un nome descrittivo per una CloudFront distribuzione, consulta[Alias: record di risorse impostato per una distribuzione CloudFront](quickref-route53.md#scenario-user-friendly-url-for-cloudfront-distribution).

# Frammenti CloudWatch di modello Amazon
<a name="quickref-cloudwatch"></a>

Usa questi frammenti di modello di esempio per descrivere le tue CloudWatch risorse Amazon in. CloudFormation Per ulteriori informazioni, consulta il [riferimento ai tipi di CloudWatch risorse Amazon](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/AWS_CloudWatch.html).

**Topics**
+ [Allarme di fatturazione](#cloudwatch-sample-billing-alarm)
+ [Allarme di utilizzo della CPU](#cloudwatch-sample-cpu-utilization-alarm)
+ [Ripristino di un’istanza Amazon Elastic Compute Cloud](#cloudwatch-sample-recover-instance)
+ [Creazione di un pannello di controllo di base](#cloudwatch-sample-dashboard-basic)
+ [Crea una dashboard con widget side-by-side](#cloudwatch-sample-dashboard-sidebyside)

## Allarme di fatturazione
<a name="cloudwatch-sample-billing-alarm"></a>

Nel seguente esempio, Amazon CloudWatch invia una notifica via e-mail quando gli addebiti AWS sul tuo account superano la soglia di allarme. Per ricevere notifiche di utilizzo, abilita avvisi di fatturazione. Per ulteriori informazioni, consulta [Creare un allarme di fatturazione per monitorare i AWS costi stimati](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/monitor_estimated_charges_with_cloudwatch.html) nella *Amazon CloudWatch User Guide*. >

### JSON
<a name="quickref-cloudwatch-example-1.json"></a>

```
"SpendingAlarm": {
  "Type": "AWS::CloudWatch::Alarm",
  "Properties": {
    "AlarmDescription": { "Fn::Join": ["", [
      "Alarm if AWS spending is over $",
      { "Ref": "AlarmThreshold" }
    ]]},
    "Namespace": "AWS/Billing",
    "MetricName": "EstimatedCharges",
    "Dimensions": [{
      "Name": "Currency",
      "Value" : "USD"
    }],
    "Statistic": "Maximum",
    "Period": "21600",
    "EvaluationPeriods": "1",
    "Threshold": { "Ref": "AlarmThreshold" },
    "ComparisonOperator": "GreaterThanThreshold",
    "AlarmActions": [{
      "Ref": "BillingAlarmNotification"
    }],
    "InsufficientDataActions": [{
      "Ref": "BillingAlarmNotification"
    }]
  }
}
```

### YAML
<a name="quickref-cloudwatch-example-1.yaml"></a>

```
SpendingAlarm:
  Type: AWS::CloudWatch::Alarm
  Properties:
    AlarmDescription: 
      'Fn::Join':
        - ''
        - - Alarm if AWS spending is over $
          - !Ref: AlarmThreshold
    Namespace: AWS/Billing
    MetricName: EstimatedCharges
    Dimensions:
    - Name: Currency
      Value: USD
    Statistic: Maximum
    Period: '21600'
    EvaluationPeriods: '1'
    Threshold:
      !Ref: "AlarmThreshold"
    ComparisonOperator: GreaterThanThreshold
    AlarmActions:
    - !Ref: "BillingAlarmNotification"
    InsufficientDataActions:
    - !Ref: "BillingAlarmNotification"
```

## Allarme di utilizzo della CPU
<a name="cloudwatch-sample-cpu-utilization-alarm"></a>

Nel seguente frammento di codice viene creato un allarme che invia una notifica quando l’utilizzo medio CPU di un’istanza Amazon EC2 supera il 90% per più di 60 secondi su tre periodi di valutazione.

### JSON
<a name="quickref-cloudwatch-example-2.json"></a>

```
 1. "CPUAlarm" : {
 2.   "Type" : "AWS::CloudWatch::Alarm",
 3.   "Properties" : {
 4.     "AlarmDescription" : "CPU alarm for my instance",
 5.     "AlarmActions" : [ { "Ref" : "logical name of an AWS::SNS::Topic resource" } ],
 6.     "MetricName" : "CPUUtilization",
 7.     "Namespace" : "AWS/EC2",
 8.     "Statistic" : "Average",
 9.     "Period" : "60",
10.     "EvaluationPeriods" : "3",
11.     "Threshold" : "90",
12.     "ComparisonOperator" : "GreaterThanThreshold",
13.     "Dimensions" : [ {
14.       "Name" : "InstanceId",
15.       "Value" : { "Ref" : "logical name of an AWS::EC2::Instance resource" }
16.     } ]
17.   }
18. }
```

### YAML
<a name="quickref-cloudwatch-example-2.yaml"></a>

```
 1. CPUAlarm:
 2.   Type: AWS::CloudWatch::Alarm
 3.   Properties:
 4.     AlarmDescription: CPU alarm for my instance
 5.     AlarmActions:
 6.     - !Ref: "logical name of an AWS::SNS::Topic resource"
 7.     MetricName: CPUUtilization
 8.     Namespace: AWS/EC2
 9.     Statistic: Average
10.     Period: '60'
11.     EvaluationPeriods: '3'
12.     Threshold: '90'
13.     ComparisonOperator: GreaterThanThreshold
14.     Dimensions:
15.     - Name: InstanceId
16.       Value: !Ref: "logical name of an AWS::EC2::Instance resource"
```

## Ripristino di un’istanza Amazon Elastic Compute Cloud
<a name="cloudwatch-sample-recover-instance"></a>

Il seguente CloudWatch allarme ripristina un'istanza EC2 quando presenta errori di controllo dello stato per 15 minuti consecutivi. *Per ulteriori informazioni sulle azioni relative agli allarmi, consulta la sezione [Create alarms to stop, terminate, reboot or recovery a EC2 nella](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/UsingAlarmActions.html) Amazon User Guide. CloudWatch *

### JSON
<a name="quickref-cloudwatch-example-3.json"></a>

```
{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Parameters" : {
    "RecoveryInstance" : {
      "Description" : "The EC2 instance ID to associate this alarm with.",
      "Type" : "AWS::EC2::Instance::Id"
    }
  },
  "Resources": {
    "RecoveryTestAlarm": {
      "Type": "AWS::CloudWatch::Alarm",
      "Properties": {
        "AlarmDescription": "Trigger a recovery when instance status check fails for 15 consecutive minutes.",
        "Namespace": "AWS/EC2" ,
        "MetricName": "StatusCheckFailed_System",
        "Statistic": "Minimum",
        "Period": "60",
        "EvaluationPeriods": "15",
        "ComparisonOperator": "GreaterThanThreshold",
        "Threshold": "0",
        "AlarmActions": [ {"Fn::Join" : ["", ["arn:aws:automate:", { "Ref" : "AWS::Region" }, ":ec2:recover" ]]} ],
        "Dimensions": [{"Name": "InstanceId","Value": {"Ref": "RecoveryInstance"}}]
      }
    }
  }
}
```

### YAML
<a name="quickref-cloudwatch-example-3.yaml"></a>

```
AWSTemplateFormatVersion: '2010-09-09'
Parameters:
  RecoveryInstance:
    Description: The EC2 instance ID to associate this alarm with.
    Type: AWS::EC2::Instance::Id
Resources:
  RecoveryTestAlarm:
    Type: AWS::CloudWatch::Alarm
    Properties:
      AlarmDescription: Trigger a recovery when instance status check fails for 15
        consecutive minutes.
      Namespace: AWS/EC2
      MetricName: StatusCheckFailed_System
      Statistic: Minimum
      Period: '60'
      EvaluationPeriods: '15'
      ComparisonOperator: GreaterThanThreshold
      Threshold: '0'
      AlarmActions: [ !Sub "arn:aws:automate:${AWS::Region}:ec2:recover" ]
      Dimensions:
      - Name: InstanceId
        Value: !Ref: RecoveryInstance
```

## Creazione di un pannello di controllo di base
<a name="cloudwatch-sample-dashboard-basic"></a>

L'esempio seguente crea una CloudWatch dashboard semplice con un widget metrico che mostra l'utilizzo della CPU e un widget di testo che mostra un messaggio.

### JSON
<a name="quickref-cloudwatch-sample-dashboard-basic.json"></a>

```
{
    "BasicDashboard": {
        "Type": "AWS::CloudWatch::Dashboard",
        "Properties": {
            "DashboardName": "Dashboard1",
            "DashboardBody": "{\"widgets\":[{\"type\":\"metric\",\"x\":0,\"y\":0,\"width\":12,\"height\":6,\"properties\":{\"metrics\":[[\"AWS/EC2\",\"CPUUtilization\",\"InstanceId\",\"i-012345\"]],\"period\":300,\"stat\":\"Average\",\"region\":\"us-east-1\",\"title\":\"EC2 Instance CPU\"}},{\"type\":\"text\",\"x\":0,\"y\":7,\"width\":3,\"height\":3,\"properties\":{\"markdown\":\"Hello world\"}}]}"
        }
    }
}
```

### YAML
<a name="quickref-cloudwatch-sample-dashboard-basic.yaml"></a>

```
BasicDashboard:
  Type: AWS::CloudWatch::Dashboard
  Properties:
    DashboardName: Dashboard1
    DashboardBody: '{"widgets":[{"type":"metric","x":0,"y":0,"width":12,"height":6,"properties":{"metrics":[["AWS/EC2","CPUUtilization","InstanceId","i-012345"]],"period":300,"stat":"Average","region":"us-east-1","title":"EC2 Instance CPU"}},{"type":"text","x":0,"y":7,"width":3,"height":3,"properties":{"markdown":"Hello world"}}]}'
```

## Crea una dashboard con widget side-by-side
<a name="cloudwatch-sample-dashboard-sidebyside"></a>

Nell’esempio seguente viene creato un pannello di controllo con due widget parametro visualizzati affiancati.

### JSON
<a name="quickref-cloudwatch-sample-dashboard-sidebyside.json"></a>

```
{
    "DashboardSideBySide": {
        "Type": "AWS::CloudWatch::Dashboard",
        "Properties": {
            "DashboardName": "Dashboard1",
            "DashboardBody": "{\"widgets\":[{\"type\":\"metric\",\"x\":0,\"y\":0,\"width\":12,\"height\":6,\"properties\":{\"metrics\":[[\"AWS/EC2\",\"CPUUtilization\",\"InstanceId\",\"i-012345\"]],\"period\":300,\"stat\":\"Average\",\"region\":\"us-east-1\",\"title\":\"EC2 Instance CPU\"}},{\"type\":\"metric\",\"x\":12,\"y\":0,\"width\":12,\"height\":6,\"properties\":{\"metrics\":[[\"AWS/S3\",\"BucketSizeBytes\",\"BucketName\",\"amzn-s3-demo-bucket\"]],\"period\":86400,\"stat\":\"Maximum\",\"region\":\"us-east-1\",\"title\":\"amzn-s3-demo-bucket bytes\"}}]}"
        }
    }
}
```

### YAML
<a name="quickref-cloudwatch-sample-dashboard-sidebysidequickref-cloudwatch-sample-dashboard-sidebyside.yaml"></a>

```
DashboardSideBySide:
  Type: AWS::CloudWatch::Dashboard
  Properties:
    DashboardName: Dashboard1
    DashboardBody: '{"widgets":[{"type":"metric","x":0,"y":0,"width":12,"height":6,"properties":{"metrics":[["AWS/EC2","CPUUtilization","InstanceId","i-012345"]],"period":300,"stat":"Average","region":"us-east-1","title":"EC2 Instance CPU"}},{"type":"metric","x":12,"y":0,"width":12,"height":6,"properties":{"metrics":[["AWS/S3","BucketSizeBytes","BucketName","amzn-s3-demo-bucket"]],"period":86400,"stat":"Maximum","region":"us-east-1","title":"amzn-s3-demo-bucket bytes"}}]}'
```

# Frammenti di modello Amazon CloudWatch Logs
<a name="quickref-cloudwatchlogs"></a>

Amazon CloudWatch Logs può monitorare il sistema, l'applicazione e i file di log personalizzati da istanze Amazon EC2 o altre fonti. Puoi utilizzarlo CloudFormation per fornire e gestire gruppi di log e filtri metrici. Per ulteriori informazioni su Amazon CloudWatch Logs, consulta la [Amazon CloudWatch Logs User Guide.](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/WhatIsCloudWatchLogs.html)

**Topics**
+ [Invia log a Logs da un' CloudWatch istanza Linux](#quickref-cloudwatchlogs-example1)
+ [Invia i log a Logs da un'istanza di Windows CloudWatch](#quickref-cloudwatchlogs-example2)
+ [Consulta anche](#w2aac11c41c35c11)

## Invia log a Logs da un' CloudWatch istanza Linux
<a name="quickref-cloudwatchlogs-example1"></a>

Il modello seguente mostra come configurare un server Web su Amazon Linux 2023 con l'integrazione di CloudWatch Logs. Il modello effettua le seguenti attività:
+ Installa Apache e PHP.
+ Configura l' CloudWatch agente per inoltrare i log di accesso di Apache a Logs. CloudWatch 
+ Imposta un ruolo IAM per consentire all' CloudWatch agente di inviare i dati di registro a Logs. CloudWatch 
+ Crea notifiche e allarmi personalizzati per monitorare gli errori 404 o l’utilizzo elevato della larghezza di banda.

Gli eventi di registro dal server Web forniscono dati metrici per gli CloudWatch allarmi. I due filtri metrici descrivono come le informazioni di registro vengono trasformate in metriche. CloudWatch Il parametro 404 conta il numero di occorrenze 404. Il parametro delle dimensioni monitora le dimensioni di una richiesta. I due CloudWatch allarmi invieranno notifiche se ci sono più di due 404 entro 2 minuti o se la dimensione media della richiesta supera i 3500 KB nell'arco di 10 minuti.

### JSON
<a name="quickref-cloudwatchlogs-example.json"></a>

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Description": "Sample template that sets up and configures CloudWatch Logs on Amazon Linux 2023 instance.",
    "Parameters": {
        "KeyName": {
            "Description": "Name of an existing EC2 KeyPair to enable SSH access to the instances",
            "Type": "AWS::EC2::KeyPair::KeyName",
            "ConstraintDescription": "must be the name of an existing EC2 KeyPair."
        },
        "SSHLocation": {
            "Description": "The IP address range that can be used to SSH to the EC2 instances",
            "Type": "String",
            "MinLength": "9",
            "MaxLength": "18",
            "Default": "0.0.0.0/0",
            "AllowedPattern": "(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})/(\\d{1,2})",
            "ConstraintDescription": "must be a valid IP CIDR range of the form x.x.x.x/x."
        },
        "OperatorEmail": {
            "Description": "Email address to notify when CloudWatch alarms are triggered (404 errors or high bandwidth usage)",
            "Type": "String"
        }
    },
    "Resources": {
        "LogRole": {
            "Type": "AWS::IAM::Role",
            "Properties": {
                "AssumeRolePolicyDocument": {
                    "Version": "2012-10-17",		 	 	 
                    "Statement": [
                        {
                            "Effect": "Allow",
                            "Principal": {
                                "Service": [
                                    "ec2.amazonaws.com"
                                ]
                            },
                            "Action": [
                                "sts:AssumeRole"
                            ]
                        }
                    ]
                },
                "Path": "/",
                "Policies": [
                    {
                        "PolicyName": "LogRolePolicy",
                        "PolicyDocument": {
                            "Version": "2012-10-17",		 	 	 
                            "Statement": [
                                {
                                    "Effect": "Allow",
                                    "Action": [
                                        "logs:PutLogEvents",
                                        "logs:DescribeLogStreams",
                                        "logs:DescribeLogGroups",
                                        "logs:CreateLogGroup",
                                        "logs:CreateLogStream"
                                    ],
                                    "Resource": "*"
                                }
                            ]
                        }
                    }
                ]
            }
        },
        "LogRoleInstanceProfile": {
            "Type": "AWS::IAM::InstanceProfile",
            "Properties": {
                "Path": "/",
                "Roles": [{"Ref": "LogRole"}]
            }
        },
        "WebServerSecurityGroup": {
            "Type": "AWS::EC2::SecurityGroup",
            "Properties": {
                "GroupDescription": "Enable HTTP access via port 80 and SSH access via port 22",
                "SecurityGroupIngress": [
                    {
                        "IpProtocol": "tcp",
                        "FromPort": 80,
                        "ToPort": 80,
                        "CidrIp": "0.0.0.0/0"
                    },
                    {
                        "IpProtocol": "tcp",
                        "FromPort": 22,
                        "ToPort": 22,
                        "CidrIp": {"Ref": "SSHLocation"}
                    }
                ]
            }
        },
        "WebServerHost": {
            "Type": "AWS::EC2::Instance",
            "Metadata": {
                "Comment": "Install a simple PHP application on Amazon Linux 2023",
                "AWS::CloudFormation::Init": {
                    "config": {
                        "packages": {
                            "dnf": {
                                "httpd": [],
                                "php": [],
                                "php-fpm": []
                            }
                        },
                        "files": {
                            "/etc/amazon-cloudwatch-agent/amazon-cloudwatch-agent.json": {
                                "content": {
                                    "logs": {
                                        "logs_collected": {
                                            "files": {
                                                "collect_list": [{
                                                    "file_path": "/var/log/httpd/access_log",
                                                    "log_group_name": {"Ref": "WebServerLogGroup"},
                                                    "log_stream_name": "{instance_id}/apache.log",
                                                    "timestamp_format": "%d/%b/%Y:%H:%M:%S %z"
                                                }]
                                            }
                                        }
                                    }
                                },
                                "mode": "000644",
                                "owner": "root",
                                "group": "root"
                            },
                            "/var/www/html/index.php": {
                                "content": "<?php\necho '<h1>AWS CloudFormation sample PHP application on Amazon Linux 2023</h1>';\n?>\n",
                                "mode": "000644",
                                "owner": "apache",
                                "group": "apache"
                            },
                            "/etc/cfn/cfn-hup.conf": {
                                "content":  {
                                    "Fn::Join": [
                                        "",
                                        [
                                            "[main]\n",
                                            "stack=",
                                            {"Ref": "AWS::StackId"},
                                            "\n",
                                            "region=",
                                            {"Ref": "AWS::Region"},
                                            "\n"
                                        ]
                                    ]
                                },
                                "mode": "000400",
                                "owner": "root",
                                "group": "root"
                            },
                            "/etc/cfn/hooks.d/cfn-auto-reloader.conf": {
                                "content": {
                                    "Fn::Join": [
                                        "",
                                        [
                                            "[cfn-auto-reloader-hook]\n",
                                            "triggers=post.update\n",
                                            "path=Resources.WebServerHost.Metadata.AWS::CloudFormation::Init\n",
                                            "action=/opt/aws/bin/cfn-init -s ",
                                            {"Ref": "AWS::StackId"},
                                            " -r WebServerHost ",
                                            " --region     ",
                                            {"Ref": "AWS::Region"},
                                            "\n",
                                            "runas=root\n"
                                        ]
                                    ]
                                }
                            }
                        },
                        "services": {
                            "systemd": {
                                "httpd": {
                                    "enabled": "true",
                                    "ensureRunning": "true"
                                },
                                "php-fpm": {
                                    "enabled": "true",
                                    "ensureRunning": "true"
                                }
                            }
                        }
                    }
                }
            },
            "CreationPolicy": {
                "ResourceSignal": {
                    "Timeout": "PT5M"
                }
            },
            "Properties": {
                "ImageId": "{{resolve:ssm:/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-6.1-x86_64}}",
                "KeyName": {"Ref": "KeyName"},
                "InstanceType": "t3.micro",
                "SecurityGroupIds": [{"Ref": "WebServerSecurityGroup"}],
                "IamInstanceProfile": {"Ref": "LogRoleInstanceProfile"},
                "UserData": {"Fn::Base64": {"Fn::Join": [ "", [
                    "#!/bin/bash\n",
                    "dnf update -y aws-cfn-bootstrap\n",
                    "dnf install -y amazon-cloudwatch-agent\n",
                    "/opt/aws/bin/cfn-init -v --stack ", {"Ref": "AWS::StackName"}, " --resource WebServerHost --region ", {"Ref": "AWS::Region"}, "\n",
                    "\n",
                    "# Verify Apache log directory exists and create if needed\n",
                    "mkdir -p /var/log/httpd\n",
                    "\n",
                    "# Start CloudWatch agent\n",
                    "/opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl -a fetch-config -m ec2 -c file:/etc/amazon-cloudwatch-agent/amazon-cloudwatch-agent.json -s\n",
                    "\n",
                    "# Signal success\n",
                    "/opt/aws/bin/cfn-signal -e $? --stack ", {"Ref": "AWS::StackName"}, " --resource WebServerHost --region ", {"Ref": "AWS::Region"}, "\n"
                ]]}}
            }
        },
        "WebServerLogGroup": {
            "Type": "AWS::Logs::LogGroup",
            "DeletionPolicy": "Retain",
            "UpdateReplacePolicy": "Retain",
            "Properties": {
                "RetentionInDays": 7
            }
        },
        "404MetricFilter": {
            "Type": "AWS::Logs::MetricFilter",
            "Properties": {
                "LogGroupName": {"Ref": "WebServerLogGroup"},
                "FilterPattern": "[ip, identity, user_id, timestamp, request, status_code = 404, size, ...]",
                "MetricTransformations": [
                    {
                        "MetricValue": "1",
                        "MetricNamespace": "test/404s",
                        "MetricName": "test404Count"
                    }
                ]
            }
        },
        "BytesTransferredMetricFilter": {
            "Type": "AWS::Logs::MetricFilter",
            "Properties": {
                "LogGroupName": {"Ref": "WebServerLogGroup"},
                "FilterPattern": "[ip, identity, user_id, timestamp, request, status_code, size, ...]",
                "MetricTransformations": [
                    {
                        "MetricValue": "$size",
                        "MetricNamespace": "test/BytesTransferred",
                        "MetricName": "testBytesTransferred"
                    }
                ]
            }
        },
        "404Alarm": {
            "Type": "AWS::CloudWatch::Alarm",
            "Properties": {
                "AlarmDescription": "The number of 404s is greater than 2 over 2 minutes",
                "MetricName": "test404Count",
                "Namespace": "test/404s",
                "Statistic": "Sum",
                "Period": "60",
                "EvaluationPeriods": "2",
                "Threshold": "2",
                "AlarmActions": [{"Ref": "AlarmNotificationTopic"}],
                "ComparisonOperator": "GreaterThanThreshold"
            }
        },
        "BandwidthAlarm": {
            "Type": "AWS::CloudWatch::Alarm",
            "Properties": {
                "AlarmDescription": "The average volume of traffic is greater 3500 KB over 10 minutes",
                "MetricName": "testBytesTransferred",
                "Namespace": "test/BytesTransferred",
                "Statistic": "Average",
                "Period": "300",
                "EvaluationPeriods": "2",
                "Threshold": "3500",
                "AlarmActions": [{"Ref": "AlarmNotificationTopic"}],
                "ComparisonOperator": "GreaterThanThreshold"
            }
        },
        "AlarmNotificationTopic": {
            "Type": "AWS::SNS::Topic",
            "Properties": {
                "Subscription": [{"Endpoint": {"Ref": "OperatorEmail"}, "Protocol": "email"}]
            }
        }
    },
    "Outputs": {
        "InstanceId": {
            "Description": "The instance ID of the web server",
            "Value": {"Ref": "WebServerHost"}
        },
        "WebsiteURL": {
            "Value": {"Fn::Sub": "http://${WebServerHost.PublicDnsName}"},
            "Description": "URL for the web server"
        },
        "PublicIP": {
            "Description": "Public IP address of the web server",
            "Value": {"Fn::GetAtt": ["WebServerHost","PublicIp"]
            }
        },
        "CloudWatchLogGroupName": {
            "Description": "The name of the CloudWatch log group",
            "Value": {"Ref": "WebServerLogGroup"}
        }
    }
}
```

### YAML
<a name="quickref-cloudwatchlogs-example.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
Description: Sample template that sets up and configures CloudWatch Logs on Amazon Linux 2023 instance.
Parameters:
  KeyName:
    Description: Name of an existing EC2 KeyPair to enable SSH access to the instances
    Type: AWS::EC2::KeyPair::KeyName
    ConstraintDescription: must be the name of an existing EC2 KeyPair.
  SSHLocation:
    Description: The IP address range that can be used to SSH to the EC2 instances
    Type: String
    MinLength: '9'
    MaxLength: '18'
    Default: 0.0.0.0/0
    AllowedPattern: '(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})/(\d{1,2})'
    ConstraintDescription: must be a valid IP CIDR range of the form x.x.x.x/x.
  OperatorEmail:
    Description: Email address to notify when CloudWatch alarms are triggered (404 errors or high bandwidth usage)
    Type: String
Resources:
  LogRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: 2012-10-17		 	 	 
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - ec2.amazonaws.com
            Action:
              - 'sts:AssumeRole'
      Path: /
      Policies:
        - PolicyName: LogRolePolicy
          PolicyDocument:
            Version: 2012-10-17		 	 	 
            Statement:
              - Effect: Allow
                Action:
                  - 'logs:PutLogEvents'
                  - 'logs:DescribeLogStreams'
                  - 'logs:DescribeLogGroups'
                  - 'logs:CreateLogGroup'
                  - 'logs:CreateLogStream'
                Resource: '*'
  LogRoleInstanceProfile:
    Type: AWS::IAM::InstanceProfile
    Properties:
      Path: /
      Roles:
        - !Ref LogRole
  WebServerSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Enable HTTP access via port 80 and SSH access via port 22
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: 80
          ToPort: 80
          CidrIp: 0.0.0.0/0
        - IpProtocol: tcp
          FromPort: 22
          ToPort: 22
          CidrIp: !Ref SSHLocation
  WebServerHost:
    Type: AWS::EC2::Instance
    Metadata:
      Comment: Install a simple PHP application on Amazon Linux 2023
      'AWS::CloudFormation::Init':
        config:
          packages:
            dnf:
              httpd: []
              php: []
              php-fpm: []
          files:
            /etc/amazon-cloudwatch-agent/amazon-cloudwatch-agent.json:
              content: !Sub |
                {
                  "logs": {
                    "logs_collected": {
                      "files": {
                        "collect_list": [
                          {
                            "file_path": "/var/log/httpd/access_log",
                            "log_group_name": "${WebServerLogGroup}",
                            "log_stream_name": "{instance_id}/apache.log",
                            "timestamp_format": "%d/%b/%Y:%H:%M:%S %z"
                          }
                        ]
                      }
                    }
                  }
                }
              mode: '000644'
              owner: root
              group: root
            /var/www/html/index.php:
              content: |
                <?php echo '<h1>AWS CloudFormation sample PHP application on Amazon Linux 2023</h1>';
                ?>
              mode: '000644'
              owner: apache
              group: apache
            /etc/cfn/cfn-hup.conf:
              content: !Sub |
                [main]
                stack=${AWS::StackId}
                region=${AWS::Region}
              mode: '000400'
              owner: root
              group: root
            /etc/cfn/hooks.d/cfn-auto-reloader.conf:
              content: !Sub |
                [cfn-auto-reloader-hook]
                triggers=post.update
                path=Resources.WebServerHost.Metadata.AWS::CloudFormation::Init
                action=/opt/aws/bin/cfn-init -s ${AWS::StackId} -r WebServerHost --region ${AWS::Region}
                runas=root
          services:
            systemd:
              httpd:
                enabled: 'true'
                ensureRunning: 'true'
              php-fpm:
                enabled: 'true'
                ensureRunning: 'true'
    CreationPolicy:
      ResourceSignal:
        Timeout: PT5M
    Properties:
      ImageId: '{{resolve:ssm:/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-6.1-x86_64}}'
      KeyName: !Ref KeyName
      InstanceType: t3.micro
      SecurityGroupIds:
        - !Ref WebServerSecurityGroup
      IamInstanceProfile: !Ref LogRoleInstanceProfile
      UserData: !Base64
        Fn::Sub: |
          #!/bin/bash
          dnf update -y aws-cfn-bootstrap
          dnf install -y amazon-cloudwatch-agent
          /opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource WebServerHost --region ${AWS::Region}
          
          # Verify Apache log directory exists and create if needed
          mkdir -p /var/log/httpd
          
          # Start CloudWatch agent
          /opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl -a fetch-config -m ec2 -c file:/etc/amazon-cloudwatch-agent/amazon-cloudwatch-agent.json -s
          
          # Signal success
          /opt/aws/bin/cfn-signal -e $? --stack ${AWS::StackName} --resource WebServerHost --region ${AWS::Region}
          echo "Done"
  WebServerLogGroup:
    Type: AWS::Logs::LogGroup
    DeletionPolicy: Retain
    UpdateReplacePolicy: Retain
    Properties:
      RetentionInDays: 7
  404MetricFilter:
    Type: AWS::Logs::MetricFilter
    Properties:
      LogGroupName: !Ref WebServerLogGroup
      FilterPattern: >-
        [ip, identity, user_id, timestamp, request, status_code = 404, size, ...]
      MetricTransformations:
        - MetricValue: '1'
          MetricNamespace: test/404s
          MetricName: test404Count
  BytesTransferredMetricFilter:
    Type: AWS::Logs::MetricFilter
    Properties:
      LogGroupName: !Ref WebServerLogGroup
      FilterPattern: '[ip, identity, user_id, timestamp, request, status_code, size, ...]'
      MetricTransformations:
        - MetricValue: $size
          MetricNamespace: test/BytesTransferred
          MetricName: testBytesTransferred
  404Alarm:
    Type: AWS::CloudWatch::Alarm
    Properties:
      AlarmDescription: The number of 404s is greater than 2 over 2 minutes
      MetricName: test404Count
      Namespace: test/404s
      Statistic: Sum
      Period: '60'
      EvaluationPeriods: '2'
      Threshold: '2'
      AlarmActions:
        - !Ref AlarmNotificationTopic
      ComparisonOperator: GreaterThanThreshold
  BandwidthAlarm:
    Type: AWS::CloudWatch::Alarm
    Properties:
      AlarmDescription: The average volume of traffic is greater 3500 KB over 10 minutes
      MetricName: testBytesTransferred
      Namespace: test/BytesTransferred
      Statistic: Average
      Period: '300'
      EvaluationPeriods: '2'
      Threshold: '3500'
      AlarmActions:
        - !Ref AlarmNotificationTopic
      ComparisonOperator: GreaterThanThreshold
  AlarmNotificationTopic:
    Type: AWS::SNS::Topic
    Properties:
      Subscription:
        - Endpoint: !Ref OperatorEmail
          Protocol: email
Outputs:
  InstanceId:
    Description: The instance ID of the web server
    Value: !Ref WebServerHost
  WebsiteURL:
    Value: !Sub 'http://${WebServerHost.PublicDnsName}'
    Description: URL for the web server
  PublicIP:
    Description: Public IP address of the web server
    Value: !GetAtt WebServerHost.PublicIp
  CloudWatchLogGroupName:
    Description: The name of the CloudWatch log group
    Value: !Ref WebServerLogGroup
```

## Invia i log a Logs da un'istanza di Windows CloudWatch
<a name="quickref-cloudwatchlogs-example2"></a>

Il modello seguente configura i CloudWatch log per un'istanza di Windows 2012R2.

L'agente CloudWatch Logs su Windows (agente SSM su Windows 2012R2 e Windows 2016 AMIs) invia i log solo dopo l'avvio, quindi i log generati prima dell'avvio non vengono inviati. A questo proposito, il modello aiuta a garantire che l’agente venga avviato prima della scrittura dei log da:
+ Impostazione della configurazione dell’agente come prima voce `config` in `configSets` cfn-init.
+ Utilizzo di `waitAfterCompletion` per inserire una pausa dopo il comando che avvia l’agente.

### JSON
<a name="quickref-cloudwatchlogs-example2.json"></a>

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Description": "Sample template that sets up and configures CloudWatch Logs on Windows 2012R2 instance.",
    "Parameters": {
        "KeyPair": {
            "Description": "Name of an existing EC2 KeyPair to enable RDP access to the instances",
            "Type": "AWS::EC2::KeyPair::KeyName",
            "ConstraintDescription": "must be the name of an existing EC2 KeyPair."
        },
        "RDPLocation": {
            "Description": "The IP address range that can be used to RDP to the EC2 instances",
            "Type": "String",
            "MinLength": "9",
            "MaxLength": "18",
            "Default": "0.0.0.0/0",
            "AllowedPattern": "(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})/(\\d{1,2})",
            "ConstraintDescription": "must be a valid IP CIDR range of the form x.x.x.x/x."
        },
        "OperatorEmail": {
            "Description": "Email address to notify when CloudWatch alarms are triggered (404 errors)",
            "Type": "String"
        }
    },
    "Resources": {
        "WebServerSecurityGroup": {
            "Type": "AWS::EC2::SecurityGroup",
            "Properties": {
                "GroupDescription": "Enable HTTP access via port 80 and RDP access via port 3389",
                "SecurityGroupIngress": [
                    {
                        "IpProtocol": "tcp",
                        "FromPort": "80",
                        "ToPort": "80",
                        "CidrIp": "0.0.0.0/0"
                    },
                    {
                        "IpProtocol": "tcp",
                        "FromPort": "3389",
                        "ToPort": "3389",
                        "CidrIp": {"Ref": "RDPLocation"}
                    }
                ]
            }
        },
        "LogRole": {
            "Type": "AWS::IAM::Role",
            "Properties": {
                "AssumeRolePolicyDocument": {
                    "Version": "2012-10-17",		 	 	 
                    "Statement": [
                        {
                            "Effect": "Allow",
                            "Principal": {
                                "Service": [
                                    "ec2.amazonaws.com"
                                ]
                            },
                            "Action": [
                                "sts:AssumeRole"
                            ]
                        }
                    ]
                },
                "ManagedPolicyArns": [
                    "arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore"
                ],
                "Path": "/",
                "Policies": [
                    {
                        "PolicyName": "LogRolePolicy",
                        "PolicyDocument": {
                            "Version": "2012-10-17",		 	 	 
                            "Statement": [
                                {
                                    "Effect": "Allow",
                                    "Action": [
                                        "logs:Create*",
                                        "logs:PutLogEvents",
                                        "s3:GetObject"
                                    ],
                                    "Resource": [
                                        "arn:aws:logs:*:*:*",
                                        "arn:aws:s3:::*"
                                    ]
                                }
                            ]
                        }
                    }
                ]
            }
        },
        "LogRoleInstanceProfile": {
            "Type": "AWS::IAM::InstanceProfile",
            "Properties": {
                "Path": "/",
                "Roles": [{"Ref": "LogRole"}]
            }
        },
        "WebServerHost": {
            "Type": "AWS::EC2::Instance",
            "CreationPolicy": {
                "ResourceSignal": {
                    "Timeout": "PT15M"
                }
            },
            "Metadata": {
                "AWS::CloudFormation::Init": {
                    "configSets": {
                        "config": [
                            "00-ConfigureCWLogs",
                            "01-InstallWebServer",
                            "02-ConfigureApplication",
                            "03-Finalize"
                        ]
                    },
                    "00-ConfigureCWLogs": {
                        "files": {
                            "C:\\Program Files\\Amazon\\SSM\\Plugins\\awsCloudWatch\\AWS.EC2.Windows.CloudWatch.json": {
                                "content": {
                                    "EngineConfiguration": {
                                        "Components": [
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.EventLog.EventLogInputComponent,AWS.EC2.Windows.CloudWatch",
                                                "Id": "ApplicationEventLog",
                                                "Parameters": {
                                                    "Levels": "7",
                                                    "LogName": "Application"
                                                }
                                            },
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.EventLog.EventLogInputComponent,AWS.EC2.Windows.CloudWatch",
                                                "Id": "SystemEventLog",
                                                "Parameters": {
                                                    "Levels": "7",
                                                    "LogName": "System"
                                                }
                                            },
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.EventLog.EventLogInputComponent,AWS.EC2.Windows.CloudWatch",
                                                "Id": "SecurityEventLog",
                                                "Parameters": {
                                                    "Levels": "7",
                                                    "LogName": "Security"
                                                }
                                            },
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.CustomLog.CustomLogInputComponent,AWS.EC2.Windows.CloudWatch",
                                                "Id": "EC2ConfigLog",
                                                "Parameters": {
                                                    "CultureName": "en-US",
                                                    "Encoding": "ASCII",
                                                    "Filter": "EC2ConfigLog.txt",
                                                    "LogDirectoryPath": "C:\\Program Files\\Amazon\\Ec2ConfigService\\Logs",
                                                    "TimeZoneKind": "UTC",
                                                    "TimestampFormat": "yyyy-MM-ddTHH:mm:ss.fffZ:"
                                                }
                                            },
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.CustomLog.CustomLogInputComponent,AWS.EC2.Windows.CloudWatch",
                                                "Id": "CfnInitLog",
                                                "Parameters": {
                                                    "CultureName": "en-US",
                                                    "Encoding": "ASCII",
                                                    "Filter": "cfn-init.log",
                                                    "LogDirectoryPath": "C:\\cfn\\log",
                                                    "TimeZoneKind": "Local",
                                                    "TimestampFormat": "yyyy-MM-dd HH:mm:ss,fff"
                                                }
                                            },
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.CustomLog.CustomLogInputComponent,AWS.EC2.Windows.CloudWatch",
                                                "Id": "IISLogs",
                                                "Parameters": {
                                                    "CultureName": "en-US",
                                                    "Encoding": "UTF-8",
                                                    "Filter": "",
                                                    "LineCount": "3",
                                                    "LogDirectoryPath": "C:\\inetpub\\logs\\LogFiles\\W3SVC1",
                                                    "TimeZoneKind": "UTC",
                                                    "TimestampFormat": "yyyy-MM-dd HH:mm:ss"
                                                }
                                            },
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.PerformanceCounterComponent.PerformanceCounterInputComponent,AWS.EC2.Windows.CloudWatch",
                                                "Id": "MemoryPerformanceCounter",
                                                "Parameters": {
                                                    "CategoryName": "Memory",
                                                    "CounterName": "Available MBytes",
                                                    "DimensionName": "",
                                                    "DimensionValue": "",
                                                    "InstanceName": "",
                                                    "MetricName": "Memory",
                                                    "Unit": "Megabytes"
                                                }
                                            },
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch",
                                                "Id": "CloudWatchApplicationEventLog",
                                                "Parameters": {
                                                    "AccessKey": "",
                                                    "LogGroup": {"Ref": "LogGroup"},
                                                    "LogStream": "{instance_id}/ApplicationEventLog",
                                                    "Region": {"Ref": "AWS::Region"},
                                                    "SecretKey": ""
                                                }
                                            },
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch",
                                                "Id": "CloudWatchSystemEventLog",
                                                "Parameters": {
                                                    "AccessKey": "",
                                                    "LogGroup": {"Ref": "LogGroup"},
                                                    "LogStream": "{instance_id}/SystemEventLog",
                                                    "Region": {"Ref": "AWS::Region"},
                                                    "SecretKey": ""
                                                }
                                            },
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch",
                                                "Id": "CloudWatchSecurityEventLog",
                                                "Parameters": {
                                                    "AccessKey": "",
                                                    "LogGroup": {"Ref": "LogGroup"},
                                                    "LogStream": "{instance_id}/SecurityEventLog",
                                                    "Region": {"Ref": "AWS::Region"},
                                                    "SecretKey": ""
                                                }
                                            },
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch",
                                                "Id": "CloudWatchEC2ConfigLog",
                                                "Parameters": {
                                                    "AccessKey": "",
                                                    "LogGroup": {"Ref": "LogGroup"},
                                                    "LogStream": "{instance_id}/EC2ConfigLog",
                                                    "Region": {"Ref": "AWS::Region"},
                                                    "SecretKey": ""
                                                }
                                            },
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch",
                                                "Id": "CloudWatchCfnInitLog",
                                                "Parameters": {
                                                    "AccessKey": "",
                                                    "LogGroup": {"Ref": "LogGroup"},
                                                    "LogStream": "{instance_id}/CfnInitLog",
                                                    "Region": {"Ref": "AWS::Region"},
                                                    "SecretKey": ""
                                                }
                                            },
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch",
                                                "Id": "CloudWatchIISLogs",
                                                "Parameters": {
                                                    "AccessKey": "",
                                                    "LogGroup": {"Ref": "LogGroup"},
                                                    "LogStream": "{instance_id}/IISLogs",
                                                    "Region": {"Ref": "AWS::Region"},
                                                    "SecretKey": ""
                                                }
                                            },
                                            {
                                                "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatch.CloudWatchOutputComponent,AWS.EC2.Windows.CloudWatch",
                                                "Id": "CloudWatch",
                                                "Parameters": {
                                                    "AccessKey": "",
                                                    "NameSpace": "Windows/Default",
                                                    "Region": {"Ref": "AWS::Region"},
                                                    "SecretKey": ""
                                                }
                                            }
                                        ],
                                        "Flows": {
                                            "Flows": [
                                                "ApplicationEventLog,CloudWatchApplicationEventLog",
                                                "SystemEventLog,CloudWatchSystemEventLog",
                                                "SecurityEventLog,CloudWatchSecurityEventLog",
                                                "EC2ConfigLog,CloudWatchEC2ConfigLog",
                                                "CfnInitLog,CloudWatchCfnInitLog",
                                                "IISLogs,CloudWatchIISLogs",
                                                "MemoryPerformanceCounter,CloudWatch"
                                            ]
                                        },
                                        "PollInterval": "00:00:05"
                                    },
                                    "IsEnabled": true
                                }
                            }
                        },
                        "commands": {
                            "0-enableSSM": {
                                "command": "powershell.exe -Command \"Set-Service -Name AmazonSSMAgent -StartupType Automatic\" ",
                                "waitAfterCompletion": "0"
                            },
                            "1-restartSSM": {
                                "command": "powershell.exe -Command \"Restart-Service AmazonSSMAgent \"",
                                "waitAfterCompletion": "30"
                            }
                        }
                    },
                    "01-InstallWebServer": {
                        "commands": {
                            "01_install_webserver": {
                                "command": "powershell.exe -Command \"Install-WindowsFeature Web-Server  -IncludeAllSubFeature\"",
                                "waitAfterCompletion": "0"
                            }
                        }
                    },
                    "02-ConfigureApplication": {
                        "files": {
                            "c:\\Inetpub\\wwwroot\\index.htm": {
                                "content": "<html> <head> <title>Test Application Page</title> </head> <body> <h1>Congratulations!! Your IIS server is configured.</h1> </body> </html>"
                            }
                        }
                    },
                    "03-Finalize": {
                        "commands": {
                            "00_signal_success": {
                                "command": {
                                    "Fn::Sub": "cfn-signal.exe -e 0 --resource WebServerHost --stack ${AWS::StackName} --region ${AWS::Region}"
                                },
                                "waitAfterCompletion": "0"
                            }
                        }
                    }
                }
            },
            "Properties": {
                "KeyName": {
                    "Ref": "KeyPair"
                },
                "ImageId": "{{resolve:ssm:/aws/service/ami-windows-latest/Windows_Server-2012-R2_RTM-English-64Bit-Base}}",
                "InstanceType": "t2.xlarge",
                "SecurityGroupIds": [{"Ref": "WebServerSecurityGroup"}],
                "IamInstanceProfile": {"Ref": "LogRoleInstanceProfile"},
                "UserData": {
                    "Fn::Base64": {
                        "Fn::Join": [
                            "",
                            [
                                "<script>\n",
                                "wmic product where \"description='Amazon SSM Agent' \" uninstall\n",
                                "wmic product where \"description='aws-cfn-bootstrap' \" uninstall \n",
                                "start /wait c:\\Windows\\system32\\msiexec /passive /qn /i https://s3.amazonaws.com/cloudformation-examples/aws-cfn-bootstrap-win64-latest.msi\n",
                                "powershell.exe -Command \"iwr https://s3.amazonaws.com/ec2-downloads-windows/SSMAgent/latest/windows_amd64/AmazonSSMAgentSetup.exe  -UseBasicParsing -OutFile C:\\AmazonSSMAgentSetup.exe\"\n",
                                "start /wait C:\\AmazonSSMAgentSetup.exe /install /quiet\n",
                                "cfn-init.exe -v -c config -s ", {"Ref": "AWS::StackName"}, " --resource WebServerHost --region ", {"Ref": "AWS::Region"}, " \n",
                                "</script>\n"
                            ]
                        ]
                    }
                }
            }
        },
        "LogGroup": {
            "Type": "AWS::Logs::LogGroup",
            "Properties": {
                "RetentionInDays": 7
            }
        },
        "404MetricFilter": {
            "Type": "AWS::Logs::MetricFilter",
            "Properties": {
                "LogGroupName": {"Ref": "LogGroup"},
                "FilterPattern": "[timestamps, serverip, method, uri, query, port, dash, clientip, useragent, status_code = 404, ...]",
                "MetricTransformations": [
                    {
                        "MetricValue": "1",
                        "MetricNamespace": "test/404s",
                        "MetricName": "test404Count"
                    }
                ]
            }
        },
        "404Alarm": {
            "Type": "AWS::CloudWatch::Alarm",
            "Properties": {
                "AlarmDescription": "The number of 404s is greater than 2 over 2 minutes",
                "MetricName": "test404Count",
                "Namespace": "test/404s",
                "Statistic": "Sum",
                "Period": "60",
                "EvaluationPeriods": "2",
                "Threshold": "2",
                "AlarmActions": [{"Ref": "AlarmNotificationTopic"}],
                "ComparisonOperator": "GreaterThanThreshold"
            }
        },
        "AlarmNotificationTopic": {
            "Type": "AWS::SNS::Topic",
            "Properties": {
                "Subscription": [{"Endpoint": {"Ref": "OperatorEmail"}, "Protocol": "email"}]
            }
        }
    },
    "Outputs": {
        "InstanceId": {
            "Description": "The instance ID of the web server",
            "Value": {"Ref": "WebServerHost"}
        },
        "WebsiteURL": {
            "Value": {"Fn::Sub": "http://${WebServerHost.PublicDnsName}"},
            "Description": "URL for the web server"
        },
        "PublicIP": {
            "Description": "Public IP address of the web server",
            "Value": {"Fn::GetAtt": ["WebServerHost","PublicIp"]}
        },
        "CloudWatchLogGroupName": {
            "Description": "The name of the CloudWatch log group",
            "Value": {"Ref": "LogGroup"}
        }
    }
}
```

### YAML
<a name="quickref-cloudwatchlogs-example2.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
Description: >-
  Sample template that sets up and configures CloudWatch Logs on Windows 2012R2 instance.
Parameters:
  KeyPair:
    Description: Name of an existing EC2 KeyPair to enable RDP access to the instances
    Type: AWS::EC2::KeyPair::KeyName
    ConstraintDescription: must be the name of an existing EC2 KeyPair.
  RDPLocation:
    Description: The IP address range that can be used to RDP to the EC2 instances
    Type: String
    MinLength: '9'
    MaxLength: '18'
    Default: 0.0.0.0/0
    AllowedPattern: '(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})/(\d{1,2})'
    ConstraintDescription: must be a valid IP CIDR range of the form x.x.x.x/x.
  OperatorEmail:
    Description: Email address to notify when CloudWatch alarms are triggered (404 errors)
    Type: String
Resources:
  WebServerSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Enable HTTP access via port 80 and RDP access via port 3389
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: '80'
          ToPort: '80'
          CidrIp: 0.0.0.0/0
        - IpProtocol: tcp
          FromPort: '3389'
          ToPort: '3389'
          CidrIp: !Ref RDPLocation
  LogRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: 2012-10-17		 	 	 
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - ec2.amazonaws.com
            Action:
              - 'sts:AssumeRole'
      ManagedPolicyArns:
        - 'arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore'
      Path: /
      Policies:
        - PolicyName: LogRolePolicy
          PolicyDocument:
            Version: 2012-10-17		 	 	 
            Statement:
              - Effect: Allow
                Action:
                  - 'logs:Create*'
                  - 'logs:PutLogEvents'
                  - 's3:GetObject'
                Resource:
                  - 'arn:aws:logs:*:*:*'
                  - 'arn:aws:s3:::*'
  LogRoleInstanceProfile:
    Type: AWS::IAM::InstanceProfile
    Properties:
      Path: /
      Roles:
        - !Ref LogRole
  WebServerHost:
    Type: AWS::EC2::Instance
    CreationPolicy:
      ResourceSignal:
        Timeout: PT15M
    Metadata:
      'AWS::CloudFormation::Init':
        configSets:
          config:
            - 00-ConfigureCWLogs
            - 01-InstallWebServer
            - 02-ConfigureApplication
            - 03-Finalize
        00-ConfigureCWLogs:
          files:
            'C:\Program Files\Amazon\SSM\Plugins\awsCloudWatch\AWS.EC2.Windows.CloudWatch.json':
              content: !Sub |
                {
                  "EngineConfiguration": {
                      "Components": [
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.EventLog.EventLogInputComponent,AWS.EC2.Windows.CloudWatch",
                              "Id": "ApplicationEventLog",
                              "Parameters": {
                                  "Levels": "7",
                                  "LogName": "Application"
                              }
                          },
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.EventLog.EventLogInputComponent,AWS.EC2.Windows.CloudWatch",
                              "Id": "SystemEventLog",
                              "Parameters": {
                                  "Levels": "7",
                                  "LogName": "System"
                              }
                          },
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.EventLog.EventLogInputComponent,AWS.EC2.Windows.CloudWatch",
                              "Id": "SecurityEventLog",
                              "Parameters": {
                                  "Levels": "7",
                                  "LogName": "Security"
                              }
                          },
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.CustomLog.CustomLogInputComponent,AWS.EC2.Windows.CloudWatch",
                              "Id": "EC2ConfigLog",
                              "Parameters": {
                                  "CultureName": "en-US",
                                  "Encoding": "ASCII",
                                  "Filter": "EC2ConfigLog.txt",
                                  "LogDirectoryPath": "C:\\Program Files\\Amazon\\Ec2ConfigService\\Logs",
                                  "TimeZoneKind": "UTC",
                                  "TimestampFormat": "yyyy-MM-ddTHH:mm:ss.fffZ:"
                              }
                          },
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.CustomLog.CustomLogInputComponent,AWS.EC2.Windows.CloudWatch",
                              "Id": "CfnInitLog",
                              "Parameters": {
                                  "CultureName": "en-US",
                                  "Encoding": "ASCII",
                                  "Filter": "cfn-init.log",
                                  "LogDirectoryPath": "C:\\cfn\\log",
                                  "TimeZoneKind": "Local",
                                  "TimestampFormat": "yyyy-MM-dd HH:mm:ss,fff"
                              }
                          },
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.CustomLog.CustomLogInputComponent,AWS.EC2.Windows.CloudWatch",
                              "Id": "IISLogs",
                              "Parameters": {
                                  "CultureName": "en-US",
                                  "Encoding": "UTF-8",
                                  "Filter": "",
                                  "LineCount": "3",
                                  "LogDirectoryPath": "C:\\inetpub\\logs\\LogFiles\\W3SVC1",
                                  "TimeZoneKind": "UTC",
                                  "TimestampFormat": "yyyy-MM-dd HH:mm:ss"
                              }
                          },
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.PerformanceCounterComponent.PerformanceCounterInputComponent,AWS.EC2.Windows.CloudWatch",
                              "Id": "MemoryPerformanceCounter",
                              "Parameters": {
                                  "CategoryName": "Memory",
                                  "CounterName": "Available MBytes",
                                  "DimensionName": "",
                                  "DimensionValue": "",
                                  "InstanceName": "",
                                  "MetricName": "Memory",
                                  "Unit": "Megabytes"
                              }
                          },
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch",
                              "Id": "CloudWatchApplicationEventLog",
                              "Parameters": {
                                  "AccessKey": "",
                                  "LogGroup": "${LogGroup}",
                                  "LogStream": "{instance_id}/ApplicationEventLog",
                                  "Region": "${AWS::Region}",
                                  "SecretKey": ""
                              }
                          },
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch",
                              "Id": "CloudWatchSystemEventLog",
                              "Parameters": {
                                  "AccessKey": "",
                                  "LogGroup": "${LogGroup}",
                                  "LogStream": "{instance_id}/SystemEventLog",
                                  "Region": "${AWS::Region}",
                                  "SecretKey": ""
                              }
                          },
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch",
                              "Id": "CloudWatchSecurityEventLog",
                              "Parameters": {
                                  "AccessKey": "",
                                  "LogGroup": "${LogGroup}",
                                  "LogStream": "{instance_id}/SecurityEventLog",
                                  "Region": "${AWS::Region}",
                                  "SecretKey": ""
                              }
                          },
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch",
                              "Id": "CloudWatchEC2ConfigLog",
                              "Parameters": {
                                  "AccessKey": "",
                                  "LogGroup": "${LogGroup}",
                                  "LogStream": "{instance_id}/EC2ConfigLog",
                                  "Region": "${AWS::Region}",
                                  "SecretKey": ""
                              }
                          },
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch",
                              "Id": "CloudWatchCfnInitLog",
                              "Parameters": {
                                  "AccessKey": "",
                                  "LogGroup": "${LogGroup}",
                                  "LogStream": "{instance_id}/CfnInitLog",
                                  "Region": "${AWS::Region}",
                                  "SecretKey": ""
                              }
                          },
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatchLogsOutput,AWS.EC2.Windows.CloudWatch",
                              "Id": "CloudWatchIISLogs",
                              "Parameters": {
                                  "AccessKey": "",
                                  "LogGroup": "${LogGroup}",
                                  "LogStream": "{instance_id}/IISLogs",
                                  "Region": "${AWS::Region}",
                                  "SecretKey": ""
                              }
                          },
                          {
                              "FullName": "AWS.EC2.Windows.CloudWatch.CloudWatch.CloudWatchOutputComponent,AWS.EC2.Windows.CloudWatch",
                              "Id": "CloudWatch",
                              "Parameters": {
                                  "AccessKey": "",
                                  "NameSpace": "Windows/Default",
                                  "Region": "${AWS::Region}",
                                  "SecretKey": ""
                              }
                          }
                      ],
                      "Flows": {
                          "Flows": [
                              "ApplicationEventLog,CloudWatchApplicationEventLog",
                              "SystemEventLog,CloudWatchSystemEventLog",
                              "SecurityEventLog,CloudWatchSecurityEventLog",
                              "EC2ConfigLog,CloudWatchEC2ConfigLog",
                              "CfnInitLog,CloudWatchCfnInitLog",
                              "IISLogs,CloudWatchIISLogs",
                              "MemoryPerformanceCounter,CloudWatch"
                          ]
                      },
                      "PollInterval": "00:00:05"
                  },
                  "IsEnabled": true
                }
          commands:
            0-enableSSM:
              command: >-
                powershell.exe -Command "Set-Service -Name AmazonSSMAgent
                -StartupType Automatic" 
              waitAfterCompletion: '0'
            1-restartSSM:
              command: powershell.exe -Command "Restart-Service AmazonSSMAgent "
              waitAfterCompletion: '30'
        01-InstallWebServer:
          commands:
            01_install_webserver:
              command: >-
                powershell.exe -Command "Install-WindowsFeature Web-Server 
                -IncludeAllSubFeature"
              waitAfterCompletion: '0'
        02-ConfigureApplication:
          files:
            'c:\Inetpub\wwwroot\index.htm':
              content: >-
                <html> <head> <title>Test Application Page</title> </head>
                <body> <h1>Congratulations !! Your IIS server is
                configured.</h1> </body> </html>
        03-Finalize:
          commands:
            00_signal_success:
              command: !Sub >-
                cfn-signal.exe -e 0 --resource WebServerHost --stack
                ${AWS::StackName} --region ${AWS::Region}
              waitAfterCompletion: '0'
    Properties:
      KeyName: !Ref KeyPair
      ImageId: "{{resolve:ssm:/aws/service/ami-windows-latest/Windows_Server-2012-R2_RTM-English-64Bit-Base}}"
      InstanceType: t2.xlarge
      SecurityGroupIds:
        - !Ref WebServerSecurityGroup
      IamInstanceProfile: !Ref LogRoleInstanceProfile
      UserData: !Base64 
        'Fn::Sub': >
          <script>

          wmic product where "description='Amazon SSM Agent' " uninstall

          wmic product where "description='aws-cfn-bootstrap' " uninstall 

          start /wait c:\\Windows\\system32\\msiexec /passive /qn /i
          https://s3.amazonaws.com/cloudformation-examples/aws-cfn-bootstrap-win64-latest.msi

          powershell.exe -Command "iwr
          https://s3.amazonaws.com/ec2-downloads-windows/SSMAgent/latest/windows_amd64/AmazonSSMAgentSetup.exe 
          -UseBasicParsing -OutFile C:\\AmazonSSMAgentSetup.exe"

          start /wait C:\\AmazonSSMAgentSetup.exe /install /quiet

          cfn-init.exe -v -c config -s ${AWS::StackName} --resource
          WebServerHost --region ${AWS::Region} 

          </script>
  LogGroup:
    Type: AWS::Logs::LogGroup
    Properties:
      RetentionInDays: 7
  404MetricFilter:
    Type: AWS::Logs::MetricFilter
    Properties:
      LogGroupName: !Ref LogGroup
      FilterPattern: >-
        [timestamps, serverip, method, uri, query, port, dash, clientip,
        useragent, status_code = 404, ...]
      MetricTransformations:
        - MetricValue: '1'
          MetricNamespace: test/404s
          MetricName: test404Count
  404Alarm:
    Type: AWS::CloudWatch::Alarm
    Properties:
      AlarmDescription: The number of 404s is greater than 2 over 2 minutes
      MetricName: test404Count
      Namespace: test/404s
      Statistic: Sum
      Period: '60'
      EvaluationPeriods: '2'
      Threshold: '2'
      AlarmActions:
        - !Ref AlarmNotificationTopic
      ComparisonOperator: GreaterThanThreshold
  AlarmNotificationTopic:
    Type: AWS::SNS::Topic
    Properties:
      Subscription:
        - Endpoint: !Ref OperatorEmail
          Protocol: email
Outputs:
  InstanceId:
    Description: The instance ID of the web server
    Value: !Ref WebServerHost
  WebsiteURL:
    Value: !Sub 'http://${WebServerHost.PublicDnsName}'
    Description: URL for the web server
  PublicIP:
    Description: Public IP address of the web server
    Value: !GetAtt 
      - WebServerHost
      - PublicIp
  CloudWatchLogGroupName:
    Description: The name of the CloudWatch log group
    Value: !Ref LogGroup
```

## Consulta anche
<a name="w2aac11c41c35c11"></a>

Per ulteriori informazioni sulle risorse Logs, consulta o. CloudWatch [AWS::Logs::LogGroup[AWS::Logs::MetricFilter](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-logs-metricfilter.html)](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-logs-loggroup.html)

# Frammenti di modello Amazon DynamoDB
<a name="quickref-dynamodb"></a>

**Topics**
+ [Application Auto Scaling con una tabella Amazon DynamoDB](#quickref-dynamodb-application-autoscaling)
+ [Consulta anche](#w2aac11c41c39b7)

## Application Auto Scaling con una tabella Amazon DynamoDB
<a name="quickref-dynamodb-application-autoscaling"></a>

In questo esempio Application Auto Scaling viene configurato per una risorsa `AWS::DynamoDB::Table`. Il modello definisce una policy di dimensionamento `TargetTrackingScaling` che aumenta il throughput `WriteCapacityUnits` della tabella.

### JSON
<a name="quickref-dynamodb-example.json"></a>

```
{
    "Resources": {
        "DDBTable": {
            "Type": "AWS::DynamoDB::Table",
            "Properties": {
                "AttributeDefinitions": [
                    {
                        "AttributeName": "ArtistId",
                        "AttributeType": "S"
                    },
                    {
                        "AttributeName": "Concert",
                        "AttributeType": "S"
                    },
                    {
                        "AttributeName": "TicketSales",
                        "AttributeType": "S"
                    }
                ],
                "KeySchema": [
                    {
                        "AttributeName": "ArtistId",
                        "KeyType": "HASH"
                    },
                    {
                        "AttributeName": "Concert",
                        "KeyType": "RANGE"
                    }
                ],
                "GlobalSecondaryIndexes": [
                    {
                        "IndexName": "GSI",
                        "KeySchema": [
                            {
                                "AttributeName": "TicketSales",
                                "KeyType": "HASH"
                            }
                        ],
                        "Projection": {
                            "ProjectionType": "KEYS_ONLY"
                        },
                        "ProvisionedThroughput": {
                            "ReadCapacityUnits": 5,
                            "WriteCapacityUnits": 5
                        }
                    }
                ],
                "ProvisionedThroughput": {
                    "ReadCapacityUnits": 5,
                    "WriteCapacityUnits": 5
                }
            }
        },
        "WriteCapacityScalableTarget": {
            "Type": "AWS::ApplicationAutoScaling::ScalableTarget",
            "Properties": {
                "MaxCapacity": 15,
                "MinCapacity": 5,
                "ResourceId": {
                    "Fn::Join": [
                        "/",
                        [
                            "table",
                            {
                                "Ref": "DDBTable"
                            }
                        ]
                    ]
                },
                "RoleARN" : { "Fn::Sub" : "arn:aws:iam::${AWS::AccountId}:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable" },
                "ScalableDimension": "dynamodb:table:WriteCapacityUnits",
                "ServiceNamespace": "dynamodb"
            }
        },
        "WriteScalingPolicy": {
            "Type": "AWS::ApplicationAutoScaling::ScalingPolicy",
            "Properties": {
                "PolicyName": "WriteAutoScalingPolicy",
                "PolicyType": "TargetTrackingScaling",
                "ScalingTargetId": {
                    "Ref": "WriteCapacityScalableTarget"
                },
                "TargetTrackingScalingPolicyConfiguration": {
                    "TargetValue": 50,
                    "ScaleInCooldown": 60,
                    "ScaleOutCooldown": 60,
                    "PredefinedMetricSpecification": {
                        "PredefinedMetricType": "DynamoDBWriteCapacityUtilization"
                    }
                }
            }
        }
    }
}
```

### YAML
<a name="quickref-dynamodb-example.yaml"></a>

```
Resources:
  DDBTable:
    Type: AWS::DynamoDB::Table
    Properties:
      AttributeDefinitions:
        - AttributeName: "ArtistId"
          AttributeType: "S"
        - AttributeName: "Concert"
          AttributeType: "S"
        - AttributeName: "TicketSales"
          AttributeType: "S"
      KeySchema:
        - AttributeName: "ArtistId"
          KeyType: "HASH"
        - AttributeName: "Concert"
          KeyType: "RANGE"
      GlobalSecondaryIndexes:
        - IndexName: "GSI"
          KeySchema:
            - AttributeName: "TicketSales"
              KeyType: "HASH"
          Projection:
            ProjectionType: "KEYS_ONLY"
          ProvisionedThroughput:
            ReadCapacityUnits: 5
            WriteCapacityUnits: 5
      ProvisionedThroughput:
        ReadCapacityUnits: 5
        WriteCapacityUnits: 5
  WriteCapacityScalableTarget:
    Type: AWS::ApplicationAutoScaling::ScalableTarget
    Properties:
      MaxCapacity: 15
      MinCapacity: 5
      ResourceId: !Join
        - /
        - - table
          - !Ref DDBTable
      RoleARN:
        Fn::Sub: 'arn:aws:iam::${AWS::AccountId}:role/aws-service-role/dynamodb.application-autoscaling.amazonaws.com/AWSServiceRoleForApplicationAutoScaling_DynamoDBTable'
      ScalableDimension: dynamodb:table:WriteCapacityUnits
      ServiceNamespace: dynamodb
  WriteScalingPolicy:
    Type: AWS::ApplicationAutoScaling::ScalingPolicy
    Properties:
      PolicyName: WriteAutoScalingPolicy
      PolicyType: TargetTrackingScaling
      ScalingTargetId: !Ref WriteCapacityScalableTarget
      TargetTrackingScalingPolicyConfiguration:
        TargetValue: 50.0
        ScaleInCooldown: 60
        ScaleOutCooldown: 60
        PredefinedMetricSpecification:
          PredefinedMetricType: DynamoDBWriteCapacityUtilization
```

## Consulta anche
<a name="w2aac11c41c39b7"></a>

Per ulteriori informazioni, consulta il post del blog [How to use CloudFormation to configure auto scaling for DynamoDB table and index on the Database Blog](https://aws.amazon.com/blogs/database/how-to-use-aws-cloudformation-to-configure-auto-scaling-for-amazon-dynamodb-tables-and-indexes/). AWS 

Per ulteriori informazioni sulle risorse DynamoDB, vedere. [AWS::DynamoDB::Table](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-dynamodb-table.html)

# Frammenti EC2 CloudFormation di modello Amazon
<a name="quickref-ec2"></a>

Amazon EC2 fornisce capacità di elaborazione scalabile in. Cloud AWS Puoi usare Amazon EC2 per avviare tutti o pochi server virtuali di cui hai bisogno, configurare sicurezza e rete e gestire lo storage. Questi server virtuali, noti come istanze, possono eseguire una varietà di sistemi operativi e applicazioni, e possono essere personalizzati per soddisfare requisiti specifici. Amazon ti EC2 consente di scalare verso l'alto o verso il basso per gestire i cambiamenti nei requisiti o i picchi di utilizzo.

Puoi definire e fornire EC2 istanze Amazon come parte della tua infrastruttura utilizzando CloudFormation modelli. I modelli semplificano la gestione e l'automazione della distribuzione delle EC2 risorse Amazon in modo ripetibile e coerente. 

I seguenti frammenti di modello di esempio descrivono CloudFormation risorse o componenti per Amazon. EC2 Questi frammenti sono progettati per essere integrati in un modello e non sono destinati a essere eseguiti in modo indipendente.

**Topics**
+ [Configurazione delle istanze EC2](quickref-ec2-instance-config.md)
+ [Creazione di modelli di avvio](quickref-ec2-launch-templates.md)
+ [Gestione dei gruppi di sicurezza](quickref-ec2-sg.md)
+ [Alloca Elastic IPs](quickref-ec2-elastic-ip.md)
+ [Configurazione di risorse VPC](quickref-ec2-vpc.md)

# Configura le istanze Amazon EC2 con CloudFormation
<a name="quickref-ec2-instance-config"></a>

I seguenti frammenti mostrano come configurare le istanze Amazon EC2 utilizzando CloudFormation.

**Topics**
+ [Configurazioni generali di Amazon EC2](#quickref-ec2-instance-config-general)
+ [Specifica della mappatura dei dispositivi a blocchi per un’istanza](#scenario-ec2-bdm)

## Configurazioni generali di Amazon EC2
<a name="quickref-ec2-instance-config-general"></a>

I seguenti frammenti mostrano le configurazioni generali per le istanze Amazon EC2 che utilizzano CloudFormation.

**Topics**
+ [Creazione di un’istanza Amazon EC2 in una zona di disponibilità specificata](#scenario-ec2-instance)
+ [Configurazione di un’istanza Amazon EC2 dotata di tag con un volume EBS e dati utente](#scenario-ec2-instance-with-vol-and-tags)
+ [Definizione del nome della tabella DynamoDB nei dati utente per il lancio dell’istanza Amazon EC2](#scenario-ec2-with-sdb-domain)
+ [Creazione di un volume Amazon EBS con `DeletionPolicy`](#scenario-ec2-volume)

### Creazione di un’istanza Amazon EC2 in una zona di disponibilità specificata
<a name="scenario-ec2-instance"></a>

Il seguente frammento crea un'istanza Amazon EC2 nella zona di disponibilità specificata utilizzando una risorsa. [AWS::EC2::Instance](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-instance.html) Il codice per la zona di disponibilità è il codice della Regione seguito da un identificatore con una lettera. Puoi avviare un’istanza in una singola zona di disponibilità. 

#### JSON
<a name="quickref-ec2-example-6.json"></a>

```
1. "Ec2Instance": {
2.     "Type": "AWS::EC2::Instance",
3.     "Properties": {
4.         "AvailabilityZone": "aa-example-1a",
5.         "ImageId": "ami-1234567890abcdef0"
6.     }
7. }
```

#### YAML
<a name="quickref-ec2-example-6.yaml"></a>

```
1. Ec2Instance:
2.   Type: AWS::EC2::Instance
3.   Properties:
4.     AvailabilityZone: aa-example-1a
5.     ImageId: ami-1234567890abcdef0
```

### Configurazione di un’istanza Amazon EC2 dotata di tag con un volume EBS e dati utente
<a name="scenario-ec2-instance-with-vol-and-tags"></a>

Il seguente frammento crea un’istanza Amazon EC2 con un tag, un volume EBS e dati utente. Utilizza una risorsa. [AWS::EC2::Instance](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-instance.html) Nello stesso modello, è necessario definire una [AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html)risorsa, una [AWS::SNS::Topic](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sns-topic.html)risorsa e una [AWS::EC2::Volume](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-volume.html)risorsa. Il `KeyName` deve essere definito nella sezione `Parameters` del modello.

I tag possono aiutarti a classificare AWS le risorse in base alle tue preferenze, ad esempio per scopo, proprietario o ambiente. I dati utente consentono di fornire script o dati personalizzati a un’istanza durante il lancio. Questi dati aiutano ad automatizzare le attività, configurare il software, installare i pacchetti e compiere altre azioni su un’istanza durante l’inizializzazione. 

Per ulteriori informazioni sul tagging delle risorse, consulta [Tag your Amazon EC2 resources](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html) nella *Guida per l’utente di Amazon EC2*. 

Per informazioni sui dati utente, consulta [Utilizzo dei metadati dell’istanza per gestire l’istanza EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) nella *Guida per l’utente di Amazon EC2*.

#### JSON
<a name="quickref-ec2-example-7.json"></a>

```
 1. "Ec2Instance": {
 2.   "Type": "AWS::EC2::Instance",
 3.   "Properties": {
 4.     "KeyName": { "Ref": "KeyName" },
 5.     "SecurityGroups": [ { "Ref": "Ec2SecurityGroup" } ],
 6.     "UserData": {
 7.       "Fn::Base64": {
 8.         "Fn::Join": [ ":", [
 9.             "PORT=80",
10.             "TOPIC=",
11.             { "Ref": "MySNSTopic" }
12.           ]
13.         ]
14.       }
15.     },
16.     "InstanceType": "aa.size",
17.     "AvailabilityZone": "aa-example-1a",
18.     "ImageId": "ami-1234567890abcdef0",
19.     "Volumes": [
20.       {
21.         "VolumeId": { "Ref": "MyVolumeResource" },
22.         "Device": "/dev/sdk"
23.       }
24.     ],
25.     "Tags": [ { "Key": "Name", "Value": "MyTag" } ]
26.   }
27. }
```

#### YAML
<a name="quickref-ec2-example-7.yaml"></a>

```
 1. Ec2Instance:
 2.   Type: AWS::EC2::Instance
 3.   Properties:
 4.     KeyName: !Ref KeyName
 5.     SecurityGroups:
 6.       - !Ref Ec2SecurityGroup
 7.     UserData:
 8.       Fn::Base64:
 9.         Fn::Join:
10.           - ":"
11.           - - "PORT=80"
12.             - "TOPIC="
13.             - !Ref MySNSTopic
14.     InstanceType: aa.size
15.     AvailabilityZone: aa-example-1a
16.     ImageId: ami-1234567890abcdef0
17.     Volumes:
18.       - VolumeId: !Ref MyVolumeResource
19.         Device: "/dev/sdk"
20.     Tags:
21.       - Key: Name
22.         Value: MyTag
```

### Definizione del nome della tabella DynamoDB nei dati utente per il lancio dell’istanza Amazon EC2
<a name="scenario-ec2-with-sdb-domain"></a>

Il seguente frammento crea un’istanza Amazon EC2 e definisce un nome di tabella DynamoDB nei dati utente da passare all’istanza all’avvio. Utilizza una [AWS::EC2::Instance](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-instance.html)risorsa. Puoi definire parametri o valori dinamici nei dati utente per passare un’istanza EC2 al momento del lancio. 

Per ulteriori informazioni sui dati utente, consulta [Use instance metadata to manage your EC2 instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html) nella *Guida per l’utente di Amazon EC2*.

#### JSON
<a name="quickref-ec2-example-8.json"></a>

```
 1. "Ec2Instance": {
 2.     "Type": "AWS::EC2::Instance",
 3.     "Properties": {
 4.         "UserData": {
 5.             "Fn::Base64": {
 6.                 "Fn::Join": [
 7.                     "",
 8.                     [
 9.                         "TableName=",
10.                         {
11.                             "Ref": "DynamoDBTableName"
12.                         }
13.                     ]
14.                 ]
15.             }
16.         },
17.         "AvailabilityZone": "aa-example-1a",
18.         "ImageId": "ami-1234567890abcdef0"
19.     }
20. }
```

#### YAML
<a name="quickref-ec2-example-8.yaml"></a>

```
 1. Ec2Instance:
 2.   Type: AWS::EC2::Instance
 3.   Properties:
 4.     UserData:
 5.       Fn::Base64:
 6.         Fn::Join:
 7.           - ''
 8.           - - 'TableName='
 9.             - Ref: DynamoDBTableName
10.     AvailabilityZone: aa-example-1a
11.     ImageId: ami-1234567890abcdef0
```

### Creazione di un volume Amazon EBS con `DeletionPolicy`
<a name="scenario-ec2-volume"></a>

I seguenti frammenti creano un volume Amazon EBS utilizzando una risorsa Amazon EC2. [AWS::EC2::Volume](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-volume.html) Puoi utilizzare le proprietà `Size` o `SnapshotID` per definire il volume, ma non entrambe. Un attributo `DeletionPolicy` viene impostato per creare uno snapshot del volume quando lo stack viene eliminato. 

Per ulteriori informazioni sull’attributo `DeletionPolicy`, consulta l’[attributo DeletionPolicy](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-deletionpolicy.html).

Per ulteriori informazioni sulla creazione di volumi Amazon EBS, consulta [Creazione di un volume Amazon EBS](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-creating-volume.html).

#### JSON
<a name="quickref-ec2-example-13.json"></a>

Questo frammento crea un volume Amazon EBS con una **dimensione** specificata. La dimensione è impostata su 10, ma è possibile regolarla in base alle esigenze. La [AWS::EC2::Volume](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-volume.html)risorsa consente di specificare la dimensione o l'ID di uno snapshot, ma non entrambi.

```
 1. "MyEBSVolume": {
 2.     "Type": "AWS::EC2::Volume",
 3.     "Properties": {
 4.         "Size": "10",
 5.         "AvailabilityZone": {
 6.             "Ref": "AvailabilityZone"
 7.         }
 8.     },
 9.     "DeletionPolicy": "Snapshot"
10. }
```

Questo frammento crea un volume Amazon EBS utilizzando un **ID snapshot** fornito. La [AWS::EC2::Volume](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-volume.html)risorsa consente di specificare la dimensione o l'ID di un'istantanea, ma non entrambi.

```
 1. "MyEBSVolume": {
 2.     "Type": "AWS::EC2::Volume",
 3.     "Properties": {
 4.         "SnapshotId" : "snap-1234567890abcdef0",
 5.         "AvailabilityZone": {
 6.             "Ref": "AvailabilityZone"
 7.         }
 8.     },
 9.     "DeletionPolicy": "Snapshot"
10. }
```

#### YAML
<a name="quickref-ec2-example-13.yaml"></a>

Questo frammento crea un volume Amazon EBS con una **dimensione** specificata. La dimensione è impostata su 10, ma è possibile regolarla in base alle esigenze. La [AWS::EC2::Volume](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-volume.html)risorsa consente di specificare la dimensione o l'ID di un'istantanea, ma non entrambi.

```
1. MyEBSVolume:
2.   Type: AWS::EC2::Volume
3.   Properties:
4.     Size: 10
5.     AvailabilityZone:
6.       Ref: AvailabilityZone
7.   DeletionPolicy: Snapshot
```

Questo frammento crea un volume Amazon EBS utilizzando un **ID snapshot** fornito. La [AWS::EC2::Volume](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-volume.html)risorsa consente di specificare la dimensione o l'ID di un'istantanea, ma non entrambi.

```
1. MyEBSVolume:
2.   Type: AWS::EC2::Volume
3.   Properties:
4.     SnapshotId: snap-1234567890abcdef0
5.     AvailabilityZone:
6.       Ref: AvailabilityZone
7.   DeletionPolicy: Snapshot
```

## Specifica della mappatura dei dispositivi a blocchi per un’istanza
<a name="scenario-ec2-bdm"></a>

Una mappatura dei dispositivi a blocchi definisce i dispositivi a blocchi, inclusi i volumi di archivio dell’istanza e i volumi EBS, da collegare a un’istanza. Puoi specificare una mappatura dei dispositivi a blocchi quando crei un’AMI in modo che la mappatura venga utilizzata da tutte le istanze avviate dall’AMI. In alternativa, puoi specificare una mappatura dei dispositivi a blocchi quando avvii un’istanza, in modo che la mappatura sostituisca quella specificata nell’AMI da cui è stata avviata l’istanza.

Puoi utilizzare i seguenti frammenti di modello per specificare le mappature dei dispositivi a blocchi per i tuoi volumi EBS o Instance Store utilizzando la proprietà di una risorsa. `BlockDeviceMappings` [AWS::EC2::Instance](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-instance.html) 

Per ulteriori informazioni sulle mappature dei dispositivi a blocchi, consulta [Block device mappings for volumes on Amazon EC2 instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html) nella *Guida per l’utente di Amazon EC2*.

**Topics**
+ [Specifica le mappature dei dispositivi a blocchi per due volumi EBS](#w2aac11c41c43c13b9c11)
+ [Specifica la mappatura dei dispositivi a blocchi per un volume di archivio dell’istanza](#w2aac11c41c43c13b9c13)

### Specifica le mappature dei dispositivi a blocchi per due volumi EBS
<a name="w2aac11c41c43c13b9c11"></a>

#### JSON
<a name="quickref-ec2-example-1.json"></a>

```
"Ec2Instance": {
    "Type": "AWS::EC2::Instance",
    "Properties": {
      "ImageId": "{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}",
      "KeyName": { "Ref": "KeyName" },
      "InstanceType": { "Ref": "InstanceType" },
      "SecurityGroups": [{ "Ref": "Ec2SecurityGroup" }],
      "BlockDeviceMappings": [
        {
          "DeviceName": "/dev/sda1",
          "Ebs": { "VolumeSize": "50" }
        },
        {
          "DeviceName": "/dev/sdm",
          "Ebs": { "VolumeSize": "100" }
        }
      ]
    }
  }
}
```

#### YAML
<a name="quickref-ec2-example-1.yaml"></a>

```
EC2Instance:
    Type: AWS::EC2::Instance
    Properties:
      ImageId: '{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}'
      KeyName: !Ref KeyName
      InstanceType: !Ref InstanceType
      SecurityGroups:
        - !Ref Ec2SecurityGroup
      BlockDeviceMappings:
        -
          DeviceName: /dev/sda1
          Ebs:
            VolumeSize: 50
        -
          DeviceName: /dev/sdm
          Ebs:
            VolumeSize: 100
```

### Specifica la mappatura dei dispositivi a blocchi per un volume di archivio dell’istanza
<a name="w2aac11c41c43c13b9c13"></a>

#### JSON
<a name="quickref-ec2-example-2.json"></a>

```
"Ec2Instance" : {
  "Type" : "AWS::EC2::Instance", 
  "Properties" : {
    "ImageId" : "{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}",
    "KeyName" : { "Ref" : "KeyName" },
    "InstanceType": { "Ref": "InstanceType" },
    "SecurityGroups" : [{ "Ref" : "Ec2SecurityGroup" }],
    "BlockDeviceMappings" : [
      {
        "DeviceName"  : "/dev/sdc",
        "VirtualName" : "ephemeral0"
      }
    ]
  }
}
```

#### YAML
<a name="quickref-ec2-example-2.yaml"></a>

```
EC2Instance:
  Type: AWS::EC2::Instance
  Properties:
    ImageId: '{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}'
    KeyName: !Ref KeyName
    InstanceType: !Ref InstanceType
    SecurityGroups:
      - !Ref Ec2SecurityGroup
    BlockDeviceMappings:
      - DeviceName: /dev/sdc
        VirtualName: ephemeral0
```

# Crea modelli di lancio con CloudFormation
<a name="quickref-ec2-launch-templates"></a>

Questa sezione fornisce un esempio per la creazione di un modello di lancio di Amazon EC2 utilizzando. CloudFormation I modelli di avvio consentono di creare modelli per la configurazione e il provisioning delle istanze Amazon EC2 all’interno di AWS. Con i modelli di avvio, puoi archiviare i parametri di avvio in modo da non doverli specificare ogni volta che avvii un’istanza. Per altri esempi, consulta la sezione [Esempi](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html#aws-resource-ec2-launchtemplate--examples) nella risorsa `AWS::EC2::LaunchTemplate`.

Per maggiori informazioni sui modelli di avvio, consulta [Store instance launch parameters in Amazon EC2 launch templates](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html) nella *Guida per l’utente di Amazon EC2*. 

Per ulteriori informazioni su come creare modelli di avvio da utilizzare con i gruppi di Auto Scaling, consulta [Auto Scaling launch templates](https://docs.aws.amazon.com/autoscaling/ec2/userguide/launch-templates.html) nella *Guida per l’utente di Amazon EC2 Auto Scaling*.

**Topics**
+ [Creazione di un modello di avvio che specifica gruppi di sicurezza, tag, dati utente e un ruolo IAM](#scenario-as-launch-template)

## Creazione di un modello di avvio che specifica gruppi di sicurezza, tag, dati utente e un ruolo IAM
<a name="scenario-as-launch-template"></a>

Questo frammento mostra una [AWS::EC2::LaunchTemplate](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html)risorsa che contiene le informazioni di configurazione per avviare un'istanza. Puoi specificare i valori per le proprietà `ImageId`, `InstanceType`, `SecurityGroups`, `UserData` e `TagSpecifications`. La `SecurityGroups` proprietà specifica un gruppo di sicurezza EC2 esistente e un nuovo gruppo di sicurezza. La `Ref` funzione ottiene l'ID della [AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html)risorsa `myNewEC2SecurityGroup` dichiarata altrove nel modello dello stack. 

Il modello di avvio include una sezione per i dati utente personalizzati. In questa sezione puoi passare attività di configurazione e script che vengono eseguiti all’avvio di un’istanza. In questo esempio, i dati utente installano l' AWS Systems Manager agente e lo avviano.

Il modello di avvio include anche un ruolo IAM che consente alle applicazioni in esecuzione sulle istanze di eseguire operazioni per tuo conto. Questo esempio mostra una [AWS::IAM::Role](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-role.html)risorsa per il modello di avvio, che utilizza la `IamInstanceProfile` proprietà per specificare il ruolo IAM. La `Ref` funzione ottiene il nome della [AWS::IAM::InstanceProfile](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-instanceprofile.html)risorsa`myInstanceProfile`. Per configurare le autorizzazioni del ruolo IAM, è necessario specificare un valore per la proprietà `ManagedPolicyArns`.

### JSON
<a name="quickref-launch-template-example-1.json"></a>

```
 1. {
 2.   "Resources":{
 3.     "myLaunchTemplate":{
 4.       "Type":"AWS::EC2::LaunchTemplate",
 5.       "Properties":{
 6.         "LaunchTemplateName":{ "Fn::Sub": "${AWS::StackName}-launch-template" },
 7.         "LaunchTemplateData":{
 8.           "ImageId":"ami-02354e95b3example",
 9.           "InstanceType":"t3.micro",
10.           "IamInstanceProfile":{
11.             "Name":{
12.               "Ref":"myInstanceProfile"
13.             }
14.           },
15.           "SecurityGroupIds":[
16.             {
17.               "Ref":"myNewEC2SecurityGroup"
18.             },
19.             "sg-083cd3bfb8example"
20.           ],
21.           "UserData":{
22.             "Fn::Base64":{
23.               "Fn::Join": [
24.                 "", [
25.                   "#!/bin/bash\n",
26.                   "cd /tmp\n",
27.                   "yum install -y https://s3.amazonaws.com/ec2-downloads-windows/SSMAgent/latest/linux_amd64/amazon-ssm-agent.rpm\n",
28.                   "systemctl enable amazon-ssm-agent\n",
29.                   "systemctl start amazon-ssm-agent\n"
30.                 ]
31.               ]
32.             }
33.           },
34.           "TagSpecifications":[
35.             {
36.               "ResourceType":"instance",
37.               "Tags":[
38.                 {
39.                   "Key":"environment",
40.                   "Value":"development"
41.                 }
42.               ]
43.             },
44.             {
45.               "ResourceType":"volume",
46.               "Tags":[
47.                 {
48.                   "Key":"environment",
49.                   "Value":"development"
50.                 }
51.               ]
52.             }
53.           ]
54.         }
55.       }
56.     },
57.     "myInstanceRole":{
58.       "Type":"AWS::IAM::Role",
59.       "Properties":{
60.         "RoleName":"InstanceRole",
61.         "AssumeRolePolicyDocument":{
62.           "Version": "2012-10-17",		 	 	 
63.           "Statement":[
64.             {
65.               "Effect":"Allow",
66.               "Principal":{
67.                 "Service":[
68.                   "ec2.amazonaws.com"
69.                 ]
70.               },
71.               "Action":[
72.                 "sts:AssumeRole"
73.               ]
74.             }
75.           ]
76.         },
77.         "ManagedPolicyArns":[
78.           "arn:aws:iam::aws:policy/myCustomerManagedPolicy"
79.         ]
80.       }
81.     },
82.     "myInstanceProfile":{
83.       "Type":"AWS::IAM::InstanceProfile",
84.       "Properties":{
85.         "Path":"/",
86.         "Roles":[
87.           {
88.             "Ref":"myInstanceRole"
89.           }
90.         ]
91.       }
92.     }
93.   }
94. }
```

### YAML
<a name="quickref-launch-template-example-1.yaml"></a>

```
 1. ---
 2. Resources:
 3.   myLaunchTemplate:
 4.     Type: AWS::EC2::LaunchTemplate
 5.     Properties:
 6.       LaunchTemplateName: !Sub ${AWS::StackName}-launch-template
 7.       LaunchTemplateData:
 8.         ImageId: ami-02354e95b3example
 9.         InstanceType: t3.micro
10.         IamInstanceProfile:
11.           Name: !Ref myInstanceProfile
12.         SecurityGroupIds:
13.         - !Ref myNewEC2SecurityGroup
14.         - sg-083cd3bfb8example
15.         UserData:
16.           Fn::Base64: !Sub |
17.             #!/bin/bash
18.             cd /tmp
19.             yum install -y https://s3.amazonaws.com/ec2-downloads-windows/SSMAgent/latest/linux_amd64/amazon-ssm-agent.rpm
20.             systemctl enable amazon-ssm-agent
21.             systemctl start amazon-ssm-agent
22.         TagSpecifications:
23.         - ResourceType: instance
24.           Tags:
25.           - Key: environment
26.             Value: development
27.         - ResourceType: volume
28.           Tags:
29.           - Key: environment
30.             Value: development
31.   myInstanceRole:
32.     Type: AWS::IAM::Role
33.     Properties:
34.       RoleName: InstanceRole
35.       AssumeRolePolicyDocument:
36.         Version: '2012-10-17'
37.         Statement:
38.         - Effect: 'Allow'
39.           Principal:
40.             Service:
41.             - 'ec2.amazonaws.com'
42.           Action:
43.           - 'sts:AssumeRole'
44.       ManagedPolicyArns:
45.         - 'arn:aws:iam::aws:policy/myCustomerManagedPolicy'
46.   myInstanceProfile:
47.     Type: AWS::IAM::InstanceProfile
48.     Properties:
49.       Path: '/'
50.       Roles:
51.       - !Ref myInstanceRole
```

# Gestisci i gruppi di sicurezza con CloudFormation
<a name="quickref-ec2-sg"></a>

I seguenti frammenti mostrano come gestire i gruppi CloudFormation di sicurezza e le istanze Amazon EC2 per controllare l'accesso alle risorse. AWS 

**Topics**
+ [Associazione di un gruppo di sicurezza a un’istanza Amazon EC2](#quickref-ec2-instances-associate-security-group)
+ [Creazione di gruppi di sicurezza con regole di ingresso](#quickref-ec2-instances-ingress)
+ [Creazione di un Elastic Load Balancer con una regola di ingresso al gruppo di sicurezza](#scenario-ec2-security-group-elbingress)

## Associazione di un gruppo di sicurezza a un’istanza Amazon EC2
<a name="quickref-ec2-instances-associate-security-group"></a>

I seguenti frammenti di esempio mostrano come associare un'istanza Amazon EC2 a un gruppo di sicurezza Amazon VPC predefinito utilizzando CloudFormation.

**Topics**
+ [Associazione di un gruppo di sicurezza VPC predefinito a un’istanza Amazon EC2](#using-cfn-getatt-default-values)
+ [Creazione di un’istanza Amazon EC2 con un volume e un gruppo di sicurezza collegati](#scenario-ec2-volumeattachment)

### Associazione di un gruppo di sicurezza VPC predefinito a un’istanza Amazon EC2
<a name="using-cfn-getatt-default-values"></a>

Il seguente frammento crea un Amazon VPC, una sottorete all’interno del VPC e un’istanza Amazon EC2. Il VPC viene creato utilizzando una risorsa [AWS::EC2::VPC](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-vpc.html). L’intervallo di indirizzi IP per il VPC è definito nel modello più grande e viene richiamato dal parametro `MyVPCCIDRRange`.

Una sottorete viene creata all’interno del VPC utilizzando una risorsa [AWS::EC2::Subnet](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-subnet.html). La sottorete è associata al VPC, a cui si fa riferimento come `MyVPC`.

Un'istanza EC2 viene avviata all'interno del VPC e della sottorete utilizzando una risorsa. [AWS::EC2::Instance](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-instance.html) Questa risorsa specifica l’Amazon Machine Image (AMI) da utilizzare per avviare l’istanza, la sottorete in cui verrà eseguita l’istanza e il gruppo di sicurezza da associare all’istanza. `ImageId` utilizza un parametro Systems Manager per recuperare dinamicamente l’ultima AMI Amazon Linux 2. 

L’ID del gruppo di sicurezza viene ottenuto utilizzando la funzione `Fn::GetAtt`, che recupera il gruppo di sicurezza predefinito dalla risorsa `MyVPC`. 

L’istanza viene inserita all’interno della risorsa `MySubnet` definita nel frammento. 

Quando crei un VPC utilizzando CloudFormation, crea AWS automaticamente risorse predefinite all'interno del VPC, incluso un gruppo di sicurezza predefinito. Tuttavia, quando si definisce un VPC all'interno di un CloudFormation modello, è possibile che non si abbia accesso a queste risorse predefinite al momento IDs della creazione del modello. Per accedere e utilizzare le risorse predefinite specificate nel modello, puoi utilizzare funzioni intrinseche come `Fn::GetAtt`. Questa funzione consente di lavorare con le risorse predefinite create automaticamente da CloudFormation.

#### JSON
<a name="quickref-ec2-example-15.json"></a>

```
"MyVPC": {
    "Type": "AWS::EC2::VPC",
    "Properties": {
        "CidrBlock": {
            "Ref": "MyVPCCIDRRange"
        },
        "EnableDnsSupport": false,
        "EnableDnsHostnames": false,
        "InstanceTenancy": "default"
    }
},
"MySubnet": {
    "Type": "AWS::EC2::Subnet",
    "Properties": {
        "CidrBlock": {
            "Ref": "MyVPCCIDRRange"
        },
        "VpcId": {
            "Ref": "MyVPC"
        }
    }
},
"MyInstance": {
    "Type": "AWS::EC2::Instance",
    "Properties": {
        "ImageId": "{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}",
        "SecurityGroupIds": [
            {
                "Fn::GetAtt": [
                    "MyVPC",
                    "DefaultSecurityGroup"
                ]
            }
        ],
        "SubnetId": {
            "Ref": "MySubnet"
        }
    }
}
```

#### YAML
<a name="quickref-ec2-example-15.yaml"></a>

```
MyVPC:
  Type: AWS::EC2::VPC
  Properties:
    CidrBlock:
      Ref: MyVPCCIDRRange
    EnableDnsSupport: false
    EnableDnsHostnames: false
    InstanceTenancy: default
MySubnet:
  Type: AWS::EC2::Subnet
  Properties:
    CidrBlock:
      Ref: MyVPCCIDRRange
    VpcId:
      Ref: MyVPC
MyInstance:
  Type: AWS::EC2::Instance
  Properties:
    ImageId: '{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}'
    SecurityGroupIds:
      - Fn::GetAtt:
          - MyVPC
          - DefaultSecurityGroup
    SubnetId:
      Ref: MySubnet
```

### Creazione di un’istanza Amazon EC2 con un volume e un gruppo di sicurezza collegati
<a name="scenario-ec2-volumeattachment"></a>

Il seguente frammento crea un'istanza Amazon EC2 utilizzando una risorsa, che viene lanciata da [AWS::EC2::Instance](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-instance.html)un'AMI designata. L'istanza è associata a un gruppo di sicurezza che consente il traffico SSH in entrata sulla porta 22 da un indirizzo IP specificato, utilizzando una risorsa. [AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html) Crea un volume Amazon EBS da 100 GB utilizzando una [AWS::EC2::Volume](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-volume.html)risorsa. Il volume viene creato nella stessa zona di disponibilità dell’istanza, come specificato dalla funzione `GetAtt`, e viene montato sull’istanza sul dispositivo `/dev/sdh`.

Per ulteriori informazioni sulla creazione di volumi Amazon EBS, consulta [Creazione di un volume Amazon EBS](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-creating-volume.html).

#### JSON
<a name="quickref-ec2-example-14.json"></a>

```
 1. "Ec2Instance": {
 2.     "Type": "AWS::EC2::Instance",
 3.     "Properties": {
 4.         "SecurityGroups": [
 5.             {
 6.                 "Ref": "InstanceSecurityGroup"
 7.             }
 8.         ],
 9.         "ImageId": "ami-1234567890abcdef0"
10.     }
11. },
12. "InstanceSecurityGroup": {
13.     "Type": "AWS::EC2::SecurityGroup",
14.     "Properties": {
15.         "GroupDescription": "Enable SSH access via port 22",
16.         "SecurityGroupIngress": [
17.             {
18.                 "IpProtocol": "tcp",
19.                 "FromPort": "22",
20.                 "ToPort": "22",
21.                 "CidrIp": "192.0.2.0/24"
22.             }
23.         ]
24.     }
25. },
26. "NewVolume": {
27.     "Type": "AWS::EC2::Volume",
28.     "Properties": {
29.         "Size": "100",
30.         "AvailabilityZone": {
31.             "Fn::GetAtt": [
32.                 "Ec2Instance",
33.                 "AvailabilityZone"
34.             ]
35.         }
36.     }
37. },
38. "MountPoint": {
39.     "Type": "AWS::EC2::VolumeAttachment",
40.     "Properties": {
41.         "InstanceId": {
42.             "Ref": "Ec2Instance"
43.         },
44.         "VolumeId": {
45.             "Ref": "NewVolume"
46.         },
47.         "Device": "/dev/sdh"
48.     }
49. }
```

#### YAML
<a name="quickref-ec2-example-14.yaml"></a>

```
 1. Ec2Instance:
 2.   Type: AWS::EC2::Instance
 3.   Properties:
 4.     SecurityGroups:
 5.       - !Ref InstanceSecurityGroup
 6.     ImageId: ami-1234567890abcdef0
 7. InstanceSecurityGroup:
 8.   Type: AWS::EC2::SecurityGroup
 9.   Properties:
10.     GroupDescription: Enable SSH access via port 22
11.     SecurityGroupIngress:
12.       - IpProtocol: tcp
13.         FromPort: 22
14.         ToPort: 22
15.         CidrIp: 192.0.2.0/24
16. NewVolume:
17.   Type: AWS::EC2::Volume
18.   Properties:
19.     Size: 100
20.     AvailabilityZone: !GetAtt [Ec2Instance, AvailabilityZone]
21. MountPoint:
22.   Type: AWS::EC2::VolumeAttachment
23.   Properties:
24.     InstanceId: !Ref Ec2Instance
25.     VolumeId: !Ref NewVolume
26.     Device: /dev/sdh
```

## Creazione di gruppi di sicurezza con regole di ingresso
<a name="quickref-ec2-instances-ingress"></a>

I frammenti di esempio seguenti mostrano come configurare i gruppi di sicurezza con regole di ingresso specifiche utilizzando CloudFormation.

**Topics**
+ [Creazione di un gruppo di sicurezza con regole di ingresso per l’accesso SSH e HTTP](#scenario-ec2-security-group-rule)
+ [Creazione di un gruppo di sicurezza con regole di ingresso per l’accesso HTTP e SSH da intervalli CIDR specificati](#scenario-ec2-security-group-two-ports)
+ [Crea gruppi di sicurezza con riferimenti incrociati e regole di ingresso](#scenario-ec2-security-group-ingress)

### Creazione di un gruppo di sicurezza con regole di ingresso per l’accesso SSH e HTTP
<a name="scenario-ec2-security-group-rule"></a>

Il seguente frammento descrive due regole di ingresso per gruppi di sicurezza che utilizzano una risorsa. [AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html) La prima regola di ingresso consente l'accesso SSH (porta 22) da un gruppo di sicurezza esistente denominato`MyAdminSecurityGroup`, di proprietà dell'account con il numero di AWS account. `1111-2222-3333` La seconda regola di ingresso consente l’accesso HTTP (porta 80) da un gruppo di sicurezza diverso denominato `MySecurityGroupCreatedInCFN`, creato nello stesso modello. La funzione `Ref` viene utilizzata per fare riferimento al nome logico del gruppo di sicurezza creato nello stesso modello. 

Nella prima regola di ingresso, è necessario aggiungere un valore per entrambe le proprietà `SourceSecurityGroupName` e `SourceSecurityGroupOwnerId`. Nella seconda regola di ingresso, `MySecurityGroupCreatedInCFNTemplate` fa riferimento a un gruppo di sicurezza diverso, creato nello stesso modello. Verifica che il nome logico `MySecurityGroupCreatedInCFNTemplate` corrisponda al nome logico effettivo della risorsa del gruppo di sicurezza specificata nel modello più grande. 

Per ulteriori informazioni sui gruppi di sicurezza, consulta [Amazon EC2 security groups for your Amazon EC2 instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html) nella *Guida per l’utente di Amazon EC2*.

#### JSON
<a name="quickref-ec2-example-10.json"></a>

```
 1. "SecurityGroup": {
 2.     "Type": "AWS::EC2::SecurityGroup",
 3.     "Properties": {
 4.         "GroupDescription": "Allow connections from specified source security group",
 5.         "SecurityGroupIngress": [
 6.             {
 7.                 "IpProtocol": "tcp",
 8.                 "FromPort": "22",
 9.                 "ToPort": "22",
10.                 "SourceSecurityGroupName": "MyAdminSecurityGroup",
11.                 "SourceSecurityGroupOwnerId": "1111-2222-3333"
12.             },
13.             {
14.                 "IpProtocol": "tcp",
15.                 "FromPort": "80",
16.                 "ToPort": "80",
17.                 "SourceSecurityGroupName": {
18.                     "Ref": "MySecurityGroupCreatedInCFNTemplate"
19.                 }
20.             }
21.         ]
22.     }
23. }
```

#### YAML
<a name="quickref-ec2-example-10.yaml"></a>

```
 1. SecurityGroup:
 2.   Type: AWS::EC2::SecurityGroup
 3.   Properties:
 4.     GroupDescription: Allow connections from specified source security group
 5.     SecurityGroupIngress:
 6.       - IpProtocol: tcp
 7.         FromPort: '22'
 8.         ToPort: '22'
 9.         SourceSecurityGroupName: MyAdminSecurityGroup
10.         SourceSecurityGroupOwnerId: '1111-2222-3333'
11.       - IpProtocol: tcp
12.         FromPort: '80'
13.         ToPort: '80'
14.         SourceSecurityGroupName:
15.           Ref: MySecurityGroupCreatedInCFNTemplate
```

### Creazione di un gruppo di sicurezza con regole di ingresso per l’accesso HTTP e SSH da intervalli CIDR specificati
<a name="scenario-ec2-security-group-two-ports"></a>

Il seguente frammento crea un gruppo di sicurezza per un’istanza Amazon EC2 con due regole in entrata. Le regole in entrata consentono il traffico TCP in ingresso sulle porte specificate dagli intervalli CIDR designati. Viene utilizzata una [AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html)risorsa per specificare le regole. È possibile specificare un protocollo per ciascuna regola. Per TCP, è necessario anche specificare una porta o un intervallo di porte. Se non si specifica un gruppo di sicurezza di origine o un intervallo CIDR, lo stack verrà avviato correttamente, ma la regola non verrà applicata al gruppo di sicurezza. 

Per ulteriori informazioni sui gruppi di sicurezza, consulta [Amazon EC2 security groups for your Amazon EC2 instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html) nella *Guida per l’utente di Amazon EC2*.

#### JSON
<a name="quickref-ec2-example-9.json"></a>

```
 1. "ServerSecurityGroup": {
 2.   "Type": "AWS::EC2::SecurityGroup",
 3.   "Properties": {
 4.     "GroupDescription": "Allow connections from specified CIDR ranges",
 5.     "SecurityGroupIngress": [
 6.       {
 7.         "IpProtocol": "tcp",
 8.         "FromPort": "80",
 9.         "ToPort": "80",
10.         "CidrIp": "192.0.2.0/24"
11.       },
12.       {
13.         "IpProtocol": "tcp",
14.         "FromPort": "22",
15.         "ToPort": "22",
16.         "CidrIp": "192.0.2.0/24"
17.       }
18.     ]
19.   }
20. }
```

#### YAML
<a name="quickref-ec2-example-9.yaml"></a>

```
 1. ServerSecurityGroup:
 2.   Type: AWS::EC2::SecurityGroup
 3.   Properties:
 4.     GroupDescription: Allow connections from specified CIDR ranges
 5.     SecurityGroupIngress:
 6.       - IpProtocol: tcp
 7.         FromPort: 80
 8.         ToPort: 80
 9.         CidrIp: 192.0.2.0/24
10.       - IpProtocol: tcp
11.         FromPort: 22
12.         ToPort: 22
13.         CidrIp: 192.0.2.0/24
```

### Crea gruppi di sicurezza con riferimenti incrociati e regole di ingresso
<a name="scenario-ec2-security-group-ingress"></a>

Il seguente frammento utilizza la [AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html)risorsa per creare due gruppi di sicurezza Amazon EC2 e. `SGroup1` `SGroup2` [Le regole di ingresso che consentono la comunicazione tra i due gruppi di sicurezza vengono create utilizzando la risorsa Ingress. AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroupingress.html) `SGroup1Ingress`stabilisce una regola di ingresso `SGroup1` che consente il traffico TCP in entrata sulla porta 80 dal gruppo di sicurezza di origine,. `SGroup2` `SGroup2Ingress`stabilisce una regola di ingresso `SGroup2` che consente il traffico TCP in entrata sulla porta 80 dal gruppo di sicurezza di origine,. `SGroup1` 

#### JSON
<a name="quickref-ec2-example-12.json"></a>

```
 1. "SGroup1": {
 2.     "Type": "AWS::EC2::SecurityGroup",
 3.     "Properties": {
 4.         "GroupDescription": "EC2 instance access"
 5.     }
 6. },
 7. "SGroup2": {
 8.     "Type": "AWS::EC2::SecurityGroup",
 9.     "Properties": {
10.         "GroupDescription": "EC2 instance access"
11.     }
12. },
13. "SGroup1Ingress": {
14.     "Type": "AWS::EC2::SecurityGroupIngress",
15.     "Properties": {
16.         "GroupName": {
17.             "Ref": "SGroup1"
18.         },
19.         "IpProtocol": "tcp",
20.         "ToPort": "80",
21.         "FromPort": "80",
22.         "SourceSecurityGroupName": {
23.             "Ref": "SGroup2"
24.         }
25.     }
26. },
27. "SGroup2Ingress": {
28.     "Type": "AWS::EC2::SecurityGroupIngress",
29.     "Properties": {
30.         "GroupName": {
31.             "Ref": "SGroup2"
32.         },
33.         "IpProtocol": "tcp",
34.         "ToPort": "80",
35.         "FromPort": "80",
36.         "SourceSecurityGroupName": {
37.             "Ref": "SGroup1"
38.         }
39.     }
40. }
```

#### YAML
<a name="quickref-ec2-example-12.yaml"></a>

```
 1. SGroup1:
 2.   Type: AWS::EC2::SecurityGroup
 3.   Properties:
 4.     GroupDescription: EC2 Instance access
 5. SGroup2:
 6.   Type: AWS::EC2::SecurityGroup
 7.   Properties:
 8.     GroupDescription: EC2 Instance access
 9. SGroup1Ingress:
10.   Type: AWS::EC2::SecurityGroupIngress
11.   Properties:
12.     GroupName: !Ref SGroup1
13.     IpProtocol: tcp
14.     ToPort: 80
15.     FromPort: 80
16.     SourceSecurityGroupName: !Ref SGroup2
17. SGroup2Ingress:
18.   Type: AWS::EC2::SecurityGroupIngress
19.   Properties:
20.     GroupName: !Ref SGroup2
21.     IpProtocol: tcp
22.     ToPort: 80
23.     FromPort: 80
24.     SourceSecurityGroupName: !Ref SGroup1
```

## Creazione di un Elastic Load Balancer con una regola di ingresso al gruppo di sicurezza
<a name="scenario-ec2-security-group-elbingress"></a>

Il modello seguente crea una [AWS::ElasticLoadBalancing::LoadBalancer](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancing-loadbalancer.html)risorsa nella zona di disponibilità specificata. La [AWS::ElasticLoadBalancing::LoadBalancer](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancing-loadbalancer.html)risorsa è configurata per ascoltare il traffico HTTP sulla porta 80 e indirizzare le richieste alle istanze anche sulla porta 80. Elastic Load Balancer è responsabile del bilanciamento del carico del traffico HTTP in entrata tra le istanze.

 Inoltre, questo modello genera una [AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html)risorsa associata al load balancer. Questo gruppo di sicurezza viene creato con un’unica regola di ingresso, descritta come `ELB ingress group`, che consente il traffico TCP in entrata sulla porta 80. L’origine di questa regola di ingresso viene definita utilizzando la funzione `Fn::GetAtt` per recuperare gli attributi dalla risorsa di bilanciamento del carico. `SourceSecurityGroupOwnerId` utilizza `Fn::GetAtt` per ottenere l’`OwnerAlias` del gruppo di sicurezza di origine del bilanciatore del carico. `SourceSecurityGroupName` utilizza `Fn::Getatt` per ottenere il `GroupName` del gruppo di sicurezza di origine dell’ELB. 

Questa configurazione garantisce una comunicazione sicura tra l’ELB e le istanze. 

Per ulteriori informazioni su Elastic Load Balancing, consulta la [Guida per l’utente di Elastic Load Balancing](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/).

### JSON
<a name="quickref-ec2-example-11.json"></a>

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Resources": {
        "MyELB": {
            "Type": "AWS::ElasticLoadBalancing::LoadBalancer",
            "Properties": {
                "AvailabilityZones": [
                    "aa-example-1a"
                ],
                "Listeners": [
                    {
                        "LoadBalancerPort": "80",
                        "InstancePort": "80",
                        "Protocol": "HTTP"
                    }
                ]
            }
        },
        "MyELBIngressGroup": {
            "Type": "AWS::EC2::SecurityGroup",
            "Properties": {
                "GroupDescription": "ELB ingress group",
                "SecurityGroupIngress": [
                    {
                        "IpProtocol": "tcp",
                        "FromPort": 80,
                        "ToPort": 80,
                        "SourceSecurityGroupOwnerId": {
                            "Fn::GetAtt": [
                                "MyELB",
                                "SourceSecurityGroup.OwnerAlias"
                            ]
                        },
                        "SourceSecurityGroupName": {
                            "Fn::GetAtt": [
                                "MyELB",
                                "SourceSecurityGroup.GroupName"
                            ]
                        }
                    }
                ]
            }
        }
    }
}
```

### YAML
<a name="quickref-ec2-example-11.yaml"></a>

```
AWSTemplateFormatVersion: '2010-09-09'
Resources:
  MyELB:
    Type: AWS::ElasticLoadBalancing::LoadBalancer
    Properties:
      AvailabilityZones:
        - aa-example-1a
      Listeners:
        - LoadBalancerPort: '80'
          InstancePort: '80'
          Protocol: HTTP
  MyELBIngressGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: ELB ingress group
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: '80'
          ToPort: '80'
          SourceSecurityGroupOwnerId:
            Fn::GetAtt:
              - MyELB
              - SourceSecurityGroup.OwnerAlias
          SourceSecurityGroupName:
            Fn::GetAtt:
              - MyELB
              - SourceSecurityGroup.GroupName
```

# Alloca e associa indirizzi IP elastici con CloudFormation
<a name="quickref-ec2-elastic-ip"></a>

I seguenti frammenti di modello sono esempi relativi agli indirizzi IP elastici (EIP) in Amazon EC2. Questi esempi riguardano l'allocazione, l'associazione e la gestione delle istanze. EIPs 

**Topics**
+ [Allocazione di un indirizzo IP elastico e relativa associazione a un’istanza Amazon EC2](#scenario-ec2-eip)
+ [Associazione di un indirizzo IP elastico a un’istanza Amazon EC2 specificando l’indirizzo IP](#scenario-ec2-eip-association)
+ [Associazione di un indirizzo IP elastico a un’istanza Amazon EC2 specificando l’ID di allocazione dell’indirizzo IP](#scenario-ec2-eip-association-vpc)

## Allocazione di un indirizzo IP elastico e relativa associazione a un’istanza Amazon EC2
<a name="scenario-ec2-eip"></a>

Il seguente frammento alloca un indirizzo Amazon EC2 Elastic IP (EIP) e lo associa a un'istanza Amazon EC2 utilizzando una risorsa. [AWS::EC2::EIP ](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-eip.html) [Puoi allocare un indirizzo EIP da un pool di indirizzi di proprietà AWS o proveniente da un pool di indirizzi creato da un intervallo di indirizzi pubblico da te utilizzato AWS per utilizzarlo con AWS le tue risorse utilizzando i tuoi IPv4 indirizzi IP personali (BYOIP).](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-byoip.html) In questo esempio, l'EIP viene allocato da un pool di indirizzi di proprietà di. AWS

Per maggiori informazioni sugli indirizzi IP elastici, consulta [Indirizzo IP elastico](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/elastic-ip-addresses-eip.html) nella *Guida per l’utente di Amazon EC2*.

### JSON
<a name="quickref-ec2-example-3.json"></a>

```
1. "ElasticIP": {
2.     "Type": "AWS::EC2::EIP",
3.     "Properties": {
4.         "InstanceId": {
5.             "Ref": "Ec2Instance"
6.         }
7.     }
8. }
```

### YAML
<a name="quickref-ec2-example-3.yaml"></a>

```
1. ElasticIP:
2.   Type: AWS::EC2::EIP
3.   Properties:
4.     InstanceId: !Ref EC2Instance
```

## Associazione di un indirizzo IP elastico a un’istanza Amazon EC2 specificando l’indirizzo IP
<a name="scenario-ec2-eip-association"></a>

Il seguente frammento associa un indirizzo IP elastico Amazon EC2 esistente a un'istanza EC2 utilizzando una risorsa [AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-eipassociation.html): :EC2::. EIPAssociation Per utilizzare un indirizzo IP elastico, occorre prima allocarlo per l’uso nel proprio account. Un indirizzo IP elastico può essere associato a un’istanza singola.

### JSON
<a name="quickref-ec2-example-4.json"></a>

```
1. "IPAssoc": {
2.   "Type": "AWS::EC2::EIPAssociation",
3.   "Properties": {
4.     "InstanceId": {
5.       "Ref": "Ec2Instance"
6.     },
7.     "EIP": "192.0.2.0"
8.   }
9. }
```

### YAML
<a name="quickref-ec2-example-4.yaml"></a>

```
1. IPAssoc:
2.   Type: AWS::EC2::EIPAssociation
3.   Properties:
4.     InstanceId: !Ref EC2Instance
5.     EIP: 192.0.2.0
```

## Associazione di un indirizzo IP elastico a un’istanza Amazon EC2 specificando l’ID di allocazione dell’indirizzo IP
<a name="scenario-ec2-eip-association-vpc"></a>

[Il seguente frammento associa un indirizzo IP elastico esistente a un'istanza Amazon EC2 specificando l'ID di allocazione utilizzando una risorsa AWS: :EC2::. EIPAssociation](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-eipassociation.html) Un ID di allocazione viene assegnato a un indirizzo IP elastico al momento dell’allocazione dell’indirizzo IP elastico. 

### JSON
<a name="quickref-ec2-example-5.json"></a>

```
1. "IPAssoc": {
2.     "Type": "AWS::EC2::EIPAssociation",
3.     "Properties": {
4.         "InstanceId": {
5.             "Ref": "Ec2Instance"
6.         },
7.         "AllocationId": "eipalloc-1234567890abcdef0"
8.     }
9. }
```

### YAML
<a name="quickref-ec2-example-5.yaml"></a>

```
1. IPAssoc:
2.   Type: AWS::EC2::EIPAssociation
3.   Properties:
4.     InstanceId: !Ref EC2Instance
5.     AllocationId: eipalloc-1234567890abcdef0
```

# Configura le risorse Amazon VPC con CloudFormation
<a name="quickref-ec2-vpc"></a>

Questa sezione fornisce esempi per configurare le risorse Amazon VPC utilizzando. CloudFormation VPCsconsentono di creare una rete virtuale all'interno AWS di una rete virtuale e questi frammenti mostrano come configurare alcuni aspetti per VPCs soddisfare i requisiti di rete. 

**Topics**
+ [Abilita l'accesso a Internet IPv6 solo in uscita in un VPC](#quickref-ec2-route-egressonlyinternetgateway)
+ [Frammenti di modello di interfaccia di rete elastica (ENI)](#cfn-template-snippets-eni)

## Abilita l'accesso a Internet IPv6 solo in uscita in un VPC
<a name="quickref-ec2-route-egressonlyinternetgateway"></a>

Un gateway Internet solo in uscita consente alle istanze all’interno di un VPC di accedere a Internet e impedire che le risorse su Internet comunichino con le istanze. Il seguente frammento consente l'accesso a Internet IPv6 solo in uscita dall'interno di un VPC. Crea un VPC con un intervallo di IPv4 indirizzi `10.0.0/16` utilizzando una risorsa [AWS: :EC2: :VPC](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-vpc.html). Una tabella di routing è associata a questa risorsa VPC utilizzando una [AWS::EC2::RouteTable](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-routetable.html)risorsa. La tabella di routing gestisce i percorsi per le istanze all’interno del VPC. An [AWS::EC2::EgressOnlyInternetGateway](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-egressonlyinternetgateway.html)viene utilizzato per creare un gateway Internet solo in uscita per consentire la IPv6 comunicazione per il traffico in uscita dalle istanze all'interno del VPC, impedendo al contempo il traffico in entrata. Viene specificata una [AWS::EC2::Route](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-route.html)risorsa per creare un IPv6 percorso nella tabella delle rotte che indirizza tutto il traffico in uscita () verso il gateway Internet di sola uscita IPv6. `::/0` 

*Per ulteriori informazioni sui gateway Internet solo in uscita, consulta [Abilitare il IPv6 traffico in uscita utilizzando un gateway Internet solo in uscita nella Amazon VPC User](https://docs.aws.amazon.com/vpc/latest/userguide/egress-only-internet-gateway.html) Guide.*

### JSON
<a name="quickref-ec2-example-16.json"></a>

```
"DefaultIpv6Route": {
    "Type": "AWS::EC2::Route",
    "Properties": {
        "DestinationIpv6CidrBlock": "::/0",
        "EgressOnlyInternetGatewayId": {
            "Ref": "EgressOnlyInternetGateway"
        },
        "RouteTableId": {
            "Ref": "RouteTable"
        }
    }
},
"EgressOnlyInternetGateway": {
    "Type": "AWS::EC2::EgressOnlyInternetGateway",
    "Properties": {
        "VpcId": {
            "Ref": "VPC"
        }
    }
},
"RouteTable": {
    "Type": "AWS::EC2::RouteTable",
    "Properties": {
        "VpcId": {
            "Ref": "VPC"
        }
    }
},
"VPC": {
    "Type": "AWS::EC2::VPC",
    "Properties": {
        "CidrBlock": "10.0.0.0/16"
    }
}
```

### YAML
<a name="quickref-ec2-example-16.yaml"></a>

```
DefaultIpv6Route:
  Type: AWS::EC2::Route
  Properties:
    DestinationIpv6CidrBlock: "::/0"
    EgressOnlyInternetGatewayId:
      Ref: "EgressOnlyInternetGateway"
    RouteTableId:
      Ref: "RouteTable"
EgressOnlyInternetGateway:
  Type: AWS::EC2::EgressOnlyInternetGateway
  Properties:
    VpcId:
      Ref: "VPC"
RouteTable:
  Type: AWS::EC2::RouteTable
  Properties:
    VpcId:
      Ref: "VPC"
VPC:
  Type: AWS::EC2::VPC
  Properties:
    CidrBlock: "10.0.0.0/16"
```

## Frammenti di modello di interfaccia di rete elastica (ENI)
<a name="cfn-template-snippets-eni"></a>

### Crea un'istanza Amazon EC2 con interfacce di rete elastiche collegate () ENIs
<a name="cfn-template-snippets-eni-template"></a>

Il seguente frammento di esempio crea un’istanza Amazon EC2 utilizzando una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-instance.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-instance.html) nella sottorete e nell’Amazon VPC specificati. Collega due interfacce di rete (ENIs) all'istanza, associa gli indirizzi IP elastici alle istanze tramite l'interfaccia allegata ENIs e configura il gruppo di sicurezza per l'accesso SSH e HTTP. I dati utente vengono forniti all’istanza come parte della configurazione di avvio al momento della creazione dell’istanza. I dati utente includono uno script codificato in formato `base64` per garantire che venga passato all’istanza. All’avvio dell’istanza, lo script viene eseguito automaticamente come parte del processo di bootstrap. Installa `ec2-net-utils`, configura le interfacce di rete e avvia il servizio HTTP. 

Per determinare l’Amazon Machine Image (AMI) appropriata in base alla Regione selezionata, il frammento utilizza una funzione `Fn::FindInMap` che cerca i valori in una mappatura `RegionMap`. Questa mappatura deve essere definita nel modello più grande. Le due interfacce di rete vengono create utilizzando risorse [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-networkinterface.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-networkinterface.html). Gli indirizzi IP elastici vengono specificati utilizzando risorse [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-eip.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-eip.html) allocate al dominio `vpc`. Questi indirizzi IP elastici sono associati alle interfacce di rete utilizzando risorse [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-eipassociation.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-eipassociation.html). 

La sezione `Outputs` definisce i valori o le risorse a cui si desidera accedere dopo la creazione dello stack. In questo frammento, l’output definito è `InstancePublicIp`, che rappresenta l’indirizzo IP pubblico dell’istanza EC2 creata dallo stack. **[È possibile recuperare questo output nella scheda Output della CloudFormation console o utilizzando il comando describe-stacks.](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-stacks.html)** 

Per ulteriori informazioni sulle interfacce di rete elastiche, consulta [Interfacce di rete Elastiche](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-eni.html).

#### JSON
<a name="cfn-template-snippets-eni-example-1.json"></a>

```
"Resources": {
    "ControlPortAddress": {
        "Type": "AWS::EC2::EIP",
        "Properties": {
            "Domain": "vpc"
        }
    },
    "AssociateControlPort": {
        "Type": "AWS::EC2::EIPAssociation",
        "Properties": {
            "AllocationId": {
                "Fn::GetAtt": [
                    "ControlPortAddress",
                    "AllocationId"
                ]
            },
            "NetworkInterfaceId": {
                "Ref": "controlXface"
            }
        }
    },
    "WebPortAddress": {
        "Type": "AWS::EC2::EIP",
        "Properties": {
            "Domain": "vpc"
        }
    },
    "AssociateWebPort": {
        "Type": "AWS::EC2::EIPAssociation",
        "Properties": {
            "AllocationId": {
                "Fn::GetAtt": [
                    "WebPortAddress",
                    "AllocationId"
                ]
            },
            "NetworkInterfaceId": {
                "Ref": "webXface"
            }
        }
    },
    "SSHSecurityGroup": {
        "Type": "AWS::EC2::SecurityGroup",
        "Properties": {
            "VpcId": {
                "Ref": "VpcId"
            },
            "GroupDescription": "Enable SSH access via port 22",
            "SecurityGroupIngress": [
                {
                    "CidrIp": "0.0.0.0/0",
                    "FromPort": 22,
                    "IpProtocol": "tcp",
                    "ToPort": 22
                }
            ]
        }
    },
    "WebSecurityGroup": {
        "Type": "AWS::EC2::SecurityGroup",
        "Properties": {
            "VpcId": {
                "Ref": "VpcId"
            },
            "GroupDescription": "Enable HTTP access via user-defined port",
            "SecurityGroupIngress": [
                {
                    "CidrIp": "0.0.0.0/0",
                    "FromPort": 80,
                    "IpProtocol": "tcp",
                    "ToPort": 80
                }
            ]
        }
    },
    "controlXface": {
        "Type": "AWS::EC2::NetworkInterface",
        "Properties": {
            "SubnetId": {
                "Ref": "SubnetId"
            },
            "Description": "Interface for controlling traffic such as SSH",
            "GroupSet": [
                {
                    "Fn::GetAtt": [
                        "SSHSecurityGroup",
                        "GroupId"
                    ]
                }
            ],
            "SourceDestCheck": true,
            "Tags": [
                {
                    "Key": "Network",
                    "Value": "Control"
                }
            ]
        }
    },
    "webXface": {
        "Type": "AWS::EC2::NetworkInterface",
        "Properties": {
            "SubnetId": {
                "Ref": "SubnetId"
            },
            "Description": "Interface for web traffic",
            "GroupSet": [
                {
                    "Fn::GetAtt": [
                        "WebSecurityGroup",
                        "GroupId"
                    ]
                }
            ],
            "SourceDestCheck": true,
            "Tags": [
                {
                    "Key": "Network",
                    "Value": "Web"
                }
            ]
        }
    },
    "Ec2Instance": {
        "Type": "AWS::EC2::Instance",
        "Properties": {
            "ImageId": {
                "Fn::FindInMap": [
                    "RegionMap",
                    {
                        "Ref": "AWS::Region"
                    },
                    "AMI"
                ]
            },
            "KeyName": {
                "Ref": "KeyName"
            },
            "NetworkInterfaces": [
                {
                    "NetworkInterfaceId": {
                        "Ref": "controlXface"
                    },
                    "DeviceIndex": "0"
                },
                {
                    "NetworkInterfaceId": {
                        "Ref": "webXface"
                    },
                    "DeviceIndex": "1"
                }
            ],
            "Tags": [
                {
                    "Key": "Role",
                    "Value": "Test Instance"
                }
            ],
            "UserData": {
                "Fn::Base64": {
                    "Fn::Sub": "#!/bin/bash -xe\nyum install ec2-net-utils -y\nec2ifup eth1\nservice httpd start\n"
                }
            }
        }
    }
},
"Outputs": {
    "InstancePublicIp": {
        "Description": "Public IP Address of the EC2 Instance",
        "Value": {
            "Fn::GetAtt": [
                "Ec2Instance",
                "PublicIp"
            ]
        }
    }
}
```

#### YAML
<a name="cfn-template-snippets-eni-example.yaml"></a>

```
Resources:
  ControlPortAddress:
    Type: AWS::EC2::EIP
    Properties:
      Domain: vpc
  AssociateControlPort:
    Type: AWS::EC2::EIPAssociation
    Properties:
      AllocationId:
        Fn::GetAtt:
          - ControlPortAddress
          - AllocationId
      NetworkInterfaceId:
        Ref: controlXface
  WebPortAddress:
    Type: AWS::EC2::EIP
    Properties:
      Domain: vpc
  AssociateWebPort:
    Type: AWS::EC2::EIPAssociation
    Properties:
      AllocationId:
        Fn::GetAtt:
          - WebPortAddress
          - AllocationId
      NetworkInterfaceId:
        Ref: webXface
  SSHSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      VpcId:
        Ref: VpcId
      GroupDescription: Enable SSH access via port 22
      SecurityGroupIngress:
        - CidrIp: 0.0.0.0/0
          FromPort: 22
          IpProtocol: tcp
          ToPort: 22
  WebSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      VpcId:
        Ref: VpcId
      GroupDescription: Enable HTTP access via user-defined port
      SecurityGroupIngress:
        - CidrIp: 0.0.0.0/0
          FromPort: 80
          IpProtocol: tcp
          ToPort: 80
  controlXface:
    Type: AWS::EC2::NetworkInterface
    Properties:
      SubnetId:
        Ref: SubnetId
      Description: Interface for controlling traffic such as SSH
      GroupSet:
        - Fn::GetAtt:
            - SSHSecurityGroup
            - GroupId
      SourceDestCheck: true
      Tags:
        - Key: Network
          Value: Control
  webXface:
    Type: AWS::EC2::NetworkInterface
    Properties:
      SubnetId:
        Ref: SubnetId
      Description: Interface for web traffic
      GroupSet:
        - Fn::GetAtt:
            - WebSecurityGroup
            - GroupId
      SourceDestCheck: true
      Tags:
        - Key: Network
          Value: Web
  Ec2Instance:
    Type: AWS::EC2::Instance
    Properties:
      ImageId:
        Fn::FindInMap:
          - RegionMap
          - Ref: AWS::Region
          - AMI
      KeyName:
        Ref: KeyName
      NetworkInterfaces:
        - NetworkInterfaceId:
            Ref: controlXface
          DeviceIndex: "0"
        - NetworkInterfaceId:
            Ref: webXface
          DeviceIndex: "1"
      Tags:
        - Key: Role
          Value: Test Instance
      UserData:
        Fn::Base64: !Sub |
          #!/bin/bash -xe
          yum install ec2-net-utils -y
          ec2ifup eth1
          service httpd start
Outputs:
  InstancePublicIp:
    Description: Public IP Address of the EC2 Instance
    Value:
      Fn::GetAtt:
        - Ec2Instance
        - PublicIp
```

# Modelli di esempio di Amazon Elastic Container Service
<a name="quickref-ecs"></a>

Amazon Elastic Container Service (Amazon ECS) è un servizio di gestione dei container che facilita l’esecuzione, l’arresto e la gestione di container Docker in un cluster di istanze Amazon Elastic Compute Cloud (Amazon EC2).

## Crea un cluster con AL2023 Amazon ECS-Optimized-AMI
<a name="create-cluster-al2023"></a>

Definisci un cluster con un provider di capacità che avvia istanze AL2023 su Amazon EC2.

**Importante**  
Per l'AMI più recente IDs, consulta l'AMI ottimizzata per [Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html) nella *Amazon Elastic Container Service Developer Guide*.

### JSON
<a name="quickref-ecs-example-1.json"></a>

```
{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Description": "EC2 ECS cluster that starts out empty, with no EC2 instances yet. An ECS capacity provider automatically launches more EC2 instances as required on the fly when you request ECS to launch services or standalone tasks.",
  "Parameters": {
      "InstanceType": {
          "Type": "String",
          "Description": "EC2 instance type",
          "Default": "t2.medium",
          "AllowedValues": [
              "t1.micro",
              "t2.2xlarge",
              "t2.large",
              "t2.medium",
              "t2.micro",
              "t2.nano",
              "t2.small",
              "t2.xlarge",
              "t3.2xlarge",
              "t3.large",
              "t3.medium",
              "t3.micro",
              "t3.nano",
              "t3.small",
              "t3.xlarge"
          ]
      },
      "DesiredCapacity": {
          "Type": "Number",
          "Default": "0",
          "Description": "Number of EC2 instances to launch in your ECS cluster."
      },
      "MaxSize": {
          "Type": "Number",
          "Default": "100",
          "Description": "Maximum number of EC2 instances that can be launched in your ECS cluster."
      },
      "ECSAMI": {
          "Description": "The Amazon Machine Image ID used for the cluster",
          "Type": "AWS::SSM::Parameter::Value<AWS::EC2::Image::Id>",
          "Default": "/aws/service/ecs/optimized-ami/amazon-linux-2023/recommended/image_id"
      },
      "VpcId": {
          "Type": "AWS::EC2::VPC::Id",
          "Description": "VPC ID where the ECS cluster is launched",
          "Default": "vpc-1234567890abcdef0"
      },
      "SubnetIds": {
          "Type": "List<AWS::EC2::Subnet::Id>",
          "Description": "List of subnet IDs where the EC2 instances will be launched",
          "Default": "subnet-021345abcdef67890"
      }
  },
  "Resources": {
      "ECSCluster": {
          "Type": "AWS::ECS::Cluster",
          "Properties": {
              "ClusterSettings": [
                  {
                      "Name": "containerInsights",
                      "Value": "enabled"
                  }
              ]
          }
      },
      "ECSAutoScalingGroup": {
          "Type": "AWS::AutoScaling::AutoScalingGroup",
          "DependsOn": [
              "ECSCluster",
              "EC2Role"
          ],
          "Properties": {
              "VPCZoneIdentifier": {
                  "Ref": "SubnetIds"
              },
              "LaunchTemplate": {
                  "LaunchTemplateId": {
                      "Ref": "ContainerInstances"
                  },
                  "Version": {
                      "Fn::GetAtt": [
                          "ContainerInstances",
                          "LatestVersionNumber"
                      ]
                  }
              },
              "MinSize": 0,
              "MaxSize": {
                  "Ref": "MaxSize"
              },
              "DesiredCapacity": {
                  "Ref": "DesiredCapacity"
              },
              "NewInstancesProtectedFromScaleIn": true
          },
          "UpdatePolicy": {
              "AutoScalingReplacingUpdate": {
                  "WillReplace": "true"
              }
          }
      },
      "ContainerInstances": {
          "Type": "AWS::EC2::LaunchTemplate",
          "Properties": {
              "LaunchTemplateName": "asg-launch-template",
              "LaunchTemplateData": {
                  "ImageId": {
                      "Ref": "ECSAMI"
                  },
                  "InstanceType": {
                      "Ref": "InstanceType"
                  },
                  "IamInstanceProfile": {
                      "Name": {
                          "Ref": "EC2InstanceProfile"
                      }
                  },
                  "SecurityGroupIds": [
                      {
                          "Ref": "ContainerHostSecurityGroup"
                      }
                  ],
                  "UserData": {
                      "Fn::Base64": {
                          "Fn::Sub": "#!/bin/bash -xe\n echo ECS_CLUSTER=${ECSCluster} >> /etc/ecs/ecs.config\n yum install -y aws-cfn-bootstrap\n /opt/aws/bin/cfn-init -v --stack ${AWS::StackId} --resource ContainerInstances --configsets full_install --region ${AWS::Region} &\n"
                      }
                  },
                  "MetadataOptions": {
                      "HttpEndpoint": "enabled",
                      "HttpTokens": "required"
                  }
              }
          }
      },
      "EC2InstanceProfile": {
          "Type": "AWS::IAM::InstanceProfile",
          "Properties": {
              "Path": "/",
              "Roles": [
                  {
                      "Ref": "EC2Role"
                  }
              ]
          }
      },
      "CapacityProvider": {
          "Type": "AWS::ECS::CapacityProvider",
          "Properties": {
              "AutoScalingGroupProvider": {
                  "AutoScalingGroupArn": {
                      "Ref": "ECSAutoScalingGroup"
                  },
                  "ManagedScaling": {
                      "InstanceWarmupPeriod": 60,
                      "MinimumScalingStepSize": 1,
                      "MaximumScalingStepSize": 100,
                      "Status": "ENABLED",
                      "TargetCapacity": 100
                  },
                  "ManagedTerminationProtection": "ENABLED"
              }
          }
      },
      "CapacityProviderAssociation": {
          "Type": "AWS::ECS::ClusterCapacityProviderAssociations",
          "Properties": {
              "CapacityProviders": [
                  {
                      "Ref": "CapacityProvider"
                  }
              ],
              "Cluster": {
                  "Ref": "ECSCluster"
              },
              "DefaultCapacityProviderStrategy": [
                  {
                      "Base": 0,
                      "CapacityProvider": {
                          "Ref": "CapacityProvider"
                      },
                      "Weight": 1
                  }
              ]
          }
      },
      "ContainerHostSecurityGroup": {
          "Type": "AWS::EC2::SecurityGroup",
          "Properties": {
              "GroupDescription": "Access to the EC2 hosts that run containers",
              "VpcId": {
                  "Ref": "VpcId"
              }
          }
      },
      "EC2Role": {
          "Type": "AWS::IAM::Role",
          "Properties": {
              "AssumeRolePolicyDocument": {
                  "Statement": [
                      {
                          "Effect": "Allow",
                          "Principal": {
                              "Service": [
                                  "ec2.amazonaws.com"
                              ]
                          },
                          "Action": [
                              "sts:AssumeRole"
                          ]
                      }
                  ]
              },
              "Path": "/",
              "ManagedPolicyArns": [
                  "arn:aws:iam::aws:policy/service-role/AmazonEC2ContainerServiceforEC2Role",
                  "arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore"
              ]
          }
      },
      "ECSTaskExecutionRole": {
          "Type": "AWS::IAM::Role",
          "Properties": {
              "AssumeRolePolicyDocument": {
                  "Statement": [
                      {
                          "Effect": "Allow",
                          "Principal": {
                              "Service": [
                                  "ecs-tasks.amazonaws.com"
                              ]
                          },
                          "Action": [
                              "sts:AssumeRole"
                          ],
                          "Condition": {
                              "ArnLike": {
                                  "aws:SourceArn": {
                                      "Fn::Sub": "arn:${AWS::Partition}:ecs:${AWS::Region}:${AWS::AccountId}:*"
                                  }
                              },
                              "StringEquals": {
                                  "aws:SourceAccount": {
                                        "Fn::Sub": "${AWS::AccountId}"
                                    }
                              }
                          }
                      }
                  ]
              },
              "Path": "/",
              "ManagedPolicyArns": [
                  "arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy"
              ]
          }
      }
  },
  "Outputs": {
      "ClusterName": {
          "Description": "The ECS cluster into which to launch resources",
          "Value": "ECSCluster"
      },
      "ECSTaskExecutionRole": {
          "Description": "The role used to start up a task",
          "Value": "ECSTaskExecutionRole"
      },
      "CapacityProvider": {
          "Description": "The cluster capacity provider that the service should use to request capacity when it wants to start up a task",
          "Value": "CapacityProvider"
      }
  }
}
```

### YAML
<a name="quickref-ecs-example-1.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
Description: EC2 ECS cluster that starts out empty, with no EC2 instances yet.
  An ECS capacity provider automatically launches more EC2 instances as required
  on the fly when you request ECS to launch services or standalone tasks.
Parameters:
  InstanceType:
    Type: String
    Description: EC2 instance type
    Default: "t2.medium"
    AllowedValues:
      - t1.micro
      - t2.2xlarge
      - t2.large
      - t2.medium
      - t2.micro
      - t2.nano
      - t2.small
      - t2.xlarge
      - t3.2xlarge
      - t3.large
      - t3.medium
      - t3.micro
      - t3.nano
      - t3.small
      - t3.xlarge
  DesiredCapacity:
    Type: Number
    Default: "0"
    Description: Number of EC2 instances to launch in your ECS cluster.
  MaxSize:
    Type: Number
    Default: "100"
    Description: Maximum number of EC2 instances that can be launched in your ECS cluster.
  ECSAMI:
    Description: The Amazon Machine Image ID used for the cluster
    Type: AWS::SSM::Parameter::Value<AWS::EC2::Image::Id>
    Default: /aws/service/ecs/optimized-ami/amazon-linux-2023/recommended/image_id
  VpcId:
    Type: AWS::EC2::VPC::Id
    Description: VPC ID where the ECS cluster is launched
    Default: vpc-1234567890abcdef0
  SubnetIds:
    Type: List<AWS::EC2::Subnet::Id>
    Description: List of subnet IDs where the EC2 instances will be launched
    Default: "subnet-021345abcdef67890"
Resources:
# This is authorizes ECS to manage resources on your
  # account on your behalf. This role is likely already created on your account
  # ECSRole:
  #  Type: AWS::IAM::ServiceLinkedRole
  #  Properties:
  #    AWSServiceName: 'ecs.amazonaws.com'
  
   # ECS Resources
  ECSCluster:
    Type: AWS::ECS::Cluster
    Properties:
      ClusterSettings:
        - Name: containerInsights
          Value: enabled
  
  # Autoscaling group. This launches the actual EC2 instances that will register
  # themselves as members of the cluster, and run the docker containers.
  ECSAutoScalingGroup:
    Type: AWS::AutoScaling::AutoScalingGroup
    DependsOn:
      # This is to ensure that the ASG gets deleted first before these
    # resources, when it comes to stack teardown.
      - ECSCluster
      - EC2Role
    Properties:
      VPCZoneIdentifier:
        Ref: SubnetIds
      LaunchTemplate:
        LaunchTemplateId: !Ref ContainerInstances
        Version: !GetAtt ContainerInstances.LatestVersionNumber
      MinSize: 0
      MaxSize:
        Ref: MaxSize
      DesiredCapacity:
        Ref: DesiredCapacity
      NewInstancesProtectedFromScaleIn: true
    UpdatePolicy:
      AutoScalingReplacingUpdate:
        WillReplace: "true"
  # The config for each instance that is added to the cluster
  ContainerInstances:
    Type: AWS::EC2::LaunchTemplate
    Properties:
      LaunchTemplateName: "asg-launch-template"
      LaunchTemplateData:
        ImageId:
          Ref: ECSAMI
        InstanceType:
          Ref: InstanceType
        IamInstanceProfile:
          Name: !Ref EC2InstanceProfile
        SecurityGroupIds:
          - !Ref ContainerHostSecurityGroup
        # This injected configuration file is how the EC2 instance
      # knows which ECS cluster on your AWS account it should be joining
        UserData:
          Fn::Base64: !Sub |
           #!/bin/bash -xe
            echo ECS_CLUSTER=${ECSCluster} >> /etc/ecs/ecs.config
            yum install -y aws-cfn-bootstrap
            /opt/aws/bin/cfn-init -v --stack ${AWS::StackId} --resource ContainerInstances --configsets full_install --region ${AWS::Region} &
         # Disable IMDSv1, and require IMDSv2
        MetadataOptions:
          HttpEndpoint: enabled
          HttpTokens: required
  EC2InstanceProfile:
    Type: AWS::IAM::InstanceProfile
    Properties:
      Path: /
      Roles: 
      - !Ref EC2Role 
  # Create an ECS capacity provider to attach the ASG to the ECS cluster
  # so that it autoscales as we launch more containers
  CapacityProvider:
    Type: AWS::ECS::CapacityProvider
    Properties:
      AutoScalingGroupProvider:
        AutoScalingGroupArn: !Ref ECSAutoScalingGroup
        ManagedScaling:
          InstanceWarmupPeriod: 60
          MinimumScalingStepSize: 1
          MaximumScalingStepSize: 100
          Status: ENABLED
          # Percentage of cluster reservation to try to maintain
          TargetCapacity: 100
        ManagedTerminationProtection: ENABLED
   # Create a cluster capacity provider assocation so that the cluster
  # will use the capacity provider
  CapacityProviderAssociation:
    Type: AWS::ECS::ClusterCapacityProviderAssociations
    Properties:
      CapacityProviders:
        - !Ref CapacityProvider
      Cluster: !Ref ECSCluster
      DefaultCapacityProviderStrategy:
        - Base: 0
          CapacityProvider: !Ref CapacityProvider
          Weight: 1
  # A security group for the EC2 hosts that will run the containers.
  # This can be used to limit incoming traffic to or outgoing traffic
  # from the container's host EC2 instance.
  ContainerHostSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Access to the EC2 hosts that run containers
      VpcId:
        Ref: VpcId
  # Role for the EC2 hosts. This allows the ECS agent on the EC2 hosts
  # to communciate with the ECS control plane, as well as download the docker
  # images from ECR to run on your host.
  EC2Role:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - ec2.amazonaws.com
            Action:
              - sts:AssumeRole
      Path: /
      ManagedPolicyArns:
      # See reference: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/security-iam-awsmanpol.html#security-iam-awsmanpol-AmazonEC2ContainerServiceforEC2Role
        - arn:aws:iam::aws:policy/service-role/AmazonEC2ContainerServiceforEC2Role
      # This managed policy allows us to connect to the instance using SSM
        - arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore
  # This is a role which is used within Fargate to allow the Fargate agent
  # to download images, and upload logs.
  ECSTaskExecutionRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - ecs-tasks.amazonaws.com
            Action:
              - sts:AssumeRole
            Condition:
              ArnLike:
                aws:SourceArn: !Sub arn:${AWS::Partition}:ecs:${AWS::Region}:${AWS::AccountId}:*
              StringEquals:
                aws:SourceAccount: !Sub ${AWS::AccountId}
      Path: /
      # This role enables all features of ECS. See reference:
    # https://docs.aws.amazon.com/AmazonECS/latest/developerguide/security-iam-awsmanpol.html#security-iam-awsmanpol-AmazonECSTaskExecutionRolePolicy
      ManagedPolicyArns:
        - arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy
Outputs:
  ClusterName:
    Description: The ECS cluster into which to launch resources
    Value: ECSCluster
  ECSTaskExecutionRole:
    Description: The role used to start up a task
    Value: ECSTaskExecutionRole
  CapacityProvider:
    Description: The cluster capacity provider that the service should use to
      request capacity when it wants to start up a task
    Value: CapacityProvider
```

## Implementa un servizio
<a name="create-service"></a>

Il modello seguente definisce un servizio che utilizza il provider di capacità per richiedere la AL2023 capacità su cui funzionare. I contenitori verranno avviati sulle AL2023 istanze non appena saranno online:

### JSON
<a name="quickref-ecs-example-2.json"></a>

```
{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Description": "An example service that deploys in AWS VPC networking mode on EC2 capacity. Service uses a capacity provider to request EC2 instances to run on. Service runs with networking in private subnets, but still accessible to the internet via a load balancer hosted in public subnets.",
  "Parameters": {
      "VpcId": {
          "Type": "String",
          "Description": "The VPC that the service is running inside of"
      },
      "PublicSubnetIds": {
          "Type": "List<AWS::EC2::Subnet::Id>",
          "Description": "List of public subnet ID's to put the load balancer in"
      },
      "PrivateSubnetIds": {
          "Type": "List<AWS::EC2::Subnet::Id>",
          "Description": "List of private subnet ID's that the AWS VPC tasks are in"
      },
      "ClusterName": {
          "Type": "String",
          "Description": "The name of the ECS cluster into which to launch capacity."
      },
      "ECSTaskExecutionRole": {
          "Type": "String",
          "Description": "The role used to start up an ECS task"
      },
      "CapacityProvider": {
          "Type": "String",
          "Description": "The cluster capacity provider that the service should use to request capacity when it wants to start up a task"
      },
      "ServiceName": {
          "Type": "String",
          "Default": "web",
          "Description": "A name for the service"
      },
      "ImageUrl": {
          "Type": "String",
          "Default": "public.ecr.aws/docker/library/nginx:latest",
          "Description": "The url of a docker image that contains the application process that will handle the traffic for this service"
      },
      "ContainerCpu": {
          "Type": "Number",
          "Default": 256,
          "Description": "How much CPU to give the container. 1024 is 1 CPU"
      },
      "ContainerMemory": {
          "Type": "Number",
          "Default": 512,
          "Description": "How much memory in megabytes to give the container"
      },
      "ContainerPort": {
          "Type": "Number",
          "Default": 80,
          "Description": "What port that the application expects traffic on"
      },
      "DesiredCount": {
          "Type": "Number",
          "Default": 2,
          "Description": "How many copies of the service task to run"
      }
  },
  "Resources": {
      "TaskDefinition": {
          "Type": "AWS::ECS::TaskDefinition",
          "Properties": {
              "Family": {
                  "Ref": "ServiceName"
              },
              "Cpu": {
                  "Ref": "ContainerCpu"
              },
              "Memory": {
                  "Ref": "ContainerMemory"
              },
              "NetworkMode": "awsvpc",
              "RequiresCompatibilities": [
                  "EC2"
              ],
              "ExecutionRoleArn": {
                  "Ref": "ECSTaskExecutionRole"
              },
              "ContainerDefinitions": [
                  {
                      "Name": {
                          "Ref": "ServiceName"
                      },
                      "Cpu": {
                          "Ref": "ContainerCpu"
                      },
                      "Memory": {
                          "Ref": "ContainerMemory"
                      },
                      "Image": {
                          "Ref": "ImageUrl"
                      },
                      "PortMappings": [
                          {
                              "ContainerPort": {
                                  "Ref": "ContainerPort"
                              },
                              "HostPort": {
                                  "Ref": "ContainerPort"
                              }
                          }
                      ],
                      "LogConfiguration": {
                          "LogDriver": "awslogs",
                          "Options": {
                              "mode": "non-blocking",
                              "max-buffer-size": "25m",
                              "awslogs-group": {
                                  "Ref": "LogGroup"
                              },
                              "awslogs-region": {
                                  "Ref": "AWS::Region"
                              },
                              "awslogs-stream-prefix": {
                                  "Ref": "ServiceName"
                              }
                          }
                      }
                  }
              ]
          }
      },
      "Service": {
          "Type": "AWS::ECS::Service",
          "DependsOn": "PublicLoadBalancerListener",
          "Properties": {
              "ServiceName": {
                  "Ref": "ServiceName"
              },
              "Cluster": {
                  "Ref": "ClusterName"
              },
              "PlacementStrategies": [
                  {
                      "Field": "attribute:ecs.availability-zone",
                      "Type": "spread"
                  },
                  {
                      "Field": "cpu",
                      "Type": "binpack"
                  }
              ],
              "CapacityProviderStrategy": [
                  {
                      "Base": 0,
                      "CapacityProvider": {
                          "Ref": "CapacityProvider"
                      },
                      "Weight": 1
                  }
              ],
              "NetworkConfiguration": {
                  "AwsvpcConfiguration": {
                      "SecurityGroups": [
                          {
                              "Ref": "ServiceSecurityGroup"
                          }
                      ],
                      "Subnets": {
                          "Ref": "PrivateSubnetIds"
                      }
                  }
              },
              "DeploymentConfiguration": {
                  "MaximumPercent": 200,
                  "MinimumHealthyPercent": 75
              },
              "DesiredCount": {
                  "Ref": "DesiredCount"
              },
              "TaskDefinition": {
                  "Ref": "TaskDefinition"
              },
              "LoadBalancers": [
                  {
                      "ContainerName": {
                          "Ref": "ServiceName"
                      },
                      "ContainerPort": {
                          "Ref": "ContainerPort"
                      },
                      "TargetGroupArn": {
                          "Ref": "ServiceTargetGroup"
                      }
                  }
              ]
          }
      },
      "ServiceSecurityGroup": {
          "Type": "AWS::EC2::SecurityGroup",
          "Properties": {
              "GroupDescription": "Security group for service",
              "VpcId": {
                  "Ref": "VpcId"
              }
          }
      },
      "ServiceTargetGroup": {
          "Type": "AWS::ElasticLoadBalancingV2::TargetGroup",
          "Properties": {
              "HealthCheckIntervalSeconds": 6,
              "HealthCheckPath": "/",
              "HealthCheckProtocol": "HTTP",
              "HealthCheckTimeoutSeconds": 5,
              "HealthyThresholdCount": 2,
              "TargetType": "ip",
              "Port": {
                  "Ref": "ContainerPort"
              },
              "Protocol": "HTTP",
              "UnhealthyThresholdCount": 10,
              "VpcId": {
                  "Ref": "VpcId"
              },
              "TargetGroupAttributes": [
                  {
                      "Key": "deregistration_delay.timeout_seconds",
                      "Value": 0
                  }
              ]
          }
      },
      "PublicLoadBalancerSG": {
          "Type": "AWS::EC2::SecurityGroup",
          "Properties": {
              "GroupDescription": "Access to the public facing load balancer",
              "VpcId": {
                  "Ref": "VpcId"
              },
              "SecurityGroupIngress": [
                  {
                      "CidrIp": "0.0.0.0/0",
                      "IpProtocol": -1
                  }
              ]
          }
      },
      "PublicLoadBalancer": {
          "Type": "AWS::ElasticLoadBalancingV2::LoadBalancer",
          "Properties": {
              "Scheme": "internet-facing",
              "LoadBalancerAttributes": [
                  {
                      "Key": "idle_timeout.timeout_seconds",
                      "Value": "30"
                  }
              ],
              "Subnets": {
                  "Ref": "PublicSubnetIds"
              },
              "SecurityGroups": [
                  {
                      "Ref": "PublicLoadBalancerSG"
                  }
              ]
          }
      },
      "PublicLoadBalancerListener": {
          "Type": "AWS::ElasticLoadBalancingV2::Listener",
          "Properties": {
              "DefaultActions": [
                  {
                      "Type": "forward",
                      "ForwardConfig": {
                          "TargetGroups": [
                              {
                                  "TargetGroupArn": {
                                      "Ref": "ServiceTargetGroup"
                                  },
                                  "Weight": 100
                              }
                          ]
                      }
                  }
              ],
              "LoadBalancerArn": {
                  "Ref": "PublicLoadBalancer"
              },
              "Port": 80,
              "Protocol": "HTTP"
          }
      },
      "ServiceIngressfromLoadBalancer": {
          "Type": "AWS::EC2::SecurityGroupIngress",
          "Properties": {
              "Description": "Ingress from the public ALB",
              "GroupId": {
                  "Ref": "ServiceSecurityGroup"
              },
              "IpProtocol": -1,
              "SourceSecurityGroupId": {
                  "Ref": "PublicLoadBalancerSG"
              }
          }
      },
      "LogGroup": {
          "Type": "AWS::Logs::LogGroup"
      }
  }
}
```

### YAML
<a name="quickref-ecs-example-2.yaml"></a>

```
AWSTemplateFormatVersion: '2010-09-09'
Description: >-
  An example service that deploys in AWS VPC networking mode on EC2 capacity.
  Service uses a capacity provider to request EC2 instances to run on. Service
  runs with networking in private subnets, but still accessible to the internet
  via a load balancer hosted in public subnets.
Parameters:
  VpcId:
    Type: String
    Description: The VPC that the service is running inside of
  PublicSubnetIds:
    Type: 'List<AWS::EC2::Subnet::Id>'
    Description: List of public subnet ID's to put the load balancer in
  PrivateSubnetIds:
    Type: 'List<AWS::EC2::Subnet::Id>'
    Description: List of private subnet ID's that the AWS VPC tasks are in
  ClusterName:
    Type: String
    Description: The name of the ECS cluster into which to launch capacity.
  ECSTaskExecutionRole:
    Type: String
    Description: The role used to start up an ECS task
  CapacityProvider:
    Type: String
    Description: >-
      The cluster capacity provider that the service should use to request
      capacity when it wants to start up a task
  ServiceName:
    Type: String
    Default: web
    Description: A name for the service
  ImageUrl:
    Type: String
    Default: 'public.ecr.aws/docker/library/nginx:latest'
    Description: >-
      The url of a docker image that contains the application process that will
      handle the traffic for this service
  ContainerCpu:
    Type: Number
    Default: 256
    Description: How much CPU to give the container. 1024 is 1 CPU
  ContainerMemory:
    Type: Number
    Default: 512
    Description: How much memory in megabytes to give the container
  ContainerPort:
    Type: Number
    Default: 80
    Description: What port that the application expects traffic on
  DesiredCount:
    Type: Number
    Default: 2
    Description: How many copies of the service task to run
Resources:
  TaskDefinition:
    Type: AWS::ECS::TaskDefinition
    Properties:
      Family: !Ref ServiceName
      Cpu: !Ref ContainerCpu
      Memory: !Ref ContainerMemory
      NetworkMode: awsvpc
      RequiresCompatibilities:
        - EC2
      ExecutionRoleArn: !Ref ECSTaskExecutionRole
      ContainerDefinitions:
        - Name: !Ref ServiceName
          Cpu: !Ref ContainerCpu
          Memory: !Ref ContainerMemory
          Image: !Ref ImageUrl
          PortMappings:
            - ContainerPort: !Ref ContainerPort
              HostPort: !Ref ContainerPort
          LogConfiguration:
            LogDriver: awslogs
            Options:
              mode: non-blocking
              max-buffer-size: 25m
              awslogs-group: !Ref LogGroup
              awslogs-region: !Ref AWS::Region
              awslogs-stream-prefix: !Ref ServiceName
  Service:
    Type: AWS::ECS::Service
    DependsOn: PublicLoadBalancerListener
    Properties:
      ServiceName: !Ref ServiceName
      Cluster: !Ref ClusterName
      PlacementStrategies:
        - Field: 'attribute:ecs.availability-zone'
          Type: spread
        - Field: cpu
          Type: binpack
      CapacityProviderStrategy:
        - Base: 0
          CapacityProvider: !Ref CapacityProvider
          Weight: 1
      NetworkConfiguration:
        AwsvpcConfiguration:
          SecurityGroups:
            - !Ref ServiceSecurityGroup
          Subnets: !Ref PrivateSubnetIds
      DeploymentConfiguration:
        MaximumPercent: 200
        MinimumHealthyPercent: 75
      DesiredCount: !Ref DesiredCount
      TaskDefinition: !Ref TaskDefinition
      LoadBalancers:
        - ContainerName: !Ref ServiceName
          ContainerPort: !Ref ContainerPort
          TargetGroupArn: !Ref ServiceTargetGroup
  ServiceSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Security group for service
      VpcId: !Ref VpcId
  ServiceTargetGroup:
    Type: AWS::ElasticLoadBalancingV2::TargetGroup
    Properties:
      HealthCheckIntervalSeconds: 6
      HealthCheckPath: /
      HealthCheckProtocol: HTTP
      HealthCheckTimeoutSeconds: 5
      HealthyThresholdCount: 2
      TargetType: ip
      Port: !Ref ContainerPort
      Protocol: HTTP
      UnhealthyThresholdCount: 10
      VpcId: !Ref VpcId
      TargetGroupAttributes:
        - Key: deregistration_delay.timeout_seconds
          Value: 0
  PublicLoadBalancerSG:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Access to the public facing load balancer
      VpcId: !Ref VpcId
      SecurityGroupIngress:
        - CidrIp: 0.0.0.0/0
          IpProtocol: -1
  PublicLoadBalancer:
    Type: AWS::ElasticLoadBalancingV2::LoadBalancer
    Properties:
      Scheme: internet-facing
      LoadBalancerAttributes:
        - Key: idle_timeout.timeout_seconds
          Value: '30'
      Subnets: !Ref PublicSubnetIds
      SecurityGroups:
        - !Ref PublicLoadBalancerSG
  PublicLoadBalancerListener:
    Type: AWS::ElasticLoadBalancingV2::Listener
    Properties:
      DefaultActions:
        - Type: forward
          ForwardConfig:
            TargetGroups:
              - TargetGroupArn: !Ref ServiceTargetGroup
                Weight: 100
      LoadBalancerArn: !Ref PublicLoadBalancer
      Port: 80
      Protocol: HTTP
  ServiceIngressfromLoadBalancer:
    Type: AWS::EC2::SecurityGroupIngress
    Properties:
      Description: Ingress from the public ALB
      GroupId: !Ref ServiceSecurityGroup
      IpProtocol: -1
      SourceSecurityGroupId: !Ref PublicLoadBalancerSG
  LogGroup:
    Type: AWS::Logs::LogGroup
```

# Modello di esempio Amazon Elastic File System
<a name="quickref-efs"></a>

Amazon Elastic File System (Amazon EFS) è un servizio di storage di file per istanze Amazon Elastic Compute Cloud (Amazon EC2). Con Amazon EFS le tue applicazioni dispongono di storage quando serve, perché la capacità di storage aumenta e si riduce automaticamente con l'aggiunta e la rimozione di file.

Il seguente modello di esempio distribuisce EC2 istanze (in un gruppo Auto Scaling) associate a un file system Amazon EFS. Per associare le istanze al file system, le istanze eseguono lo script helper cfn-init, che scarica e installa il pacchetto yum `nfs-utils`, crea una nuova directory e quindi utilizza il nome DNS del file system per montare il file system in tale directory. Il nome DNS del file system si risolve nell'indirizzo IP di una destinazione di montaggio nella zona di disponibilità dell' EC2istanza Amazon. Per ulteriori informazioni sulla struttura del nome DNS, consulta [Montaggio del file system](https://docs.aws.amazon.com/efs/latest/ug/mounting-fs.html) nella *Guida per l'utente di Amazon Elastic File System*.

Per misurare l'attività del Network File System, il modello include CloudWatch metriche Amazon personalizzate. Crea inoltre un VPC, una sottorete e i gruppi di sicurezza. Per consentire alle istanze di comunicare con il file system, il VPC deve avere il DNS abilitato e la destinazione di montaggio e EC2 le istanze devono trovarsi nella stessa zona di disponibilità (AZ), specificata dalla sottorete.

Il gruppo di sicurezza del target di montaggio consente una connessione di rete alla porta TCP 2049, necessaria per consentire a un client di montare un NFSv4 file system. Per ulteriori informazioni sui gruppi di sicurezza per EC2 le istanze e gli obiettivi di montaggio, consulta la sezione [Sicurezza](https://docs.aws.amazon.com/efs/latest/ug/security-considerations.html) nella [https://docs.aws.amazon.com/efs/latest/ug/](https://docs.aws.amazon.com/efs/latest/ug/).

**Nota**  
Se effettui un aggiornamento alla destinazione di montaggio che ne causa la sostituzione, le istanze o le applicazioni che utilizzano il file system associato potrebbero venire interrotte. Questo può causare la perdita di scritture non confermate con commit. Per evitare interruzioni, arresta le istanze quando aggiorni la destinazione di montaggio impostando la capacità desiderata su zero. In questo modo le istanze possono disinstallare il file system prima che la destinazione di montaggio venga eliminata. Al termine dell'aggiornamento del montaggio, avvia le istanze in un aggiornamento successivo impostando la capacità desiderata.

## JSON
<a name="quickref-efs-example-1.json"></a>

```
{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Description": "This template creates an Amazon EFS file system and mount target and associates it with Amazon EC2 instances in an Auto Scaling group. **WARNING** This template creates Amazon EC2 instances and related resources. You will be billed for the AWS resources used if you create a stack from this template.",
  "Parameters": {
    "InstanceType" : {
      "Description" : "WebServer EC2 instance type",
      "Type" : "String",
      "Default" : "t2.small",
      "AllowedValues" : [ 
        "t1.micro", 
        "t2.nano", 
        "t2.micro", 
        "t2.small", 
        "t2.medium", 
        "t2.large", 
        "m1.small", 
        "m1.medium", 
        "m1.large", 
        "m1.xlarge", 
        "m2.xlarge", 
        "m2.2xlarge", 
        "m2.4xlarge", 
        "m3.medium", 
        "m3.large", 
        "m3.xlarge", 
        "m3.2xlarge", 
        "m4.large", 
        "m4.xlarge", 
        "m4.2xlarge", 
        "m4.4xlarge", 
        "m4.10xlarge", 
        "c1.medium", 
        "c1.xlarge", 
        "c3.large", 
        "c3.xlarge", 
        "c3.2xlarge", 
        "c3.4xlarge", 
        "c3.8xlarge", 
        "c4.large", 
        "c4.xlarge", 
        "c4.2xlarge", 
        "c4.4xlarge", 
        "c4.8xlarge", 
        "g2.2xlarge", 
        "g2.8xlarge", 
        "r3.large", 
        "r3.xlarge", 
        "r3.2xlarge", 
        "r3.4xlarge", 
        "r3.8xlarge", 
        "i2.xlarge", 
        "i2.2xlarge", 
        "i2.4xlarge", 
        "i2.8xlarge", 
        "d2.xlarge", 
        "d2.2xlarge", 
        "d2.4xlarge", 
        "d2.8xlarge", 
        "hi1.4xlarge", 
        "hs1.8xlarge", 
        "cr1.8xlarge", 
        "cc2.8xlarge", 
        "cg1.4xlarge"
      ],
      "ConstraintDescription" : "must be a valid EC2 instance type."
    },
    "KeyName": {
      "Type": "AWS::EC2::KeyPair::KeyName",
      "Description": "Name of an existing EC2 key pair to enable SSH access to the EC2 instances"
    },
    "AsgMaxSize": {
      "Type": "Number",
      "Description": "Maximum size and initial desired capacity of Auto Scaling Group",
      "Default": "2"
    },
    "SSHLocation" : {
      "Description" : "The IP address range that can be used to connect to the EC2 instances by using SSH",
      "Type": "String",
      "MinLength": "9",
      "MaxLength": "18",
      "Default": "0.0.0.0/0",
      "AllowedPattern": "(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})/(\\d{1,2})",
      "ConstraintDescription": "must be a valid IP CIDR range of the form x.x.x.x/x."
    },
    "VolumeName" : {
      "Description" : "The name to be used for the EFS volume",
      "Type": "String",
      "MinLength": "1",
      "Default": "myEFSvolume"
    },
    "MountPoint" : {
      "Description" : "The Linux mount point for the EFS volume",
      "Type": "String",
      "MinLength": "1",
      "Default": "myEFSvolume"
    }
  },
  "Mappings" : {
    "AWSInstanceType2Arch" : {
      "t1.micro"    : { "Arch" : "HVM64"  },
      "t2.nano"     : { "Arch" : "HVM64"  },
      "t2.micro"    : { "Arch" : "HVM64"  },
      "t2.small"    : { "Arch" : "HVM64"  },
      "t2.medium"   : { "Arch" : "HVM64"  },
      "t2.large"    : { "Arch" : "HVM64"  },
      "m1.small"    : { "Arch" : "HVM64"  },
      "m1.medium"   : { "Arch" : "HVM64"  },
      "m1.large"    : { "Arch" : "HVM64"  },
      "m1.xlarge"   : { "Arch" : "HVM64"  },
      "m2.xlarge"   : { "Arch" : "HVM64"  },
      "m2.2xlarge"  : { "Arch" : "HVM64"  },
      "m2.4xlarge"  : { "Arch" : "HVM64"  },
      "m3.medium"   : { "Arch" : "HVM64"  },
      "m3.large"    : { "Arch" : "HVM64"  },
      "m3.xlarge"   : { "Arch" : "HVM64"  },
      "m3.2xlarge"  : { "Arch" : "HVM64"  },
      "m4.large"    : { "Arch" : "HVM64"  },
      "m4.xlarge"   : { "Arch" : "HVM64"  },
      "m4.2xlarge"  : { "Arch" : "HVM64"  },
      "m4.4xlarge"  : { "Arch" : "HVM64"  },
      "m4.10xlarge" : { "Arch" : "HVM64"  },
      "c1.medium"   : { "Arch" : "HVM64"  },
      "c1.xlarge"   : { "Arch" : "HVM64"  },
      "c3.large"    : { "Arch" : "HVM64"  },
      "c3.xlarge"   : { "Arch" : "HVM64"  },
      "c3.2xlarge"  : { "Arch" : "HVM64"  },
      "c3.4xlarge"  : { "Arch" : "HVM64"  },
      "c3.8xlarge"  : { "Arch" : "HVM64"  },
      "c4.large"    : { "Arch" : "HVM64"  },
      "c4.xlarge"   : { "Arch" : "HVM64"  },
      "c4.2xlarge"  : { "Arch" : "HVM64"  },
      "c4.4xlarge"  : { "Arch" : "HVM64"  },
      "c4.8xlarge"  : { "Arch" : "HVM64"  },
      "g2.2xlarge"  : { "Arch" : "HVMG2"  },
      "g2.8xlarge"  : { "Arch" : "HVMG2"  },
      "r3.large"    : { "Arch" : "HVM64"  },
      "r3.xlarge"   : { "Arch" : "HVM64"  },
      "r3.2xlarge"  : { "Arch" : "HVM64"  },
      "r3.4xlarge"  : { "Arch" : "HVM64"  },
      "r3.8xlarge"  : { "Arch" : "HVM64"  },
      "i2.xlarge"   : { "Arch" : "HVM64"  },
      "i2.2xlarge"  : { "Arch" : "HVM64"  },
      "i2.4xlarge"  : { "Arch" : "HVM64"  },
      "i2.8xlarge"  : { "Arch" : "HVM64"  },
      "d2.xlarge"   : { "Arch" : "HVM64"  },
      "d2.2xlarge"  : { "Arch" : "HVM64"  },
      "d2.4xlarge"  : { "Arch" : "HVM64"  },
      "d2.8xlarge"  : { "Arch" : "HVM64"  },
      "hi1.4xlarge" : { "Arch" : "HVM64"  },
      "hs1.8xlarge" : { "Arch" : "HVM64"  },
      "cr1.8xlarge" : { "Arch" : "HVM64"  },
      "cc2.8xlarge" : { "Arch" : "HVM64"  }
    },
    "AWSRegionArch2AMI" : {
      "us-east-1"        : {"HVM64" : "ami-0ff8a91507f77f867", "HVMG2" : "ami-0a584ac55a7631c0c"},
      "us-west-2"        : {"HVM64" : "ami-a0cfeed8", "HVMG2" : "ami-0e09505bc235aa82d"},
      "us-west-1"        : {"HVM64" : "ami-0bdb828fd58c52235", "HVMG2" : "ami-066ee5fd4a9ef77f1"},
      "eu-west-1"        : {"HVM64" : "ami-047bb4163c506cd98", "HVMG2" : "ami-0a7c483d527806435"},
      "eu-west-2"        : {"HVM64" : "ami-f976839e", "HVMG2" : "NOT_SUPPORTED"},
      "eu-west-3"        : {"HVM64" : "ami-0ebc281c20e89ba4b", "HVMG2" : "NOT_SUPPORTED"},
      "eu-central-1"     : {"HVM64" : "ami-0233214e13e500f77", "HVMG2" : "ami-06223d46a6d0661c7"},
      "ap-northeast-1"   : {"HVM64" : "ami-06cd52961ce9f0d85", "HVMG2" : "ami-053cdd503598e4a9d"},
      "ap-northeast-2"   : {"HVM64" : "ami-0a10b2721688ce9d2", "HVMG2" : "NOT_SUPPORTED"},
      "ap-northeast-3"   : {"HVM64" : "ami-0d98120a9fb693f07", "HVMG2" : "NOT_SUPPORTED"},
      "ap-southeast-1"   : {"HVM64" : "ami-08569b978cc4dfa10", "HVMG2" : "ami-0be9df32ae9f92309"},
      "ap-southeast-2"   : {"HVM64" : "ami-09b42976632b27e9b", "HVMG2" : "ami-0a9ce9fecc3d1daf8"},
      "ap-south-1"       : {"HVM64" : "ami-0912f71e06545ad88", "HVMG2" : "ami-097b15e89dbdcfcf4"},
      "us-east-2"        : {"HVM64" : "ami-0b59bfac6be064b78", "HVMG2" : "NOT_SUPPORTED"},
      "ca-central-1"     : {"HVM64" : "ami-0b18956f", "HVMG2" : "NOT_SUPPORTED"},
      "sa-east-1"        : {"HVM64" : "ami-07b14488da8ea02a0", "HVMG2" : "NOT_SUPPORTED"},
      "cn-north-1"       : {"HVM64" : "ami-0a4eaf6c4454eda75", "HVMG2" : "NOT_SUPPORTED"},
      "cn-northwest-1"   : {"HVM64" : "ami-6b6a7d09", "HVMG2" : "NOT_SUPPORTED"}
    }
  },
  "Resources": {
    "CloudWatchPutMetricsRole" : {
      "Type"  : "AWS::IAM::Role",
      "Properties" : {
          "AssumeRolePolicyDocument" : {
              "Statement" : [ {
                  "Effect" : "Allow",
                  "Principal" : {
                      "Service" : [ "ec2.amazonaws.com" ]
                  },
                  "Action" : [ "sts:AssumeRole" ]
              } ]
          },
          "Path" : "/"
      }
    },
    "CloudWatchPutMetricsRolePolicy" : {
        "Type" : "AWS::IAM::Policy",
        "Properties" : {
            "PolicyName" : "CloudWatch_PutMetricData",
            "PolicyDocument" : {
              "Version": "2012-10-17",		 	 	 
              "Statement": [
                {
                  "Sid": "CloudWatchPutMetricData",
                  "Effect": "Allow",
                  "Action": ["cloudwatch:PutMetricData"],
                  "Resource": ["*"]
                }
              ]
            },
            "Roles" : [ { "Ref" : "CloudWatchPutMetricsRole" } ]
        }
    },
    "CloudWatchPutMetricsInstanceProfile" : {
      "Type" : "AWS::IAM::InstanceProfile",
      "Properties" : {
        "Path" : "/",
        "Roles" : [ { "Ref" : "CloudWatchPutMetricsRole" } ]
      }
    },
    "VPC": {
      "Type": "AWS::EC2::VPC",
      "Properties": {
        "EnableDnsSupport" : "true",
        "EnableDnsHostnames" : "true",
        "CidrBlock": "10.0.0.0/16",
        "Tags": [ {"Key": "Application", "Value": { "Ref": "AWS::StackId"} } ]
      }
    },
    "InternetGateway" : {
      "Type" : "AWS::EC2::InternetGateway",
      "Properties" : {
        "Tags" : [
          { "Key" : "Application", "Value" : { "Ref" : "AWS::StackName" } },
          { "Key" : "Network", "Value" : "Public" }
        ]
      }
    },
    "GatewayToInternet" : {
      "Type" : "AWS::EC2::VPCGatewayAttachment",
      "Properties" : {
        "VpcId" : { "Ref" : "VPC" },
        "InternetGatewayId" : { "Ref" : "InternetGateway" }
      }
    },
    "RouteTable":{
      "Type":"AWS::EC2::RouteTable",
      "Properties":{
        "VpcId": {"Ref":"VPC"}
      }
    },
    "SubnetRouteTableAssoc": {
      "Type" : "AWS::EC2::SubnetRouteTableAssociation",
      "Properties" : {
        "RouteTableId" : {"Ref":"RouteTable"},
        "SubnetId" : {"Ref":"Subnet"}
      }
    },
    "InternetGatewayRoute": {
        "Type":"AWS::EC2::Route",
        "Properties":{
            "DestinationCidrBlock":"0.0.0.0/0",
            "RouteTableId":{"Ref":"RouteTable"},
            "GatewayId":{"Ref":"InternetGateway"}
        }
    },
    "Subnet": {
      "Type": "AWS::EC2::Subnet",
      "Properties": {
        "VpcId": { "Ref": "VPC" },
        "CidrBlock": "10.0.0.0/24",
        "Tags": [ { "Key": "Application", "Value": { "Ref": "AWS::StackId" } } ]
      }
    },    
    "InstanceSecurityGroup": {
      "Type": "AWS::EC2::SecurityGroup",
      "Properties": {
        "VpcId": { "Ref": "VPC" },
        "GroupDescription": "Enable SSH access via port 22",
        "SecurityGroupIngress": [
          { "IpProtocol": "tcp", "FromPort": 22, "ToPort": 22, "CidrIp": { "Ref": "SSHLocation" } },
          { "IpProtocol": "tcp", "FromPort": 80, "ToPort": 80, "CidrIp": "0.0.0.0/0" }
         ]
      }
    },
    "MountTargetSecurityGroup": {
      "Type": "AWS::EC2::SecurityGroup",
      "Properties": {
        "VpcId": { "Ref": "VPC" },
        "GroupDescription": "Security group for mount target",
        "SecurityGroupIngress": [
          {
            "IpProtocol": "tcp",
            "FromPort": 2049,
            "ToPort": 2049,
            "CidrIp": "0.0.0.0/0"
          }
        ]
      }
    },
    "FileSystem": {
      "Type": "AWS::EFS::FileSystem",
      "Properties": {
        "PerformanceMode": "generalPurpose",
        "FileSystemTags": [
          {
            "Key": "Name",
            "Value": { "Ref" : "VolumeName" }
          }
        ]
      }
    },
    "MountTarget": {
      "Type": "AWS::EFS::MountTarget",
      "Properties": {
        "FileSystemId": { "Ref": "FileSystem" },
        "SubnetId": { "Ref": "Subnet" },
        "SecurityGroups": [ { "Ref": "MountTargetSecurityGroup" } ]        
      }
    },
    "LaunchConfiguration": {
      "Type": "AWS::AutoScaling::LaunchConfiguration",
      "Metadata" : {
        "AWS::CloudFormation::Init" : {
          "configSets" : {
            "MountConfig" : [ "setup", "mount" ]
          },
          "setup" : {
            "packages" : {
              "yum" : {
                "nfs-utils" : []
              }
            },
            "files" : {
              "/home/ec2-user/post_nfsstat" : {
                "content" : { "Fn::Join" : [ "", [
                      "#!/bin/bash\n",
                      "\n",
                      "INPUT=\"$(cat)\"\n",
                      "CW_JSON_OPEN='{ \"Namespace\": \"EFS\", \"MetricData\": [ '\n",
                      "CW_JSON_CLOSE=' ] }'\n",
                      "CW_JSON_METRIC=''\n",
                      "METRIC_COUNTER=0\n",
                      "\n",
                      "for COL in 1 2 3 4 5 6; do\n",
                      "\n",
                      " COUNTER=0\n",
                      " METRIC_FIELD=$COL\n",
                      " DATA_FIELD=$(($COL+($COL-1)))\n",
                      "\n",
                      " while read line; do\n",
                      "   if [[ COUNTER -gt 0 ]]; then\n",
                      "\n",
                      "     LINE=`echo $line | tr -s ' ' `\n",
                      "     AWS_COMMAND=\"aws cloudwatch put-metric-data --region ", { "Ref": "AWS::Region" }, "\"\n",
                      "     MOD=$(( $COUNTER % 2))\n",
                      "\n",
                      "     if [ $MOD -eq 1 ]; then\n",
                      "       METRIC_NAME=`echo $LINE | cut -d ' ' -f $METRIC_FIELD`\n",
                      "     else\n",
                      "       METRIC_VALUE=`echo $LINE | cut -d ' ' -f $DATA_FIELD`\n",
                      "     fi\n",
                      "\n",
                      "     if [[ -n \"$METRIC_NAME\" && -n \"$METRIC_VALUE\" ]]; then\n",
                      "       INSTANCE_ID=$(curl -s http://169.254.169.254/latest/meta-data/instance-id)\n",
                      "       CW_JSON_METRIC=\"$CW_JSON_METRIC { \\\"MetricName\\\": \\\"$METRIC_NAME\\\", \\\"Dimensions\\\": [{\\\"Name\\\": \\\"InstanceId\\\", \\\"Value\\\": \\\"$INSTANCE_ID\\\"} ], \\\"Value\\\": $METRIC_VALUE },\"\n",
                      "       unset METRIC_NAME\n",
                      "       unset METRIC_VALUE\n",
                      "\n",
                      "       METRIC_COUNTER=$((METRIC_COUNTER+1))\n",
                      "       if [ $METRIC_COUNTER -eq 20 ]; then\n",
                      "         # 20 is max metric collection size, so we have to submit here\n",
                      "         aws cloudwatch put-metric-data --region ", { "Ref": "AWS::Region" }, " --cli-input-json \"`echo $CW_JSON_OPEN ${CW_JSON_METRIC%?} $CW_JSON_CLOSE`\"\n",
                      "\n",
                      "         # reset\n",
                      "         METRIC_COUNTER=0\n",
                      "         CW_JSON_METRIC=''\n",
                      "       fi\n",
                      "     fi  \n",
                      "\n",
                      "\n",
                      "\n",
                      "     COUNTER=$((COUNTER+1))\n",
                      "   fi\n",
                      "\n",
                      "   if [[ \"$line\" == \"Client nfs v4:\" ]]; then\n",
                      "     # the next line is the good stuff \n",
                      "     COUNTER=$((COUNTER+1))\n",
                      "   fi\n",
                      " done <<< \"$INPUT\"\n",
                      "done\n",
                      "\n",
                      "# submit whatever is left\n",
                      "aws cloudwatch put-metric-data --region ", { "Ref": "AWS::Region" }, " --cli-input-json \"`echo $CW_JSON_OPEN ${CW_JSON_METRIC%?} $CW_JSON_CLOSE`\""
                    ] ] },
                "mode": "000755",
                "owner": "ec2-user",
                "group": "ec2-user"
              },
              "/home/ec2-user/crontab" : {
                "content" : { "Fn::Join" : [ "", [
                  "* * * * * /usr/sbin/nfsstat | /home/ec2-user/post_nfsstat\n"
                ] ] },
                "owner": "ec2-user",
                "group": "ec2-user"
              }
            },
            "commands" : {
              "01_createdir" : {
                "command" : {"Fn::Join" : [ "", [ "mkdir /", { "Ref" : "MountPoint" }]]}
              }
            }
          },
          "mount" : {
            "commands" : {
              "01_mount" : {
                "command" : { "Fn::Sub": "sudo mount -t nfs4 -o nfsvers=4.1,rsize=1048576,wsize=1048576,hard,timeo=600,retrans=2 ${FileSystem}.efs.${AWS::Region}.amazonaws.com:/ /${MountPoint}"}
              },
              "02_permissions" : {
                "command" : {"Fn::Join" : [ "", [ "chown ec2-user:ec2-user /", { "Ref" : "MountPoint" }]]}
              }
            }
          }
        }
      },
      "Properties": {
        "AssociatePublicIpAddress" : true,
        "ImageId": {
          "Fn::FindInMap": [ "AWSRegionArch2AMI", { "Ref": "AWS::Region" }, {
            "Fn::FindInMap": [ "AWSInstanceType2Arch", { "Ref": "InstanceType" }, "Arch" ]
          } ]
        },
        "InstanceType": { "Ref": "InstanceType" },
        "KeyName": { "Ref": "KeyName" },
        "SecurityGroups": [ { "Ref": "InstanceSecurityGroup" } ],
        "IamInstanceProfile" : { "Ref" : "CloudWatchPutMetricsInstanceProfile" },
        "UserData"       : { "Fn::Base64" : { "Fn::Join" : ["", [
             "#!/bin/bash -xe\n",
             "yum install -y aws-cfn-bootstrap\n",

             "/opt/aws/bin/cfn-init -v ",
             "         --stack ", { "Ref" : "AWS::StackName" },
             "         --resource LaunchConfiguration ",
             "         --configsets MountConfig ",
             "         --region ", { "Ref" : "AWS::Region" }, "\n",

             "crontab /home/ec2-user/crontab\n",

             "/opt/aws/bin/cfn-signal -e $? ",
             "         --stack ", { "Ref" : "AWS::StackName" },
             "         --resource AutoScalingGroup ",
             "         --region ", { "Ref" : "AWS::Region" }, "\n"
        ]]}}
      }
    },
    "AutoScalingGroup": {
      "Type": "AWS::AutoScaling::AutoScalingGroup",
      "DependsOn": ["MountTarget", "GatewayToInternet"],
      "CreationPolicy" : {
        "ResourceSignal" : {
          "Timeout" : "PT15M",
          "Count"   : { "Ref": "AsgMaxSize" }
        }
      },
      "Properties": {
        "VPCZoneIdentifier": [ { "Ref": "Subnet" } ],
        "LaunchConfigurationName": { "Ref": "LaunchConfiguration" },
        "MinSize": "1",
        "MaxSize": { "Ref": "AsgMaxSize" },
        "DesiredCapacity": { "Ref": "AsgMaxSize" },
        "Tags": [ {
          "Key": "Name",
          "Value": "EFS FileSystem Mounted Instance",
          "PropagateAtLaunch": "true"
        } ]
      }
    }
  },
  "Outputs" : {
    "MountTargetID" : {
      "Description" : "Mount target ID",
      "Value" :  { "Ref" : "MountTarget" }
    },
    "FileSystemID" : {
      "Description" : "File system ID",
      "Value" :  { "Ref" : "FileSystem" }
    }
  }
}
```

## YAML
<a name="quickref-efs-example-1.yaml"></a>

```
AWSTemplateFormatVersion: '2010-09-09'
Description: This template creates an Amazon EFS file system and mount target and
  associates it with Amazon EC2 instances in an Auto Scaling group. **WARNING** This
  template creates Amazon EC2 instances and related resources. You will be billed
  for the AWS resources used if you create a stack from this template.
Parameters:
  InstanceType:
    Description: WebServer EC2 instance type
    Type: String
    Default: t2.small
    AllowedValues:
      - t1.micro
      - t2.nano
      - t2.micro
      - t2.small
      - t2.medium
      - t2.large
      - m1.small
      - m1.medium
      - m1.large
      - m1.xlarge
      - m2.xlarge
      - m2.2xlarge
      - m2.4xlarge
      - m3.medium
      - m3.large
      - m3.xlarge
      - m3.2xlarge
      - m4.large
      - m4.xlarge
      - m4.2xlarge
      - m4.4xlarge
      - m4.10xlarge
      - c1.medium
      - c1.xlarge
      - c3.large
      - c3.xlarge
      - c3.2xlarge
      - c3.4xlarge
      - c3.8xlarge
      - c4.large
      - c4.xlarge
      - c4.2xlarge
      - c4.4xlarge
      - c4.8xlarge
      - g2.2xlarge
      - g2.8xlarge
      - r3.large
      - r3.xlarge
      - r3.2xlarge
      - r3.4xlarge
      - r3.8xlarge
      - i2.xlarge
      - i2.2xlarge
      - i2.4xlarge
      - i2.8xlarge
      - d2.xlarge
      - d2.2xlarge
      - d2.4xlarge
      - d2.8xlarge
      - hi1.4xlarge
      - hs1.8xlarge
      - cr1.8xlarge
      - cc2.8xlarge
      - cg1.4xlarge
    ConstraintDescription: must be a valid EC2 instance type.
  KeyName:
    Type: AWS::EC2::KeyPair::KeyName
    Description: Name of an existing EC2 key pair to enable SSH access to the ECS
      instances
  AsgMaxSize:
    Type: Number
    Description: Maximum size and initial desired capacity of Auto Scaling Group
    Default: '2'
  SSHLocation:
    Description: The IP address range that can be used to connect to the EC2 instances
      by using SSH
    Type: String
    MinLength: '9'
    MaxLength: '18'
    Default: 0.0.0.0/0
    AllowedPattern: "(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})/(\\d{1,2})"
    ConstraintDescription: must be a valid IP CIDR range of the form x.x.x.x/x.
  VolumeName:
    Description: The name to be used for the EFS volume
    Type: String
    MinLength: '1'
    Default: myEFSvolume
  MountPoint:
    Description: The Linux mount point for the EFS volume
    Type: String
    MinLength: '1'
    Default: myEFSvolume
Mappings:
  AWSInstanceType2Arch:
    t1.micro:
      Arch: HVM64
    t2.nano:
      Arch: HVM64
    t2.micro:
      Arch: HVM64
    t2.small:
      Arch: HVM64
    t2.medium:
      Arch: HVM64
    t2.large:
      Arch: HVM64
    m1.small:
      Arch: HVM64
    m1.medium:
      Arch: HVM64
    m1.large:
      Arch: HVM64
    m1.xlarge:
      Arch: HVM64
    m2.xlarge:
      Arch: HVM64
    m2.2xlarge:
      Arch: HVM64
    m2.4xlarge:
      Arch: HVM64
    m3.medium:
      Arch: HVM64
    m3.large:
      Arch: HVM64
    m3.xlarge:
      Arch: HVM64
    m3.2xlarge:
      Arch: HVM64
    m4.large:
      Arch: HVM64
    m4.xlarge:
      Arch: HVM64
    m4.2xlarge:
      Arch: HVM64
    m4.4xlarge:
      Arch: HVM64
    m4.10xlarge:
      Arch: HVM64
    c1.medium:
      Arch: HVM64
    c1.xlarge:
      Arch: HVM64
    c3.large:
      Arch: HVM64
    c3.xlarge:
      Arch: HVM64
    c3.2xlarge:
      Arch: HVM64
    c3.4xlarge:
      Arch: HVM64
    c3.8xlarge:
      Arch: HVM64
    c4.large:
      Arch: HVM64
    c4.xlarge:
      Arch: HVM64
    c4.2xlarge:
      Arch: HVM64
    c4.4xlarge:
      Arch: HVM64
    c4.8xlarge:
      Arch: HVM64
    g2.2xlarge:
      Arch: HVMG2
    g2.8xlarge:
      Arch: HVMG2
    r3.large:
      Arch: HVM64
    r3.xlarge:
      Arch: HVM64
    r3.2xlarge:
      Arch: HVM64
    r3.4xlarge:
      Arch: HVM64
    r3.8xlarge:
      Arch: HVM64
    i2.xlarge:
      Arch: HVM64
    i2.2xlarge:
      Arch: HVM64
    i2.4xlarge:
      Arch: HVM64
    i2.8xlarge:
      Arch: HVM64
    d2.xlarge:
      Arch: HVM64
    d2.2xlarge:
      Arch: HVM64
    d2.4xlarge:
      Arch: HVM64
    d2.8xlarge:
      Arch: HVM64
    hi1.4xlarge:
      Arch: HVM64
    hs1.8xlarge:
      Arch: HVM64
    cr1.8xlarge:
      Arch: HVM64
    cc2.8xlarge:
      Arch: HVM64
  AWSRegionArch2AMI:
    us-east-1:
      HVM64: ami-0ff8a91507f77f867
      HVMG2: ami-0a584ac55a7631c0c
    us-west-2:
      HVM64: ami-a0cfeed8
      HVMG2: ami-0e09505bc235aa82d
    us-west-1:
      HVM64: ami-0bdb828fd58c52235
      HVMG2: ami-066ee5fd4a9ef77f1
    eu-west-1:
      HVM64: ami-047bb4163c506cd98
      HVMG2: ami-0a7c483d527806435
    eu-west-2:
      HVM64: ami-f976839e
      HVMG2: NOT_SUPPORTED
    eu-west-3:
      HVM64: ami-0ebc281c20e89ba4b
      HVMG2: NOT_SUPPORTED
    eu-central-1:
      HVM64: ami-0233214e13e500f77
      HVMG2: ami-06223d46a6d0661c7
    ap-northeast-1:
      HVM64: ami-06cd52961ce9f0d85
      HVMG2: ami-053cdd503598e4a9d
    ap-northeast-2:
      HVM64: ami-0a10b2721688ce9d2
      HVMG2: NOT_SUPPORTED
    ap-northeast-3:
      HVM64: ami-0d98120a9fb693f07
      HVMG2: NOT_SUPPORTED
    ap-southeast-1:
      HVM64: ami-08569b978cc4dfa10
      HVMG2: ami-0be9df32ae9f92309
    ap-southeast-2:
      HVM64: ami-09b42976632b27e9b
      HVMG2: ami-0a9ce9fecc3d1daf8
    ap-south-1:
      HVM64: ami-0912f71e06545ad88
      HVMG2: ami-097b15e89dbdcfcf4
    us-east-2:
      HVM64: ami-0b59bfac6be064b78
      HVMG2: NOT_SUPPORTED
    ca-central-1:
      HVM64: ami-0b18956f
      HVMG2: NOT_SUPPORTED
    sa-east-1:
      HVM64: ami-07b14488da8ea02a0
      HVMG2: NOT_SUPPORTED
    cn-north-1:
      HVM64: ami-0a4eaf6c4454eda75
      HVMG2: NOT_SUPPORTED
    cn-northwest-1:
      HVM64: ami-6b6a7d09
      HVMG2: NOT_SUPPORTED
Resources:
  CloudWatchPutMetricsRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Statement:
        - Effect: Allow
          Principal:
            Service:
            - ec2.amazonaws.com
          Action:
          - sts:AssumeRole
      Path: "/"
  CloudWatchPutMetricsRolePolicy:
    Type: AWS::IAM::Policy
    Properties:
      PolicyName: CloudWatch_PutMetricData
      PolicyDocument:
        Version: '2012-10-17'
        Statement:
        - Sid: CloudWatchPutMetricData
          Effect: Allow
          Action:
          - cloudwatch:PutMetricData
          Resource:
          - "*"
      Roles:
      - Ref: CloudWatchPutMetricsRole
  CloudWatchPutMetricsInstanceProfile:
    Type: AWS::IAM::InstanceProfile
    Properties:
      Path: "/"
      Roles:
      - Ref: CloudWatchPutMetricsRole
  VPC:
    Type: AWS::EC2::VPC
    Properties:
      EnableDnsSupport: 'true'
      EnableDnsHostnames: 'true'
      CidrBlock: 10.0.0.0/16
      Tags:
      - Key: Application
        Value:
          Ref: AWS::StackId
  InternetGateway:
    Type: AWS::EC2::InternetGateway
    Properties:
      Tags:
      - Key: Application
        Value:
          Ref: AWS::StackName
      - Key: Network
        Value: Public
  GatewayToInternet:
    Type: AWS::EC2::VPCGatewayAttachment
    Properties:
      VpcId:
        Ref: VPC
      InternetGatewayId:
        Ref: InternetGateway
  RouteTable:
    Type: AWS::EC2::RouteTable
    Properties:
      VpcId:
        Ref: VPC
  SubnetRouteTableAssoc:
    Type: AWS::EC2::SubnetRouteTableAssociation
    Properties:
      RouteTableId:
        Ref: RouteTable
      SubnetId:
        Ref: Subnet
  InternetGatewayRoute:
    Type: AWS::EC2::Route
    Properties:
      DestinationCidrBlock: 0.0.0.0/0
      RouteTableId:
        Ref: RouteTable
      GatewayId:
        Ref: InternetGateway
  Subnet:
    Type: AWS::EC2::Subnet
    Properties:
      VpcId:
        Ref: VPC
      CidrBlock: 10.0.0.0/24
      Tags:
      - Key: Application
        Value:
          Ref: AWS::StackId
  InstanceSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      VpcId:
        Ref: VPC
      GroupDescription: Enable SSH access via port 22
      SecurityGroupIngress:
      - IpProtocol: tcp
        FromPort: 22
        ToPort: 22
        CidrIp:
          Ref: SSHLocation
      - IpProtocol: tcp
        FromPort: 80
        ToPort: 80
        CidrIp: 0.0.0.0/0
  MountTargetSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      VpcId:
        Ref: VPC
      GroupDescription: Security group for mount target
      SecurityGroupIngress:
      - IpProtocol: tcp
        FromPort: 2049
        ToPort: 2049
        CidrIp: 0.0.0.0/0
  FileSystem:
    Type: AWS::EFS::FileSystem
    Properties:
      PerformanceMode: generalPurpose
      FileSystemTags:
      - Key: Name
        Value:
          Ref: VolumeName
  MountTarget:
    Type: AWS::EFS::MountTarget
    Properties:
      FileSystemId:
        Ref: FileSystem
      SubnetId:
        Ref: Subnet
      SecurityGroups:
      - Ref: MountTargetSecurityGroup
  LaunchConfiguration:
    Type: AWS::AutoScaling::LaunchConfiguration
    Metadata:
      AWS::CloudFormation::Init:
        configSets:
          MountConfig:
          - setup
          - mount
        setup:
          packages:
            yum:
              nfs-utils: []
          files:
            "/home/ec2-user/post_nfsstat":
              content: !Sub |
                #!/bin/bash

                INPUT="$(cat)"
                CW_JSON_OPEN='{ "Namespace": "EFS", "MetricData": [ '
                CW_JSON_CLOSE=' ] }'
                CW_JSON_METRIC=''
                METRIC_COUNTER=0

                for COL in 1 2 3 4 5 6; do

                 COUNTER=0
                 METRIC_FIELD=$COL
                 DATA_FIELD=$(($COL+($COL-1)))

                 while read line; do
                   if [[ COUNTER -gt 0 ]]; then

                     LINE=`echo $line | tr -s ' ' `
                     AWS_COMMAND="aws cloudwatch put-metric-data --region ${AWS::Region}"
                     MOD=$(( $COUNTER % 2))

                     if [ $MOD -eq 1 ]; then
                       METRIC_NAME=`echo $LINE | cut -d ' ' -f $METRIC_FIELD`
                     else
                       METRIC_VALUE=`echo $LINE | cut -d ' ' -f $DATA_FIELD`
                     fi

                     if [[ -n "$METRIC_NAME" && -n "$METRIC_VALUE" ]]; then
                       INSTANCE_ID=$(curl -s http://169.254.169.254/latest/meta-data/instance-id)
                       CW_JSON_METRIC="$CW_JSON_METRIC { \"MetricName\": \"$METRIC_NAME\", \"Dimensions\": [{\"Name\": \"InstanceId\", \"Value\": \"$INSTANCE_ID\"} ], \"Value\": $METRIC_VALUE },"
                       unset METRIC_NAME
                       unset METRIC_VALUE

                       METRIC_COUNTER=$((METRIC_COUNTER+1))
                       if [ $METRIC_COUNTER -eq 20 ]; then
                         # 20 is max metric collection size, so we have to submit here
                         aws cloudwatch put-metric-data --region ${AWS::Region} --cli-input-json "`echo $CW_JSON_OPEN ${!CW_JSON_METRIC%?} $CW_JSON_CLOSE`"

                         # reset
                         METRIC_COUNTER=0
                         CW_JSON_METRIC=''
                       fi
                     fi



                     COUNTER=$((COUNTER+1))
                   fi

                   if [[ "$line" == "Client nfs v4:" ]]; then
                     # the next line is the good stuff
                     COUNTER=$((COUNTER+1))
                   fi
                 done <<< "$INPUT"
                done

                # submit whatever is left
                aws cloudwatch put-metric-data --region ${AWS::Region} --cli-input-json "`echo $CW_JSON_OPEN ${!CW_JSON_METRIC%?} $CW_JSON_CLOSE`"
              mode: '000755'
              owner: ec2-user
              group: ec2-user
            "/home/ec2-user/crontab":
              content: "* * * * * /usr/sbin/nfsstat | /home/ec2-user/post_nfsstat\n"
              owner: ec2-user
              group: ec2-user
          commands:
            01_createdir:
              command: !Sub "mkdir /${MountPoint}"
        mount:
          commands:
            01_mount:
              command: !Sub >
                mount -t nfs4 -o nfsvers=4.1 ${FileSystem}.efs.${AWS::Region}.amazonaws.com:/ /${MountPoint}
            02_permissions:
              command: !Sub "chown ec2-user:ec2-user /${MountPoint}"
    Properties:
      AssociatePublicIpAddress: true
      ImageId:
        Fn::FindInMap:
        - AWSRegionArch2AMI
        - Ref: AWS::Region
        - Fn::FindInMap:
          - AWSInstanceType2Arch
          - Ref: InstanceType
          - Arch
      InstanceType:
        Ref: InstanceType
      KeyName:
        Ref: KeyName
      SecurityGroups:
      - Ref: InstanceSecurityGroup
      IamInstanceProfile:
        Ref: CloudWatchPutMetricsInstanceProfile
      UserData:
        Fn::Base64: !Sub |
          #!/bin/bash -xe
          yum install -y aws-cfn-bootstrap
          /opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource LaunchConfiguration --configsets MountConfig --region ${AWS::Region}
          crontab /home/ec2-user/crontab
          /opt/aws/bin/cfn-signal -e $? --stack ${AWS::StackName} --resource AutoScalingGroup --region ${AWS::Region}
  AutoScalingGroup:
    Type: AWS::AutoScaling::AutoScalingGroup
    DependsOn:
    - MountTarget
    - GatewayToInternet
    CreationPolicy:
      ResourceSignal:
        Timeout: PT15M
        Count:
          Ref: AsgMaxSize
    Properties:
      VPCZoneIdentifier:
      - Ref: Subnet
      LaunchConfigurationName:
        Ref: LaunchConfiguration
      MinSize: '1'
      MaxSize:
        Ref: AsgMaxSize
      DesiredCapacity:
        Ref: AsgMaxSize
      Tags:
      - Key: Name
        Value: EFS FileSystem Mounted Instance
        PropagateAtLaunch: 'true'
Outputs:
  MountTargetID:
    Description: Mount target ID
    Value:
      Ref: MountTarget
  FileSystemID:
    Description: File system ID
    Value:
      Ref: FileSystem
```

# Frammenti di modello Elastic Beanstalk
<a name="quickref-elasticbeanstalk"></a>

Con Elastic Beanstalk, puoi distribuire e gestire rapidamente le applicazioni senza preoccuparti dell'infrastruttura che esegue tali AWS applicazioni. Il seguente modello di esempio può aiutarti a descrivere le risorse Elastic Beanstalk nel tuo modello. CloudFormation 

## PHP di esempio Elastic Beanstalk
<a name="quickref-elasticbeanstalk-sampleenv"></a>

Il modello di esempio seguente distribuisce un’applicazione Web PHP di esempio archiviata in un bucket Amazon S3. L'ambiente è anche un ambiente con scalabilità automatica e bilanciamento del carico, con un minimo di due istanze Amazon EC2 e un massimo di sei. Mostra un ambiente Elastic Beanstalk che utilizza una configurazione di avvio legacy. Per informazioni sull’utilizzo di un modello di avvio, consulta [Launch Templates](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/environments-cfg-autoscaling-launch-templates.html) nella *Guida per gli sviluppatori di AWS Elastic Beanstalk *.

Sostituisci `solution-stack` con un nome dello stack di soluzioni (versione della piattaforma). Per un elenco degli stack di soluzioni disponibili, usa il comando. AWS CLI **aws elasticbeanstalk list-available-solution-stacks**

### JSON
<a name="quickref-elasticbeanstalk-example-1.json"></a>

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Resources": {
        "sampleApplication": {
            "Type": "AWS::ElasticBeanstalk::Application",
            "Properties": {
                "Description": "AWS Elastic Beanstalk Sample Application"
            }
        },
        "sampleApplicationVersion": {
            "Type": "AWS::ElasticBeanstalk::ApplicationVersion",
            "Properties": {
                "ApplicationName": {
                    "Ref": "sampleApplication"
                },
                "Description": "AWS ElasticBeanstalk Sample Application Version",
                "SourceBundle": {
                    "S3Bucket": {
                        "Fn::Sub": "elasticbeanstalk-samples-${AWS::Region}"
                    },
                    "S3Key": "php-newsample-app.zip"
                }
            }
        },
        "sampleConfigurationTemplate": {
            "Type": "AWS::ElasticBeanstalk::ConfigurationTemplate",
            "Properties": {
                "ApplicationName": {
                    "Ref": "sampleApplication"
                },
                "Description": "AWS ElasticBeanstalk Sample Configuration Template",
                "OptionSettings": [
                    {
                        "Namespace": "aws:autoscaling:asg",
                        "OptionName": "MinSize",
                        "Value": "2"
                    },
                    {
                        "Namespace": "aws:autoscaling:asg",
                        "OptionName": "MaxSize",
                        "Value": "6"
                    },
                    {
                        "Namespace": "aws:elasticbeanstalk:environment",
                        "OptionName": "EnvironmentType",
                        "Value": "LoadBalanced"
                    },
                    {
                        "Namespace": "aws:autoscaling:launchconfiguration",
                        "OptionName": "IamInstanceProfile",
                        "Value": {
                            "Ref": "MyInstanceProfile"
                        }
                    }
                ],
                "SolutionStackName": "solution-stack"
            }
        },
        "sampleEnvironment": {
            "Type": "AWS::ElasticBeanstalk::Environment",
            "Properties": {
                "ApplicationName": {
                    "Ref": "sampleApplication"
                },
                "Description": "AWS ElasticBeanstalk Sample Environment",
                "TemplateName": {
                    "Ref": "sampleConfigurationTemplate"
                },
                "VersionLabel": {
                    "Ref": "sampleApplicationVersion"
                }
            }
        },
        "MyInstanceRole": {
            "Type": "AWS::IAM::Role",
            "Properties": {
                "AssumeRolePolicyDocument": {
                    "Version": "2012-10-17",		 	 	 
                    "Statement": [
                        {
                            "Effect": "Allow",
                            "Principal": {
                                "Service": [
                                    "ec2.amazonaws.com"
                                ]
                            },
                            "Action": [
                                "sts:AssumeRole"
                            ]
                        }
                    ]
                },
                "Description": "Beanstalk EC2 role",
                "ManagedPolicyArns": [
                    "arn:aws:iam::aws:policy/AWSElasticBeanstalkWebTier",
                    "arn:aws:iam::aws:policy/AWSElasticBeanstalkMulticontainerDocker",
                    "arn:aws:iam::aws:policy/AWSElasticBeanstalkWorkerTier"
                ]
            }
        },
        "MyInstanceProfile": {
            "Type": "AWS::IAM::InstanceProfile",
            "Properties": {
                "Roles": [
                    {
                        "Ref": "MyInstanceRole"
                    }
                ]
            }
        }
    }
}
```

### YAML
<a name="quickref-elasticbeanstalk-example-1.yaml"></a>

```
AWSTemplateFormatVersion: '2010-09-09'
Resources:
  sampleApplication:
    Type: AWS::ElasticBeanstalk::Application
    Properties:
      Description: AWS Elastic Beanstalk Sample Application
  sampleApplicationVersion:
    Type: AWS::ElasticBeanstalk::ApplicationVersion
    Properties:
      ApplicationName:
        Ref: sampleApplication
      Description: AWS ElasticBeanstalk Sample Application Version
      SourceBundle:
        S3Bucket: !Sub "elasticbeanstalk-samples-${AWS::Region}"
        S3Key: php-newsample-app.zip
  sampleConfigurationTemplate:
    Type: AWS::ElasticBeanstalk::ConfigurationTemplate
    Properties:
      ApplicationName:
        Ref: sampleApplication
      Description: AWS ElasticBeanstalk Sample Configuration Template
      OptionSettings:
      - Namespace: aws:autoscaling:asg
        OptionName: MinSize
        Value: '2'
      - Namespace: aws:autoscaling:asg
        OptionName: MaxSize
        Value: '6'
      - Namespace: aws:elasticbeanstalk:environment
        OptionName: EnvironmentType
        Value: LoadBalanced
      - Namespace: aws:autoscaling:launchconfiguration
        OptionName: IamInstanceProfile
        Value: !Ref MyInstanceProfile        
      SolutionStackName: solution-stack
  sampleEnvironment:
    Type: AWS::ElasticBeanstalk::Environment
    Properties:
      ApplicationName:
        Ref: sampleApplication
      Description: AWS ElasticBeanstalk Sample Environment
      TemplateName:
        Ref: sampleConfigurationTemplate
      VersionLabel:
        Ref: sampleApplicationVersion
  MyInstanceRole:
    Type: AWS::IAM::Role
    Properties: 
      AssumeRolePolicyDocument:
        Version: 2012-10-17
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - ec2.amazonaws.com
            Action:
              - sts:AssumeRole
      Description: Beanstalk EC2 role
      ManagedPolicyArns: 
        - arn:aws:iam::aws:policy/AWSElasticBeanstalkWebTier
        - arn:aws:iam::aws:policy/AWSElasticBeanstalkMulticontainerDocker
        - arn:aws:iam::aws:policy/AWSElasticBeanstalkWorkerTier
  MyInstanceProfile:
    Type: AWS::IAM::InstanceProfile
    Properties: 
      Roles:
        - !Ref MyInstanceRole
```

# Frammenti di modello Elastic Load Balancing
<a name="quickref-elb"></a>

Per creare un Application Load Balancer, un Network Load Balancer o un Gateway Load Balancer, utilizza i tipi di risorse V2 che iniziano con `AWS::ElasticLoadBalancingV2`. Per creare un Classic Load Balancer, usa i tipi di risorse che iniziano con `AWS::ElasticLoadBalancing`.

**Topics**
+ [ELBv2 risorse](#scenario-elbv2-load-balancer)
+ [Risorse relative a Classic Load Balancer](#scenario-elb-load-balancer)

## ELBv2 risorse
<a name="scenario-elbv2-load-balancer"></a>

Questo esempio definisce un Application Load Balancer con un listener HTTP e un’azione predefinita che inoltra il traffico al gruppo di destinazione. Il bilanciatore del carico utilizza le impostazioni predefinite per il controllo dell’integrità. Il gruppo target ha due EC2 istanze registrate. 

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

```
Resources:
  myLoadBalancer:
    Type: AWS::ElasticLoadBalancingV2::LoadBalancer
    Properties:
      Name: my-alb
      Type: application
      Scheme: internal
      Subnets: 
        - !Ref subnet-AZ1
        - !Ref subnet-AZ2
      SecurityGroups: 
        - !Ref mySecurityGroup

  myHTTPlistener:
    Type: AWS::ElasticLoadBalancingV2::Listener
    Properties:
      LoadBalancerArn: !Ref myLoadBalancer
      Protocol: HTTP
      Port: 80
      DefaultActions:
        - Type: "forward"
          TargetGroupArn: !Ref myTargetGroup
                        
  myTargetGroup:
    Type: AWS::ElasticLoadBalancingV2::TargetGroup
    Properties:
      Name: "my-target-group"
      Protocol: HTTP
      Port: 80
      TargetType: instance
      VpcId: !Ref myVPC
      Targets:
        - Id: !GetAtt Instance1.InstanceId
          Port: 80
        - Id: !GetAtt Instance2.InstanceId
          Port: 80
```

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

```
{
    "Resources": {
        "myLoadBalancer": {
            "Type": "AWS::ElasticLoadBalancingV2::LoadBalancer",
            "Properties": {
                "Name": "my-alb",
                "Type": "application",
                "Scheme": "internal",
                "Subnets": [
                    {
                        "Ref": "subnet-AZ1"
                    },
                    {
                        "Ref": "subnet-AZ2"
                    }
                ],
                "SecurityGroups": [
                    {
                        "Ref": "mySecurityGroup"
                    }
                ]
            }
        },
        "myHTTPlistener": {
            "Type": "AWS::ElasticLoadBalancingV2::Listener",
            "Properties": {
                "LoadBalancerArn": {
                    "Ref": "myLoadBalancer"
                },
                "Protocol": "HTTP",
                "Port": 80,
                "DefaultActions": [
                    {
                        "Type": "forward",
                        "TargetGroupArn": {
                            "Ref": "myTargetGroup"
                        }
                    }
                ]
            }
        },
        "myTargetGroup": {
            "Type": "AWS::ElasticLoadBalancingV2::TargetGroup",
            "Properties": {
                "Name": "my-target-group",
                "Protocol": "HTTP",
                "Port": 80,
                "TargetType": "instance",
                "VpcId": {
                    "Ref": "myVPC"
                },
                "Targets": [
                    {
                        "Id": {
                            "Fn::GetAtt": [
                                "Instance1",
                                "InstanceId"
                            ]
                        },
                        "Port": 80
                    },
                    {
                        "Id": {
                            "Fn::GetAtt": [
                                "Instance2",
                                "InstanceId"
                            ]
                        },
                        "Port": 80
                    }
                ]
            }
        }
    }
}
```

------

## Risorse relative a Classic Load Balancer
<a name="scenario-elb-load-balancer"></a>

Questo esempio definisce un Classic Load Balancer con un listener HTTP e nessuna istanza registrata. EC2 Il bilanciatore del carico utilizza le impostazioni predefinite per il controllo dell’integrità.

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

```
myLoadBalancer:
  Type: AWS::ElasticLoadBalancing::LoadBalancer
  Properties:
    AvailabilityZones:
    - "us-east-1a"
    Listeners:
    - LoadBalancerPort: '80'
      InstancePort: '80'
      Protocol: HTTP
```

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

```
"myLoadBalancer" : {
    "Type" : "AWS::ElasticLoadBalancing::LoadBalancer",
    "Properties" : {
        "AvailabilityZones" : [ "us-east-1a" ],
        "Listeners" : [ {
            "LoadBalancerPort" : "80",
            "InstancePort" : "80",
            "Protocol" : "HTTP"
        } ]
    }
}
```

------

Questo esempio definisce un Classic Load Balancer con un listener HTTP, due EC2 istanze registrate e impostazioni personalizzate per il controllo dello stato.

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

```
myClassicLoadBalancer:
  Type: AWS::ElasticLoadBalancing::LoadBalancer
  Properties:
    AvailabilityZones:
    - "us-east-1a"
    Instances:
    - Ref: Instance1
    - Ref: Instance2
    Listeners:
    - LoadBalancerPort: '80'
      InstancePort: '80'
      Protocol: HTTP
    HealthCheck:
      Target: HTTP:80/
      HealthyThreshold: '3'
      UnhealthyThreshold: '5'
      Interval: '30'
      Timeout: '5'
```

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

```
"myClassicLoadBalancer" : {
    "Type" : "AWS::ElasticLoadBalancing::LoadBalancer",
    "Properties" : {
        "AvailabilityZones" : [ "us-east-1a" ],
        "Instances" : [
            { "Ref" : "Instance1" },
            { "Ref" : "Instance2" }
        ],
        "Listeners" : [ {
            "LoadBalancerPort" : "80",
            "InstancePort" : "80",
            "Protocol" : "HTTP"
        } ],

        "HealthCheck" : {
            "Target" : "HTTP:80/",
            "HealthyThreshold" : "3",
            "UnhealthyThreshold" : "5",
            "Interval" : "30",
            "Timeout" : "5"
        }
    }
}
```

------

# AWS Identity and Access Management frammenti di modello
<a name="quickref-iam"></a>

Questa sezione contiene frammenti di AWS Identity and Access Management modello.

**Topics**
+ [Dichiarazione di una risorsa utente IAM](#scenario-iam-user)
+ [Dichiarazione di una risorsa chiave di accesso IAM](#scenario-iam-accesskey)
+ [Dichiarazione di una risorsa di gruppo IAM](#scenario-iam-group)
+ [Aggiunta di utenti a un gruppo](#scenario-iam-addusertogroup)
+ [Dichiarazione di una policy IAM](#scenario-iam-policy)
+ [Dichiarazione di una policy di bucket Amazon S3](#scenario-bucket-policy)
+ [Dichiarazione di una policy di un argomento Amazon SNS](#scenario-sns-policy)
+ [Dichiarazione di una policy Amazon SQS](#scenario-sqs-policy)
+ [Esempi di modello per i ruoli IAM](#scenarios-iamroles)

**Importante**  
Durante la creazione o l’aggiornamento di uno stack con un modello contenente risorse IAM, devi prendere atto dell’utilizzo delle funzionalità IAM. Per ulteriori informazioni, consulta [Riconoscimento delle risorse IAM nei modelli CloudFormation](control-access-with-iam.md#using-iam-capabilities).

## Dichiarazione di una risorsa utente IAM
<a name="scenario-iam-user"></a>

Questo frammento di codice mostra come dichiarare una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-user.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-user.html) per creare un utente IAM. L’utente viene dichiarato con il percorso (`"/"`) e un profilo di login che utilizza la password (`myP@ssW0rd`).

Il documento di policy `giveaccesstoqueueonly` consente all’utente di eseguire tutte le operazioni di Amazon SQS nella risorsa della coda Amazon SQS `myqueue` e rifiuta l’accesso a tutte le altre risorse della coda Amazon SQS. La funzione `Fn::GetAtt` ottiene l’attributo ARN della risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sqs-queue.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sqs-queue.html) `myqueue`.

Il documento di policy `giveaccesstotopiconly` viene aggiunto all’utente per consentirgli di eseguire tutte le operazioni di Amazon SNS nella risorsa dell’argomento Amazon SNS `mytopic` e rifiutare l’accesso a tutte le altre risorse della coda Amazon SNS. La funzione `Ref` ottiene l’attributo ARN della risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sns-topic.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sns-topic.html) `mytopic`.

### JSON
<a name="quickref-iam-example-1.json"></a>

```
"myuser" : {
   "Type" : "AWS::IAM::User",
   "Properties" : {
      "Path" : "/",
      "LoginProfile" : {
         "Password" : "myP@ssW0rd"
      },
      "Policies" : [ {
         "PolicyName" : "giveaccesstoqueueonly",
         "PolicyDocument" : {
            "Version": "2012-10-17",		 	 	 
            "Statement" : [ {
               "Effect" : "Allow",
               "Action" : [ "sqs:*" ],
               "Resource" : [ {
                  "Fn::GetAtt" : [ "myqueue", "Arn" ]
               } ]
            }, {
               "Effect" : "Deny",
               "Action" : [ "sqs:*" ],
               "NotResource" : [ {
                  "Fn::GetAtt" : [ "myqueue", "Arn" ]
               } ]
            }
         ] }
      }, {
         "PolicyName" : "giveaccesstotopiconly",
         "PolicyDocument" : {
            "Version": "2012-10-17",		 	 	 
            "Statement" : [ {
               "Effect" : "Allow",
               "Action" : [ "sns:*" ],
               "Resource" : [ { "Ref" : "mytopic" } ]
            }, {
               "Effect" : "Deny",
               "Action" : [ "sns:*" ],
               "NotResource" : [ { "Ref" : "mytopic" } ]
            } ]
         }
      } ]
   }
}
```

### YAML
<a name="quickref-iam-example-1.yaml"></a>

```
myuser:
  Type: AWS::IAM::User
  Properties:
    Path: "/"
    LoginProfile:
      Password: myP@ssW0rd
    Policies:
    - PolicyName: giveaccesstoqueueonly
      PolicyDocument:
        Version: '2012-10-17'
        Statement:
        - Effect: Allow
          Action:
          - sqs:*
          Resource:
          - !GetAtt myqueue.Arn
        - Effect: Deny
          Action:
          - sqs:*
          NotResource:
          - !GetAtt myqueue.Arn
    - PolicyName: giveaccesstotopiconly
      PolicyDocument:
        Version: '2012-10-17'
        Statement:
        - Effect: Allow
          Action:
          - sns:*
          Resource:
          - !Ref mytopic
        - Effect: Deny
          Action:
          - sns:*
          NotResource:
          - !Ref mytopic
```

## Dichiarazione di una risorsa chiave di accesso IAM
<a name="scenario-iam-accesskey"></a>

### 
<a name="quickref-iam-access-key"></a>

Questo frammento mostra una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-accesskey.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-accesskey.html). La risorsa `myaccesskey` crea una chiave di accesso e la assegna a un utente IAM dichiarato come risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-user.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-user.html) nel modello.

#### JSON
<a name="quickref-iam-example-2.json"></a>

```
"myaccesskey" : {
   "Type" : "AWS::IAM::AccessKey",
   "Properties" : {
      "UserName" : { "Ref" : "myuser" }
   }
}
```

#### YAML
<a name="quickref-iam-example-2.yaml"></a>

```
myaccesskey:
  Type: AWS::IAM::AccessKey
  Properties:
    UserName:
      !Ref myuser
```

### 
<a name="quickref-iam-access-key-2"></a>

Puoi ottenere la chiave segreta per una risorsa `AWS::IAM::AccessKey` utilizzando la funzione `Fn::GetAtt`. Uno dei modi per recuperare la chiave segreta è inserirla in un valore `Output`. Puoi ottenere la chiave di accesso utilizzando la funzione `Ref`. Le seguenti dichiarazioni del valore `Output` ottengono la chiave di accesso e la chiave segreta per `myaccesskey`.

#### JSON
<a name="quickref-iam-example-3.json"></a>

```
"AccessKeyformyaccesskey" : {
   "Value" : { "Ref" : "myaccesskey" }
},
"SecretKeyformyaccesskey" : {
   "Value" : {
      "Fn::GetAtt" : [ "myaccesskey", "SecretAccessKey" ]
   }
}
```

#### YAML
<a name="quickref-iam-example-3.yaml"></a>

```
AccessKeyformyaccesskey:
  Value:
    !Ref myaccesskey
SecretKeyformyaccesskey:
  Value: !GetAtt myaccesskey.SecretAccessKey
```

### 
<a name="quickref-iam-access-key-3"></a>

Puoi anche passare la chiave di AWS accesso e la chiave segreta a un' EC2 istanza Amazon o a un gruppo di Auto Scaling definito nel modello. La seguente dichiarazione [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-instance.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-instance.html) utilizza la proprietà `UserData` per passare la chiave di accesso e quella segreta per la risorsa `myaccesskey`.

#### JSON
<a name="quickref-iam-example-4.json"></a>

```
"myinstance" : {
   "Type" : "AWS::EC2::Instance",
   "Properties" : {
      "AvailabilityZone" : "us-east-1a",
      "ImageId" : "ami-0ff8a91507f77f867",
      "UserData" : {
         "Fn::Base64" : {
            "Fn::Join" : [
               "", [
                  "ACCESS_KEY=", {
                     "Ref" : "myaccesskey"
                  },
                  "&",
                  "SECRET_KEY=",
                  {
                     "Fn::GetAtt" : [
                        "myaccesskey",
                        "SecretAccessKey"
                     ]
                  }
               ]
            ]
         }
      }
   }
}
```

#### YAML
<a name="quickref-iam-example-4.yaml"></a>

```
myinstance:
  Type: AWS::EC2::Instance
  Properties:
    AvailabilityZone: "us-east-1a"
    ImageId: ami-0ff8a91507f77f867
    UserData:
      Fn::Base64: !Sub "ACCESS_KEY=${myaccesskey}&SECRET_KEY=${myaccesskey.SecretAccessKey}"
```

## Dichiarazione di una risorsa di gruppo IAM
<a name="scenario-iam-group"></a>

Questo frammento mostra una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-group.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-group.html). Il gruppo ha un percorso (`"/myapplication/"`). Il documento di policy `myapppolicy` viene aggiunto al gruppo per consentire agli utenti del gruppo di eseguire tutte le operazioni di Amazon SQS nella risorsa della coda Amazon SQS myqueue e rifiutare l’accesso a tutte le altre risorse Amazon SQS eccetto `myqueue`.

Per assegnare una policy a una risorsa, IAM richiede il nome della risorsa Amazon (ARN) per la risorsa. Nel frammento, la funzione `Fn::GetAtt` ottiene l’ARN della coda della risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sqs-queue.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sqs-queue.html).

### JSON
<a name="quickref-iam-example-5.json"></a>

```
"mygroup" : {
   "Type" : "AWS::IAM::Group",
   "Properties" : {
      "Path" : "/myapplication/",
      "Policies" : [ {
         "PolicyName" : "myapppolicy",
         "PolicyDocument" : {
            "Version": "2012-10-17",		 	 	 
            "Statement" : [ {
               "Effect" : "Allow",
               "Action" : [ "sqs:*" ],
               "Resource" : [ {
                  "Fn::GetAtt" : [ "myqueue", "Arn" ]
               } ]
            },
            {
               "Effect" : "Deny",
               "Action" : [ "sqs:*" ],
               "NotResource" : [ { "Fn::GetAtt" : [ "myqueue", "Arn" ] } ]
            }
         ] }
      } ]
   }
}
```

### YAML
<a name="quickref-iam-example-5.yaml"></a>

```
mygroup:
  Type: AWS::IAM::Group
  Properties:
    Path: "/myapplication/"
    Policies:
    - PolicyName: myapppolicy
      PolicyDocument:
        Version: '2012-10-17'
        Statement:
        - Effect: Allow
          Action:
          - sqs:*
          Resource: !GetAtt myqueue.Arn
        - Effect: Deny
          Action:
          - sqs:*
          NotResource: !GetAtt myqueue.Arn
```

## Aggiunta di utenti a un gruppo
<a name="scenario-iam-addusertogroup"></a>

La risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-usertogroupaddition.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-usertogroupaddition.html) aggiunge utenti a un gruppo. Nel seguente frammento, la risorsa `addUserToGroup` aggiunge i seguenti utenti a un gruppo esistente denominato `myexistinggroup2`: l’utente esistente `existinguser1` e l’utente `myuser` dichiarato come risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-user.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-user.html) nel modello.

### JSON
<a name="quickref-iam-example-6.json"></a>

```
"addUserToGroup" : {
   "Type" : "AWS::IAM::UserToGroupAddition",
   "Properties" : {
      "GroupName" : "myexistinggroup2",
      "Users" : [ "existinguser1", { "Ref" : "myuser" } ]
   }
}
```

### YAML
<a name="quickref-iam-example-6.yaml"></a>

```
addUserToGroup:
  Type: AWS::IAM::UserToGroupAddition
  Properties:
    GroupName: myexistinggroup2
    Users:
    - existinguser1
    - !Ref myuser
```

## Dichiarazione di una policy IAM
<a name="scenario-iam-policy"></a>

Questo frammento mostra come creare una policy e applicarla a più gruppi utilizzando una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-policy.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-policy.html) denominata `mypolicy`. La risorsa `mypolicy` include una proprietà `PolicyDocument` che consente le operazioni `GetObject`, `PutObject` e `PutObjectAcl` sugli oggetti nel bucket S3 rappresentato dall’ARN `arn:aws:s3:::myAWSBucket`. La risorsa `mypolicy` applica la policy a un gruppo esistente denominato `myexistinggroup1` e a un gruppo `mygroup` che viene dichiarato nel modello come una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-group.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-group.html). Questo esempio mostra come applicare una policy a un gruppo utilizzando la proprietà `Groups`; tuttavia, è anche possibile utilizzare la proprietà `Users` per aggiungere un documento della policy a un elenco di utenti.

### JSON
<a name="quickref-iam-example-7.json"></a>

```
"mypolicy" : {
   "Type" : "AWS::IAM::Policy",
   "Properties" : {
      "PolicyName" : "mygrouppolicy",
      "PolicyDocument" : {
         "Version": "2012-10-17",		 	 	 
         "Statement" : [ {
            "Effect" : "Allow",
            "Action" : [
               "s3:GetObject" , "s3:PutObject" , "s3:PutObjectAcl" ],
            "Resource" : "arn:aws:s3:::myAWSBucket/*"
         } ]
      },
      "Groups" : [ "myexistinggroup1", { "Ref" : "mygroup" } ]
   }
}
```

### YAML
<a name="quickref-iam-example-7.yaml"></a>

```
mypolicy:
  Type: AWS::IAM::Policy
  Properties:
    PolicyName: mygrouppolicy
    PolicyDocument:
      Version: '2012-10-17'
      Statement:
      - Effect: Allow
        Action:
        - s3:GetObject
        - s3:PutObject
        - s3:PutObjectAcl
        Resource: arn:aws:s3:::myAWSBucket/*
    Groups:
    - myexistinggroup1
    - !Ref mygroup
```

## Dichiarazione di una policy di bucket Amazon S3
<a name="scenario-bucket-policy"></a>

Questo frammento mostra come creare una policy e applicarla a un bucket Amazon S3 utilizzando la risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-s3-bucket.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-s3-bucket.html). La risorsa `mybucketpolicy` dichiara un documento di policy che consente all’utente IAM `user1` di eseguire l’operazione `GetObject` su tutti gli oggetti nel bucket S3 a cui la policy viene applicata. Nel frammento, la funzione `Fn::GetAtt` ottiene l’ARN della risorsa `user1`. La risorsa `mybucketpolicy` applica la policy alla risorsa `AWS::S3::BucketPolicy` mybucket. La funzione `Ref` ottiene il nome del bucket della risorsa `mybucket`.

### JSON
<a name="quickref-iam-example-8.json"></a>

```
"mybucketpolicy" : {
   "Type" : "AWS::S3::BucketPolicy",
   "Properties" : {
      "PolicyDocument" : {
         "Id" : "MyPolicy",
         "Version": "2012-10-17",		 	 	 
         "Statement" : [ {
            "Sid" : "ReadAccess",
            "Action" : [ "s3:GetObject" ],
            "Effect" : "Allow",
            "Resource" : { "Fn::Join" : [
                  "", [ "arn:aws:s3:::", { "Ref" : "mybucket" } , "/*" ]
               ] },
            "Principal" : {
               "AWS" : { "Fn::GetAtt" : [ "user1", "Arn" ] }
            }
         } ]
      },
      "Bucket" : { "Ref" : "mybucket" }
   }
}
```

### YAML
<a name="quickref-iam-example-8.yaml"></a>

```
mybucketpolicy:
  Type: AWS::S3::BucketPolicy
  Properties:
    PolicyDocument:
      Id: MyPolicy
      Version: '2012-10-17'
      Statement:
      - Sid: ReadAccess
        Action:
        - s3:GetObject
        Effect: Allow
        Resource: !Sub "arn:aws:s3:::${mybucket}/*"
        Principal:
          AWS: !GetAtt user1.Arn
    Bucket: !Ref mybucket
```

## Dichiarazione di una policy di un argomento Amazon SNS
<a name="scenario-sns-policy"></a>

Questo frammento mostra come creare una policy e applicarla a un argomento Amazon SNS utilizzando la risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sns-topicpolicy.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sns-topicpolicy.html). La risorsa `mysnspolicy` include una proprietà `PolicyDocument` che consente alla risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-user.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-user.html) `myuser` di eseguire l’operazione `Publish` su una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sns-topic.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sns-topic.html) `mytopic`. Nel frammento, la funzione `Fn::GetAtt` ottiene l’ARN per la risorsa `myuser` e la funzione `Ref` ottiene l’ARN per la risorsa `mytopic`.

### JSON
<a name="quickref-iam-example-9.json"></a>

```
"mysnspolicy" : {
   "Type" : "AWS::SNS::TopicPolicy",
   "Properties" : {
      "PolicyDocument" :  {
         "Id" : "MyTopicPolicy",
         "Version": "2012-10-17",		 	 	 
         "Statement" : [ {
            "Sid" : "My-statement-id",
            "Effect" : "Allow",
            "Principal" : {
               "AWS" : { "Fn::GetAtt" : [ "myuser", "Arn" ] }
            },
            "Action" : "sns:Publish",
            "Resource" : "*"
         } ]
      },
      "Topics" : [ { "Ref" : "mytopic" } ]
   }
}
```

### YAML
<a name="quickref-iam-example-9.yaml"></a>

```
mysnspolicy:
  Type: AWS::SNS::TopicPolicy
  Properties:
    PolicyDocument:
      Id: MyTopicPolicy
      Version: '2012-10-17'
      Statement:
      - Sid: My-statement-id
        Effect: Allow
        Principal:
          AWS: !GetAtt myuser.Arn
        Action: sns:Publish
        Resource: "*"
    Topics:
    - !Ref mytopic
```

## Dichiarazione di una policy Amazon SQS
<a name="scenario-sqs-policy"></a>

Questo frammento mostra come creare una policy e applicarla a una coda Amazon SQS utilizzando la risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sqs-queuepolicy.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sqs-queuepolicy.html). La proprietà `PolicyDocument` consente all’utente esistente `myapp` (specificato dal relativo ARN) di eseguire l’operazione `SendMessage` su una coda esistente, specificata tramite il relativo URL e su una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sqs-queue.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-sqs-queue.html) myqueue. La funzione [Ref](resources-section-structure.md#resource-properties-ref) ottiene l’URL per la risorsa `myqueue`.

### JSON
<a name="quickref-iam-example-10.json"></a>

```
"mysqspolicy" : {
   "Type" : "AWS::SQS::QueuePolicy",
   "Properties" : {
      "PolicyDocument" : {
         "Id" : "MyQueuePolicy",
         "Version": "2012-10-17",		 	 	 
         "Statement" : [ {
            "Sid" : "Allow-User-SendMessage",
            "Effect" : "Allow",
            "Principal" : {
               "AWS" : "arn:aws:iam::123456789012:user/myapp"
            },
            "Action" : [ "sqs:SendMessage" ],
            "Resource" : "*"
         } ]
      },
      "Queues" : [
         "https://sqs.us-east-2aws-region.amazonaws.com/123456789012/myexistingqueue",
         { "Ref" : "myqueue" }
      ]
   }
}
```

### YAML
<a name="quickref-iam-example-10.yaml"></a>

```
mysqspolicy:
  Type: AWS::SQS::QueuePolicy
  Properties:
    PolicyDocument:
      Id: MyQueuePolicy
      Version: '2012-10-17'
      Statement:
      - Sid: Allow-User-SendMessage
        Effect: Allow
        Principal:
          AWS: arn:aws:iam::123456789012:user/myapp
        Action:
        - sqs:SendMessage
        Resource: "*"
    Queues:
    - https://sqs.aws-region.amazonaws.com/123456789012/myexistingqueue
    - !Ref myqueue
```

## Esempi di modello per i ruoli IAM
<a name="scenarios-iamroles"></a>

Questa sezione fornisce esempi di CloudFormation modelli per i ruoli IAM per le EC2 istanze.

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

### Ruolo IAM con EC2
<a name="scenario-iamrole-ec2"></a>

In questo esempio, il profilo dell'istanza è referenziato dalla `IamInstanceProfile` proprietà dell' EC2 istanza. Sia la policy dell’istanza che del ruolo fanno riferimento a [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-role.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-role.html).

#### JSON
<a name="quickref-iam-example-11.json"></a>

```
{
   "AWSTemplateFormatVersion": "2010-09-09",
   "Resources": {
      "myEC2Instance": {
         "Type": "AWS::EC2::Instance",
         "Version": "2009-05-15",
         "Properties": {
            "ImageId": "ami-0ff8a91507f77f867",
            "InstanceType": "m1.small",
            "Monitoring": "true",
            "DisableApiTermination": "false",
            "IamInstanceProfile": {
               "Ref": "RootInstanceProfile"
            }
         }
      },
      "RootRole": {
         "Type": "AWS::IAM::Role",
         "Properties": {
            "AssumeRolePolicyDocument": {
               "Version": "2012-10-17",		 	 	 
               "Statement": [ {
                  "Effect": "Allow",
                  "Principal": {
                     "Service": [ "ec2.amazonaws.com" ]
                  },
                  "Action": [ "sts:AssumeRole" ]
               } ]
            },
            "Path": "/"
         }
      },
      "RolePolicies": {
         "Type": "AWS::IAM::Policy",
         "Properties": {
            "PolicyName": "root",
            "PolicyDocument": {
               "Version": "2012-10-17",		 	 	 
               "Statement": [ {
                  "Effect": "Allow",
                  "Action": "*",
                  "Resource": "*"
               } ]
            },
            "Roles": [ { "Ref": "RootRole" } ]
         }
      },
      "RootInstanceProfile": {
         "Type": "AWS::IAM::InstanceProfile",
         "Properties": {
            "Path": "/",
            "Roles": [ { "Ref": "RootRole" } ]
         }
      }
   }
}
```

#### YAML
<a name="quickref-iam-example-11.yaml"></a>

```
AWSTemplateFormatVersion: '2010-09-09'
Resources:
  myEC2Instance:
    Type: AWS::EC2::Instance
    Version: '2009-05-15'
    Properties:
      ImageId: ami-0ff8a91507f77f867
      InstanceType: m1.small
      Monitoring: 'true'
      DisableApiTermination: 'false'
      IamInstanceProfile:
        !Ref RootInstanceProfile
  RootRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
        - Effect: Allow
          Principal:
            Service:
            - ec2.amazonaws.com
          Action:
          - sts:AssumeRole
      Path: "/"
  RolePolicies:
    Type: AWS::IAM::Policy
    Properties:
      PolicyName: root
      PolicyDocument:
        Version: '2012-10-17'
        Statement:
        - Effect: Allow
          Action: "*"
          Resource: "*"
      Roles:
      - !Ref RootRole
  RootInstanceProfile:
    Type: AWS::IAM::InstanceProfile
    Properties:
      Path: "/"
      Roles:
      - !Ref RootRole
```

### Ruolo IAM con gruppo Auto Scaling
<a name="scenario-iamrole-asg"></a>

In questo esempio, il profilo dell'istanza è referenziato dalla `IamInstanceProfile` proprietà di una configurazione di avvio di Amazon EC2 Auto Scaling.

#### JSON
<a name="quickref-iam-example-12.json"></a>

```
{
   "AWSTemplateFormatVersion": "2010-09-09",
   "Resources": {
      "myLCOne": {
         "Type": "AWS::AutoScaling::LaunchConfiguration",
         "Version": "2009-05-15",
         "Properties": {
            "ImageId": "ami-0ff8a91507f77f867",
            "InstanceType": "m1.small",
            "InstanceMonitoring": "true",
            "IamInstanceProfile": { "Ref": "RootInstanceProfile" }
         }
      },
      "myASGrpOne": {
         "Type": "AWS::AutoScaling::AutoScalingGroup",
         "Version": "2009-05-15",
         "Properties": {
            "AvailabilityZones": [ "us-east-1a" ],
            "LaunchConfigurationName": { "Ref": "myLCOne" },
            "MinSize": "0",
            "MaxSize": "0",
            "HealthCheckType": "EC2",
            "HealthCheckGracePeriod": "120"
         }
      },
      "RootRole": {
         "Type": "AWS::IAM::Role",
         "Properties": {
            "AssumeRolePolicyDocument": {
               "Version": "2012-10-17",		 	 	 
               "Statement": [ {
                  "Effect": "Allow",
                  "Principal": {
                     "Service": [ "ec2.amazonaws.com" ]
                  },
                  "Action": [ "sts:AssumeRole" ]
               } ]
            },
            "Path": "/"
         }
      },
      "RolePolicies": {
         "Type": "AWS::IAM::Policy",
         "Properties": {
            "PolicyName": "root",
            "PolicyDocument": {
               "Version": "2012-10-17",		 	 	 
               "Statement": [ {
                  "Effect": "Allow",
                  "Action": "*",
                  "Resource": "*"
               } ]
            },
            "Roles": [ { "Ref": "RootRole" } ]
         }
      },
      "RootInstanceProfile": {
         "Type": "AWS::IAM::InstanceProfile",
         "Properties": {
            "Path": "/",
            "Roles": [ { "Ref": "RootRole" } ]
         }
      }
   }
}
```

#### YAML
<a name="quickref-iam-example-12.yaml"></a>

```
AWSTemplateFormatVersion: '2010-09-09'
Resources:
  myLCOne:
    Type: AWS::AutoScaling::LaunchConfiguration
    Version: '2009-05-15'
    Properties:
      ImageId: ami-0ff8a91507f77f867
      InstanceType: m1.small
      InstanceMonitoring: 'true'
      IamInstanceProfile:
        !Ref RootInstanceProfile
  myASGrpOne:
    Type: AWS::AutoScaling::AutoScalingGroup
    Version: '2009-05-15'
    Properties:
      AvailabilityZones:
      - "us-east-1a"
      LaunchConfigurationName:
        !Ref myLCOne
      MinSize: '0'
      MaxSize: '0'
      HealthCheckType: EC2
      HealthCheckGracePeriod: '120'
  RootRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
        - Effect: Allow
          Principal:
            Service:
            - ec2.amazonaws.com
          Action:
          - sts:AssumeRole
      Path: "/"
  RolePolicies:
    Type: AWS::IAM::Policy
    Properties:
      PolicyName: root
      PolicyDocument:
        Version: '2012-10-17'
        Statement:
        - Effect: Allow
          Action: "*"
          Resource: "*"
      Roles:
      - !Ref RootRole
  RootInstanceProfile:
    Type: AWS::IAM::InstanceProfile
    Properties:
      Path: "/"
      Roles:
      - !Ref RootRole
```

# AWS Lambda modello
<a name="quickref-lambda"></a>

Il modello seguente utilizza una funzione AWS Lambda (Lambda) e una risorsa personalizzata per aggiungere un nuovo gruppo di sicurezza a un elenco di gruppi di sicurezza esistenti. Questa funzione è utile per creare un elenco di gruppi di sicurezza in modo dinamico, così che l’elenco includa sia i nuovi gruppi di sicurezza sia quelli già esistenti. Ad esempio, è possibile passare un elenco di gruppi di sicurezza esistenti come valore di parametro, aggiungere il nuovo valore all'elenco e quindi associare tutti i valori a un'istanza. EC2 Per ulteriori informazioni sul tipo di risorsa della funzione Lambda, consulta [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-lambda-function.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-lambda-function.html).

Nell'esempio, quando CloudFormation crea la risorsa `AllSecurityGroups` personalizzata, CloudFormation richiama la funzione Lambda`AppendItemToListFunction`. CloudFormation passa l'elenco dei gruppi di sicurezza esistenti e un nuovo gruppo di sicurezza (`NewSecurityGroup`) alla funzione, che aggiunge il nuovo gruppo di sicurezza all'elenco e quindi restituisce l'elenco modificato. CloudFormation utilizza l'elenco modificato per associare tutti i gruppi di sicurezza alla `MyEC2Instance` risorsa.

## JSON
<a name="quickref-lambda-example-1.json"></a>

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Parameters": {
        "ExistingSecurityGroups": {
            "Type": "List<AWS::EC2::SecurityGroup::Id>"
        },
        "ExistingVPC": {
            "Type": "AWS::EC2::VPC::Id",
            "Description": "The VPC ID that includes the security groups in the ExistingSecurityGroups parameter."
        },
        "InstanceType": {
            "Type": "String",
            "Default": "t2.micro",
            "AllowedValues": [
                "t2.micro",
                "t3.micro"
            ]
        }
    },

    "Resources": {
        "SecurityGroup": {
            "Type": "AWS::EC2::SecurityGroup",
            "Properties": {
                "GroupDescription": "Allow HTTP traffic to the host",
                "VpcId": {
                    "Ref": "ExistingVPC"
                },
                "SecurityGroupIngress": [
                    {
                        "IpProtocol": "tcp",
                        "FromPort": 80,
                        "ToPort": 80,
                        "CidrIp": "0.0.0.0/0"
                    }
                ],
                "SecurityGroupEgress": [
                    {
                        "IpProtocol": "tcp",
                        "FromPort": 80,
                        "ToPort": 80,
                        "CidrIp": "0.0.0.0/0"
                    }
                ]
            }
        },
        "AllSecurityGroups": {
            "Type": "Custom::Split",
            "Properties": {
                "ServiceToken": {
                    "Fn::GetAtt": [
                        "AppendItemToListFunction",
                        "Arn"
                    ]
                },
                "List": {
                    "Ref": "ExistingSecurityGroups"
                },
                "AppendedItem": {
                    "Ref": "SecurityGroup"
                }
            }
        },
        "AppendItemToListFunction": {
            "Type": "AWS::Lambda::Function",
            "Properties": {
                "Handler": "index.handler",
                "Role": {
                    "Fn::GetAtt": [
                        "LambdaExecutionRole",
                        "Arn"
                    ]
                },
                "Code": {
                    "ZipFile": {
                        "Fn::Join": [
                            "",
                            [
                                "var response = require('cfn-response');",
                                "exports.handler = function(event, context) {",
                                "   var responseData = {Value: event.ResourceProperties.List};",
                                "   responseData.Value.push(event.ResourceProperties.AppendedItem);",
                                "   response.send(event, context, response.SUCCESS, responseData);",
                                "};"
                            ]
                        ]
                    }
                },
                "Runtime": "nodejs20.x"
            }
        },
        "MyEC2Instance": {
            "Type": "AWS::EC2::Instance",
            "Properties": {
                "ImageId": "{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}",
                "SecurityGroupIds": {
                    "Fn::GetAtt": [
                        "AllSecurityGroups",
                        "Value"
                    ]
                },
                "InstanceType": {
                    "Ref": "InstanceType"
                }
            }
        },
        "LambdaExecutionRole": {
            "Type": "AWS::IAM::Role",
            "Properties": {
                "AssumeRolePolicyDocument": {
                    "Version": "2012-10-17", 		 	 	 
                    "Statement": [
                        {
                            "Effect": "Allow",
                            "Principal": {
                                "Service": [
                                    "lambda.amazonaws.com"
                                ]
                            },
                            "Action": [
                                "sts:AssumeRole"
                            ]
                        }
                    ]
                },
                "Path": "/",
                "Policies": [
                    {
                        "PolicyName": "root",
                        "PolicyDocument": {
                            "Version": "2012-10-17", 		 	 	 
                            "Statement": [
                                {
                                    "Effect": "Allow",
                                    "Action": [
                                        "logs:*"
                                    ],
                                    "Resource": "arn:aws:logs:*:*:*"
                                }
                            ]
                        }
                    }
                ]
            }
        }
    },
    "Outputs": {
        "AllSecurityGroups": {
            "Description": "Security Groups that are associated with the EC2 instance",
            "Value": {
                "Fn::Join": [
                    ", ",
                    {
                        "Fn::GetAtt": [
                            "AllSecurityGroups",
                            "Value"
                        ]
                    }
                ]
            }
        }
    }
}
```

## YAML
<a name="quickref-lambda-example-1.yaml"></a>

```
AWSTemplateFormatVersion: '2010-09-09'
Parameters:
  ExistingSecurityGroups:
    Type: List<AWS::EC2::SecurityGroup::Id>
  ExistingVPC:
    Type: AWS::EC2::VPC::Id
    Description: The VPC ID that includes the security groups in the ExistingSecurityGroups parameter.
  InstanceType:
    Type: String
    Default: t2.micro
    AllowedValues:
      - t2.micro
      - t3.micro
Resources:
  SecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Allow HTTP traffic to the host
      VpcId: !Ref ExistingVPC
      SecurityGroupIngress:
        - IpProtocol: tcp
          FromPort: 80
          ToPort: 80
          CidrIp: 0.0.0.0/0
      SecurityGroupEgress:
        - IpProtocol: tcp
          FromPort: 80
          ToPort: 80
          CidrIp: 0.0.0.0/0
  AllSecurityGroups:
    Type: Custom::Split
    Properties:
      ServiceToken: !GetAtt AppendItemToListFunction.Arn
      List: !Ref ExistingSecurityGroups
      AppendedItem: !Ref SecurityGroup
  AppendItemToListFunction:
    Type: AWS::Lambda::Function
    Properties:
      Handler: index.handler
      Role: !GetAtt LambdaExecutionRole.Arn
      Code:
        ZipFile: !Join
          - ''
          - - var response = require('cfn-response');
            - exports.handler = function(event, context) {
            - '   var responseData = {Value: event.ResourceProperties.List};'
            - '   responseData.Value.push(event.ResourceProperties.AppendedItem);'
            - '   response.send(event, context, response.SUCCESS, responseData);'
            - '};'
      Runtime: nodejs20.x
  MyEC2Instance:
    Type: AWS::EC2::Instance
    Properties:
      ImageId: '{{resolve:ssm:/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2}}'
      SecurityGroupIds: !GetAtt AllSecurityGroups.Value
      InstanceType: !Ref InstanceType
  LambdaExecutionRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17' 		 	 	 
        Statement:
          - Effect: Allow
            Principal:
              Service:
                - lambda.amazonaws.com
            Action:
              - sts:AssumeRole
      Path: /
      Policies:
        - PolicyName: root
          PolicyDocument:
            Version: '2012-10-17' 		 	 	 
            Statement:
              - Effect: Allow
                Action:
                  - logs:*
                Resource: arn:aws:logs:*:*:*
Outputs:
  AllSecurityGroups:
    Description: Security Groups that are associated with the EC2 instance
    Value: !Join
      - ', '
      - !GetAtt AllSecurityGroups.Value
```

# Frammenti di modello Amazon Redshift
<a name="quickref-redshift"></a>

Amazon Redshift è un servizio di data warehouse nel cloud in scala petabyte interamente gestito. Puoi utilizzare CloudFormation per eseguire il provisioning dei cluster Amazon Redshift e gestirli.

## Cluster Amazon Redshift
<a name="quickref-redshift-samplecluster"></a>

Il modello di esempio seguente crea un cluster Amazon Redshift in base ai valori dei parametri specificati durante la creazione dello stack. Il gruppo di parametri di cluster associato al cluster Amazon Redshift attiva la registrazione delle attività degli utenti. Il modello, inoltre, avvia i cluster Amazon Redshift in un Amazon VPC definito nel modello. Il VPC include un gateway Internet in modo che sia possibile accedere ai cluster Amazon Redshift da Internet. Tuttavia, è necessario anche abilitare la comunicazione tra il cluster e il gateway Internet, operazione che viene eseguita dalla voce della tabella di routing.

**Nota**  
Il modello include la condizione `IsMultiNodeCluster`, pertanto il parametro `NumberOfNodes` viene dichiarato solo quando il valore del parametro `ClusterType` è impostato su `multi-node`.

L'esempio definisce il parametro `MysqlRootPassword` con la proprietà `NoEcho` impostata su `true`. Se si imposta l'attributo `NoEcho` su `true`, CloudFormation restituisce il valore del parametro mascherato come asterischi (\$1\$1\$1\$1\$1) per tutte le chiamate che descrivono lo stack o gli eventi stack, ad eccezione delle informazioni archiviate nelle posizioni specificate di seguito.

**Importante**  
L’utilizzo dell’attributo `NoEcho` non maschera le informazioni memorizzate nei seguenti elementi:  
La sezione dei `Metadata` modelli. CloudFormation non trasforma, modifica o oscura le informazioni incluse nella `Metadata` sezione. Per ulteriori informazioni, vedere [Metadati](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/metadata-section-structure.html).
Sezione dei modelli `Outputs`. Per ulteriori informazioni, consulta [Output](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/outputs-section-structure.html).
Attributo `Metadata` di una definizione di risorsa. Per ulteriori informazioni, consulta [Attributo `Metadata`](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-metadata.html).
Si consiglia vivamente di non utilizzare questi meccanismi per includere informazioni sensibili, come password o segreti.

**Importante**  
Invece di incorporare informazioni riservate direttamente nei CloudFormation modelli, consigliamo di utilizzare parametri dinamici nel modello di pila per fare riferimento a informazioni sensibili archiviate e gestite all'esterno CloudFormation, ad esempio nel AWS Systems Manager Parameter Store o. Gestione dei segreti AWS  
Per ulteriori informazioni, consulta la best practice [Non incorporare le credenziali nei modelli](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/security-best-practices.html#creds).

### JSON
<a name="quickref-redshift-example-1.json"></a>

```
{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Parameters" : {
    "DatabaseName" : {
      "Description" : "The name of the first database to be created when the cluster is created",
      "Type" : "String",
      "Default" : "dev",
      "AllowedPattern" : "([a-z]|[0-9])+"
    },
    "ClusterType" : {
      "Description" : "The type of cluster",
      "Type" : "String",
      "Default" : "single-node",
      "AllowedValues" : [ "single-node", "multi-node" ]
    },
    "NumberOfNodes" : {
      "Description" : "The number of compute nodes in the cluster. For multi-node clusters, the NumberOfNodes parameter must be greater than 1",
      "Type" : "Number",
      "Default" : "1"
    },
    "NodeType" : {
      "Description" : "The type of node to be provisioned",
      "Type" : "String",
      "Default" : "ds2.xlarge",
      "AllowedValues" : [ "ds2.xlarge", "ds2.8xlarge", "dc1.large", "dc1.8xlarge" ]
    }, 
    "MasterUsername" : {
      "Description" : "The user name that is associated with the master user account for the cluster that is being created",
      "Type" : "String",
      "Default" : "defaultuser",
      "AllowedPattern" : "([a-z])([a-z]|[0-9])*"
    },
    "MasterUserPassword" :  {
      "Description" : "The password that is associated with the master user account for the cluster that is being created.",
      "Type" : "String",
      "NoEcho" : "true"
    },
    "InboundTraffic" : {
      "Description" : "Allow inbound traffic to the cluster from this CIDR range.",
      "Type" : "String",
      "MinLength": "9",
      "MaxLength": "18",
      "Default" : "0.0.0.0/0",
      "AllowedPattern" : "(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})/(\\d{1,2})",
      "ConstraintDescription" : "must be a valid CIDR range of the form x.x.x.x/x."
    },
    "PortNumber" : {
      "Description" : "The port number on which the cluster accepts incoming connections.",
      "Type" : "Number",
      "Default" : "5439"
    }
  },
  "Conditions" : {
    "IsMultiNodeCluster" : {
      "Fn::Equals" : [{ "Ref" : "ClusterType" }, "multi-node" ]        
    }
  },
  "Resources" : {
    "RedshiftCluster" : {
      "Type" : "AWS::Redshift::Cluster",
      "DependsOn" : "AttachGateway",
      "Properties" : {
        "ClusterType" : { "Ref" : "ClusterType" },
        "NumberOfNodes" : { "Fn::If" : [ "IsMultiNodeCluster",  { "Ref" : "NumberOfNodes" }, { "Ref" : "AWS::NoValue" }]},
        "NodeType" : { "Ref" : "NodeType" },
        "DBName" : { "Ref" : "DatabaseName" },
        "MasterUsername" : { "Ref" : "MasterUsername" },
        "MasterUserPassword" : { "Ref" : "MasterUserPassword" },               
        "ClusterParameterGroupName" : { "Ref" : "RedshiftClusterParameterGroup" },
        "VpcSecurityGroupIds" : [ { "Ref" : "SecurityGroup" } ],
        "ClusterSubnetGroupName" : { "Ref" : "RedshiftClusterSubnetGroup" },
        "PubliclyAccessible" : "true",
        "Port" : { "Ref" : "PortNumber" }
      }
    },
    "RedshiftClusterParameterGroup" : {
      "Type" : "AWS::Redshift::ClusterParameterGroup",
      "Properties" : {
        "Description" : "Cluster parameter group",
        "ParameterGroupFamily" : "redshift-1.0",
        "Parameters" : [{
          "ParameterName" : "enable_user_activity_logging",
          "ParameterValue" : "true"
        }]
      }
    },
    "RedshiftClusterSubnetGroup" : {
      "Type" : "AWS::Redshift::ClusterSubnetGroup",
      "Properties" : {
        "Description" : "Cluster subnet group",
        "SubnetIds" : [ { "Ref" : "PublicSubnet" } ]
      }
    },
    "VPC" : {
      "Type" : "AWS::EC2::VPC",
      "Properties" : {
        "CidrBlock" : "10.0.0.0/16"
      }
    },
    "PublicSubnet" : {
      "Type" : "AWS::EC2::Subnet",
      "Properties" : {
        "CidrBlock" : "10.0.0.0/24",
        "VpcId" : { "Ref" : "VPC" }
      }
    },
    "SecurityGroup" : {
      "Type" : "AWS::EC2::SecurityGroup",
      "Properties" : {
        "GroupDescription" : "Security group",
        "SecurityGroupIngress" : [ {
          "CidrIp" : { "Ref": "InboundTraffic" },
          "FromPort" : { "Ref" : "PortNumber" },
          "ToPort" : { "Ref" : "PortNumber" },
          "IpProtocol" : "tcp"
        } ],
        "VpcId" : { "Ref" : "VPC" }
      }
    },
    "myInternetGateway" : {
      "Type" : "AWS::EC2::InternetGateway"
    },
    "AttachGateway" : {
      "Type" : "AWS::EC2::VPCGatewayAttachment",
      "Properties" : {
        "VpcId" : { "Ref" : "VPC" },
        "InternetGatewayId" : { "Ref" : "myInternetGateway" }
      }
    },
    "PublicRouteTable" : {
      "Type" : "AWS::EC2::RouteTable",
      "Properties" : {
        "VpcId" : {
          "Ref" : "VPC"
        }
      }
    },
    "PublicRoute" : {
      "Type" : "AWS::EC2::Route",
      "DependsOn" : "AttachGateway",
      "Properties"  : {
        "RouteTableId" : {
          "Ref" : "PublicRouteTable"
        },
        "DestinationCidrBlock" : "0.0.0.0/0",
        "GatewayId" : {
          "Ref" : "myInternetGateway"
        }
      }
    },
    "PublicSubnetRouteTableAssociation" : {
      "Type" : "AWS::EC2::SubnetRouteTableAssociation",
      "Properties" : {
        "SubnetId" : {
          "Ref" : "PublicSubnet"
        },
        "RouteTableId" : {
          "Ref" : "PublicRouteTable"
        }
      }
    }
  },
  "Outputs" : {
    "ClusterEndpoint" : {
      "Description" : "Cluster endpoint",
      "Value" : { "Fn::Join" : [ ":", [ { "Fn::GetAtt" : [ "RedshiftCluster", "Endpoint.Address" ] }, { "Fn::GetAtt" : [ "RedshiftCluster", "Endpoint.Port" ] } ] ] }
    },
    "ClusterName" : {
      "Description" : "Name of cluster",
      "Value" : { "Ref" : "RedshiftCluster" }
    },
    "ParameterGroupName" : {
      "Description" : "Name of parameter group",
      "Value" : { "Ref" : "RedshiftClusterParameterGroup" }
    },
    "RedshiftClusterSubnetGroupName" : {
      "Description" : "Name of cluster subnet group",
      "Value" : { "Ref" : "RedshiftClusterSubnetGroup" }
    },
    "RedshiftClusterSecurityGroupName" : {
      "Description" : "Name of cluster security group",
      "Value" : { "Ref" : "SecurityGroup" }
    }
  }
}
```

### YAML
<a name="quickref-redshift-example-1.yaml"></a>

```
AWSTemplateFormatVersion: '2010-09-09'
Parameters:
  DatabaseName:
    Description: The name of the first database to be created when the cluster is
      created
    Type: String
    Default: dev
    AllowedPattern: "([a-z]|[0-9])+"
  ClusterType:
    Description: The type of cluster
    Type: String
    Default: single-node
    AllowedValues:
    - single-node
    - multi-node
  NumberOfNodes:
    Description: The number of compute nodes in the cluster. For multi-node clusters,
      the NumberOfNodes parameter must be greater than 1
    Type: Number
    Default: '1'
  NodeType:
    Description: The type of node to be provisioned
    Type: String
    Default: ds2.xlarge
    AllowedValues:
    - ds2.xlarge
    - ds2.8xlarge
    - dc1.large
    - dc1.8xlarge
  MasterUsername:
    Description: The user name that is associated with the master user account for
      the cluster that is being created
    Type: String
    Default: defaultuser
    AllowedPattern: "([a-z])([a-z]|[0-9])*"
  MasterUserPassword:
    Description: The password that is associated with the master user account for
      the cluster that is being created.
    Type: String
    NoEcho: 'true'
  InboundTraffic:
    Description: Allow inbound traffic to the cluster from this CIDR range.
    Type: String
    MinLength: '9'
    MaxLength: '18'
    Default: 0.0.0.0/0
    AllowedPattern: "(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})\\.(\\d{1,3})/(\\d{1,2})"
    ConstraintDescription: must be a valid CIDR range of the form x.x.x.x/x.
  PortNumber:
    Description: The port number on which the cluster accepts incoming connections.
    Type: Number
    Default: '5439'
Conditions:
  IsMultiNodeCluster:
    Fn::Equals:
    - Ref: ClusterType
    - multi-node
Resources:
  RedshiftCluster:
    Type: AWS::Redshift::Cluster
    DependsOn: AttachGateway
    Properties:
      ClusterType:
        Ref: ClusterType
      NumberOfNodes:
        Fn::If:
        - IsMultiNodeCluster
        - Ref: NumberOfNodes
        - Ref: AWS::NoValue
      NodeType:
        Ref: NodeType
      DBName:
        Ref: DatabaseName
      MasterUsername:
        Ref: MasterUsername
      MasterUserPassword:
        Ref: MasterUserPassword
      ClusterParameterGroupName:
        Ref: RedshiftClusterParameterGroup
      VpcSecurityGroupIds:
      - Ref: SecurityGroup
      ClusterSubnetGroupName:
        Ref: RedshiftClusterSubnetGroup
      PubliclyAccessible: 'true'
      Port:
        Ref: PortNumber
  RedshiftClusterParameterGroup:
    Type: AWS::Redshift::ClusterParameterGroup
    Properties:
      Description: Cluster parameter group
      ParameterGroupFamily: redshift-1.0
      Parameters:
      - ParameterName: enable_user_activity_logging
        ParameterValue: 'true'
  RedshiftClusterSubnetGroup:
    Type: AWS::Redshift::ClusterSubnetGroup
    Properties:
      Description: Cluster subnet group
      SubnetIds:
      - Ref: PublicSubnet
  VPC:
    Type: AWS::EC2::VPC
    Properties:
      CidrBlock: 10.0.0.0/16
  PublicSubnet:
    Type: AWS::EC2::Subnet
    Properties:
      CidrBlock: 10.0.0.0/24
      VpcId:
        Ref: VPC
  SecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Security group
      SecurityGroupIngress:
      - CidrIp:
          Ref: InboundTraffic
        FromPort:
          Ref: PortNumber
        ToPort:
          Ref: PortNumber
        IpProtocol: tcp
      VpcId:
        Ref: VPC
  myInternetGateway:
    Type: AWS::EC2::InternetGateway
  AttachGateway:
    Type: AWS::EC2::VPCGatewayAttachment
    Properties:
      VpcId:
        Ref: VPC
      InternetGatewayId:
        Ref: myInternetGateway
  PublicRouteTable:
    Type: AWS::EC2::RouteTable
    Properties:
      VpcId:
        Ref: VPC
  PublicRoute:
    Type: AWS::EC2::Route
    DependsOn: AttachGateway
    Properties:
      RouteTableId:
        Ref: PublicRouteTable
      DestinationCidrBlock: 0.0.0.0/0
      GatewayId:
        Ref: myInternetGateway
  PublicSubnetRouteTableAssociation:
    Type: AWS::EC2::SubnetRouteTableAssociation
    Properties:
      SubnetId:
        Ref: PublicSubnet
      RouteTableId:
        Ref: PublicRouteTable
Outputs:
  ClusterEndpoint:
    Description: Cluster endpoint
    Value: !Sub "${RedshiftCluster.Endpoint.Address}:${RedshiftCluster.Endpoint.Port}"
  ClusterName:
    Description: Name of cluster
    Value:
      Ref: RedshiftCluster
  ParameterGroupName:
    Description: Name of parameter group
    Value:
      Ref: RedshiftClusterParameterGroup
  RedshiftClusterSubnetGroupName:
    Description: Name of cluster subnet group
    Value:
      Ref: RedshiftClusterSubnetGroup
  RedshiftClusterSecurityGroupName:
    Description: Name of cluster security group
    Value:
      Ref: SecurityGroup
```

## Consulta anche
<a name="w2aac11c41c72b7"></a>

[AWS::Redshift::Cluster](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-redshift-cluster.html)

# Frammenti di modello Amazon RDS
<a name="quickref-rds"></a>

**Topics**
+ [Risorsa di un’istanza database Amazon RDS](#scenario-rds-instance)
+ [Risorsa di un’istanza database (DB) Oracle Database Amazon RDS](#scenario-rds-oracleinstance)
+ [Risorsa del DBSecurity gruppo Amazon RDS per la gamma CIDR](#scenario-rds-security-group-cidr)
+ [Gruppo Amazon RDS con un DBSecurity gruppo di EC2 sicurezza Amazon](#scenario-rds-security-group-ec2)
+ [Gruppi di sicurezza VPC multipli](#scenario-multiple-vpc-security-groups)
+ [Istanza database Amazon RDS in un gruppo di sicurezza VPC](#w2aac11c41c76c15)

## Risorsa di un’istanza database Amazon RDS
<a name="scenario-rds-instance"></a>

In questo esempio viene visualizzata una risorsa dell’istanza database Amazon RDS con password utente principale gestita. Per ulteriori informazioni, consulta [Gestione delle password con Amazon RDS e Gestione dei segreti AWS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-secrets-manager.html) nella *Guida per l’utente di Amazon RDS* e [Gestione delle password con Amazon Aurora e Gestione dei segreti AWS](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/rds-secrets-manager.html) nella *Guida per l’utente di Amazon Aurora*. Poiché la proprietà `EngineVersion` opzionale non è specificata, viene utilizzata la versione del motore predefinito per questa istanza database. Per dettagli sulla versione del motore di default e altre impostazioni predefinite, consultate [Create DBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html). La `DBSecurityGroups` proprietà autorizza l'accesso alla rete alle `AWS::RDS::DBSecurityGroup` risorse `MyDbSecurityByEC2SecurityGroup` denominate and. MyDbSecurityBy CIDRIPGroup Per informazioni dettagliate, vedi [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbinstance.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbinstance.html). La risorsa dell’istanza database, inoltre, include un attributo `DeletionPolicy` impostato su `Snapshot`. Con il `Snapshot` `DeletionPolicy` set, CloudFormation scatterà un'istantanea di questa istanza DB prima di eliminarla durante l'eliminazione dello stack.

### JSON
<a name="quickref-rds-example-1.json"></a>

```
 1. "MyDB" : {
 2.  "Type" : "AWS::RDS::DBInstance",
 3.  "Properties" : {
 4.      "DBSecurityGroups" : [
 5.         {"Ref" : "MyDbSecurityByEC2SecurityGroup"}, {"Ref" : "MyDbSecurityByCIDRIPGroup"} ],
 6.      "AllocatedStorage" : "5",
 7.      "DBInstanceClass" : "db.t2.small",
 8.      "Engine" : "MySQL",
 9.      "MasterUsername" : "MyName",
10.      "ManageMasterUserPassword" : true,
11.      "MasterUserSecret" : {
12.         "KmsKeyId" : {"Ref" : "KMSKey"}
13.      }
14.  },
15.  "DeletionPolicy" : "Snapshot"
16. }
```

### YAML
<a name="quickref-rds-example-1.yaml"></a>

```
 1. MyDB:
 2.   Type: AWS::RDS::DBInstance
 3.   Properties:
 4.     DBSecurityGroups:
 5.     - Ref: MyDbSecurityByEC2SecurityGroup
 6.     - Ref: MyDbSecurityByCIDRIPGroup
 7.     AllocatedStorage: '5'
 8.     DBInstanceClass: db.t2.small
 9.     Engine: MySQL
10.     MasterUsername: MyName
11.     ManageMasterUserPassword: true
12.     MasterUserSecret:
13.       KmsKeyId: !Ref KMSKey
14.   DeletionPolicy: Snapshot
```

## Risorsa di un’istanza database (DB) Oracle Database Amazon RDS
<a name="scenario-rds-oracleinstance"></a>

In questo esempio viene creata una risorsa dell’istanza database Oracle Database con password utente principale gestita. Per ulteriori informazioni, consulta la sezione [Gestione delle password con Amazon Gestione dei segreti AWS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/rds-secrets-manager.html) nella *Guida per l’utente di Amazon RDS*. L'esempio specifica l'`Engine`as `oracle-ee` con un modello di licenza di. bring-your-own-license [Per i dettagli sulle impostazioni per le istanze di Oracle Database DB, vedere Create. DBInstance](https://docs.aws.amazon.com/AmazonRDS/latest/APIReference/API_CreateDBInstance.html) La proprietà DBSecurity Groups autorizza l'accesso alla rete alle `AWS::RDS::DBSecurityGroup` risorse denominate and. MyDbSecurityBy EC2 SecurityGroup MyDbSecurityBy CIDRIPGroup Per informazioni dettagliate, vedi [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbinstance.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbinstance.html). La risorsa dell’istanza database, inoltre, include un attributo `DeletionPolicy` impostato su `Snapshot`. Con il `Snapshot` `DeletionPolicy` set, CloudFormation scatterà un'istantanea di questa istanza DB prima di eliminarla durante l'eliminazione dello stack.

### JSON
<a name="quickref-rds-example-2.json"></a>

```
 1. "MyDB" : {
 2.  "Type" : "AWS::RDS::DBInstance",
 3.  "Properties" : {
 4.      "DBSecurityGroups" : [
 5.         {"Ref" : "MyDbSecurityByEC2SecurityGroup"}, {"Ref" : "MyDbSecurityByCIDRIPGroup"} ],
 6.      "AllocatedStorage" : "5",
 7.      "DBInstanceClass" : "db.t2.small",
 8.      "Engine" : "oracle-ee",
 9.      "LicenseModel" : "bring-your-own-license",
10.      "MasterUsername" : "master",
11.      "ManageMasterUserPassword" : true,
12.      "MasterUserSecret" : {
13.         "KmsKeyId" : {"Ref" : "KMSKey"}
14.      }
15.  },
16.  "DeletionPolicy" : "Snapshot"
17. }
```

### YAML
<a name="quickref-rds-example-2.yaml"></a>

```
 1. MyDB:
 2.   Type: AWS::RDS::DBInstance
 3.   Properties:
 4.     DBSecurityGroups:
 5.     - Ref: MyDbSecurityByEC2SecurityGroup
 6.     - Ref: MyDbSecurityByCIDRIPGroup
 7.     AllocatedStorage: '5'
 8.     DBInstanceClass: db.t2.small
 9.     Engine: oracle-ee
10.     LicenseModel: bring-your-own-license
11.     MasterUsername: master
12.     ManageMasterUserPassword: true
13.     MasterUserSecret:
14.       KmsKeyId: !Ref KMSKey
15.   DeletionPolicy: Snapshot
```

## Risorsa del DBSecurity gruppo Amazon RDS per la gamma CIDR
<a name="scenario-rds-security-group-cidr"></a>

Questo esempio mostra una risorsa `DBSecurityGroup` Amazon RDS con autorizzazioni di ingresso per l’intervallo CIDR specificato nel formato `ddd.ddd.ddd.ddd/dd`. [Per i dettagli, consulta [AWS: :RDS:: DBSecurity Group and Ingress](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbsecuritygroup.html).](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-rds-dbsecuritygroup-ingress.html)

### JSON
<a name="quickref-rds-example-3.json"></a>

```
1. "MyDbSecurityByCIDRIPGroup" : {
2.  "Type" : "AWS::RDS::DBSecurityGroup",
3.  "Properties" : {
4.      "GroupDescription" : "Ingress for CIDRIP",
5.      "DBSecurityGroupIngress" : {
6.          "CIDRIP" : "192.168.0.0/32"
7.      }
8.  }
9. }
```

### YAML
<a name="quickref-rds-example-3.yaml"></a>

```
1. MyDbSecurityByCIDRIPGroup:
2.   Type: AWS::RDS::DBSecurityGroup
3.   Properties:
4.     GroupDescription: Ingress for CIDRIP
5.     DBSecurityGroupIngress:
6.       CIDRIP: "192.168.0.0/32"
```

## Gruppo Amazon RDS con un DBSecurity gruppo di EC2 sicurezza Amazon
<a name="scenario-rds-security-group-ec2"></a>

Questo esempio mostra una risorsa [AWS: :RDS:: DBSecurity Group](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbsecuritygroup.html) con autorizzazione all'ingresso da un gruppo di EC2 sicurezza Amazon a cui fa riferimento. `MyEc2SecurityGroup`

Per fare ciò, definisci un gruppo di EC2 sicurezza e poi usi la `Ref` funzione intrinseca per fare riferimento al gruppo di sicurezza all'interno del tuo. EC2 `DBSecurityGroup`

### JSON
<a name="quickref-rds-example-4.json"></a>

```
"DBInstance" : {
   "Type": "AWS::RDS::DBInstance",
   "Properties": {
      "DBName"            : { "Ref" : "DBName" },
      "Engine"            : "MySQL",
      "MasterUsername"    : { "Ref" : "DBUsername" },
      "DBInstanceClass"   : { "Ref" : "DBClass" },
      "DBSecurityGroups"  : [ { "Ref" : "DBSecurityGroup" } ],
      "AllocatedStorage"  : { "Ref" : "DBAllocatedStorage" },
      "MasterUserPassword": { "Ref" : "DBPassword" }
   }
},

"DBSecurityGroup": {
   "Type": "AWS::RDS::DBSecurityGroup",
   "Properties": {
      "DBSecurityGroupIngress": {
         "EC2SecurityGroupName": {
            "Fn::GetAtt": ["WebServerSecurityGroup", "GroupName"]
         }
      },
      "GroupDescription" : "Frontend Access"
   }
},

"WebServerSecurityGroup" : {
   "Type" : "AWS::EC2::SecurityGroup",
   "Properties" : {
      "GroupDescription" : "Enable HTTP access via port 80 and SSH access",
      "SecurityGroupIngress" : [
         {"IpProtocol" : "tcp", "FromPort" : 80, "ToPort" : 80, "CidrIp" : "0.0.0.0/0"},
         {"IpProtocol" : "tcp", "FromPort" : 22, "ToPort" : 22, "CidrIp" : "0.0.0.0/0"}
      ]
   }
}
```

### YAML
<a name="quickref-rds-example-4.yaml"></a>

Questo esempio è estratto dal seguente esempio completo: [Drupal\$1Single\$1Instance\$1With\$1RDS.template](https://s3.amazonaws.com/cloudformation-templates-us-east-1/Drupal_Single_Instance_With_RDS.template)

```
DBInstance:
  Type: AWS::RDS::DBInstance
  Properties:
    DBName:
      Ref: DBName
    Engine: MySQL
    MasterUsername:
      Ref: DBUsername
    DBInstanceClass:
      Ref: DBClass
    DBSecurityGroups:
    - Ref: DBSecurityGroup
    AllocatedStorage:
      Ref: DBAllocatedStorage
    MasterUserPassword:
      Ref: DBPassword
DBSecurityGroup:
  Type: AWS::RDS::DBSecurityGroup
  Properties:
    DBSecurityGroupIngress:
      EC2SecurityGroupName:
        Ref: WebServerSecurityGroup
    GroupDescription: Frontend Access
WebServerSecurityGroup:
  Type: AWS::EC2::SecurityGroup
  Properties:
    GroupDescription: Enable HTTP access via port 80 and SSH access
    SecurityGroupIngress:
    - IpProtocol: tcp
      FromPort: 80
      ToPort: 80
      CidrIp: 0.0.0.0/0
    - IpProtocol: tcp
      FromPort: 22
      ToPort: 22
      CidrIp: 0.0.0.0/0
```

## Gruppi di sicurezza VPC multipli
<a name="scenario-multiple-vpc-security-groups"></a>

Questo esempio mostra una risorsa [AWS: :RDS:: DBSecurity Group](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbsecuritygroup.html) con autorizzazione all'ingresso per più gruppi di EC2 sicurezza Amazon VPC in [AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbsecuritygroupingress.html): :RDS::. DBSecurity GroupIngress

### JSON
<a name="quickref-rds-example-5.json"></a>

```
{
   "Resources" : {
      "DBinstance" : {
         "Type" : "AWS::RDS::DBInstance",
         "Properties" : {
            "AllocatedStorage" : "5",
            "DBInstanceClass" : "db.t2.small",
           "DBName" : {"Ref": "MyDBName" },
            "DBSecurityGroups" : [ { "Ref" : "DbSecurityByEC2SecurityGroup" } ],
            "DBSubnetGroupName" : { "Ref" : "MyDBSubnetGroup" },
            "Engine" : "MySQL",
           "MasterUserPassword": { "Ref" : "MyDBPassword" },
           "MasterUsername"    : { "Ref" : "MyDBUsername" }
        },
         "DeletionPolicy" : "Snapshot"
      },
      "DbSecurityByEC2SecurityGroup" : {
         "Type" : "AWS::RDS::DBSecurityGroup",
         "Properties" : {
            "GroupDescription" : "Ingress for Amazon EC2 security group",
           "EC2VpcId" : { "Ref" : "MyVPC" },
            "DBSecurityGroupIngress" : [ {
               "EC2SecurityGroupId" : "sg-b0ff1111",
               "EC2SecurityGroupOwnerId" : "111122223333"
            }, {
               "EC2SecurityGroupId" : "sg-ffd722222",
               "EC2SecurityGroupOwnerId" : "111122223333"
            } ]
         }
      }
   }
}
```

### YAML
<a name="quickref-rds-example-5.yaml"></a>

```
Resources:
  DBinstance:
    Type: AWS::RDS::DBInstance
    Properties:
      AllocatedStorage: '5'
      DBInstanceClass: db.t2.small
      DBName:
        Ref: MyDBName
      DBSecurityGroups:
      - Ref: DbSecurityByEC2SecurityGroup
      DBSubnetGroupName:
        Ref: MyDBSubnetGroup
      Engine: MySQL
      MasterUserPassword:
        Ref: MyDBPassword
      MasterUsername:
        Ref: MyDBUsername
    DeletionPolicy: Snapshot
  DbSecurityByEC2SecurityGroup:
    Type: AWS::RDS::DBSecurityGroup
    Properties:
      GroupDescription: Ingress for Amazon EC2 security group
      EC2VpcId:
        Ref: MyVPC
      DBSecurityGroupIngress:
      - EC2SecurityGroupId: sg-b0ff1111
        EC2SecurityGroupOwnerId: '111122223333'
      - EC2SecurityGroupId: sg-ffd722222
        EC2SecurityGroupOwnerId: '111122223333'
```

## Istanza database Amazon RDS in un gruppo di sicurezza VPC
<a name="w2aac11c41c76c15"></a>

Questo esempio mostra un'istanza di database Amazon RDS associata a un gruppo di sicurezza Amazon EC2 VPC.

### JSON
<a name="quickref-rds-example-6.json"></a>

```
{
  "DBEC2SecurityGroup": {
    "Type": "AWS::EC2::SecurityGroup",
    "Properties" : {
      "GroupDescription": "Open database for access",
      "SecurityGroupIngress" : [{
        "IpProtocol" : "tcp",
        "FromPort" : 3306,
        "ToPort" : 3306,
        "SourceSecurityGroupName" : { "Ref" : "WebServerSecurityGroup" }
      }]
    }
  },
  "DBInstance" : {
    "Type": "AWS::RDS::DBInstance",
    "Properties": {
      "DBName"            : { "Ref" : "DBName" },
      "Engine"            : "MySQL",
      "MultiAZ"           : { "Ref": "MultiAZDatabase" },
      "MasterUsername"    : { "Ref" : "DBUser" },
      "DBInstanceClass"   : { "Ref" : "DBClass" },
      "AllocatedStorage"  : { "Ref" : "DBAllocatedStorage" },
      "MasterUserPassword": { "Ref" : "DBPassword" },
      "VPCSecurityGroups" : [ { "Fn::GetAtt": [ "DBEC2SecurityGroup", "GroupId" ] } ]
    }
  }
}
```

### YAML
<a name="quickref-rds-example-6.yaml"></a>

```
DBEC2SecurityGroup:
  Type: AWS::EC2::SecurityGroup
  Properties:
    GroupDescription: Open database for access
    SecurityGroupIngress:
    - IpProtocol: tcp
      FromPort: 3306
      ToPort: 3306
      SourceSecurityGroupName:
        Ref: WebServerSecurityGroup
DBInstance:
  Type: AWS::RDS::DBInstance
  Properties:
    DBName:
      Ref: DBName
    Engine: MySQL
    MultiAZ:
      Ref: MultiAZDatabase
    MasterUsername:
      Ref: DBUser
    DBInstanceClass:
      Ref: DBClass
    AllocatedStorage:
      Ref: DBAllocatedStorage
    MasterUserPassword:
      Ref: DBPassword
    VPCSecurityGroups:
    - !GetAtt DBEC2SecurityGroup.GroupId
```

# Frammenti di modello Route 53
<a name="quickref-route53"></a>

**Topics**
+ [Set di record della risorsa Amazon Route 53 che utilizza il nome o l’ID della zona ospitata](#scenario-route53-recordset-by-host)
+ [Utilizzo RecordSetGroup per impostare set di record di risorse ponderati](#scenario-recordsetgroup-weighted)
+ [Utilizzo RecordSetGroup per impostare un set di record di risorse alias](#scenario-recordsetgroup-zoneapex)
+ [Alias: record di risorse impostato per una distribuzione CloudFront](#scenario-user-friendly-url-for-cloudfront-distribution)

## Set di record della risorsa Amazon Route 53 che utilizza il nome o l’ID della zona ospitata
<a name="scenario-route53-recordset-by-host"></a>

Quando crei un set di record di risorse Amazon Route 53, devi specificare la zona ospitata in cui desideri aggiungerlo. CloudFormation fornisce due modi per specificare una zona ospitata:
+ Puoi specificare esplicitamente la zona ospitata utilizzando la proprietà `HostedZoneId`.
+ È possibile CloudFormation trovare la zona ospitata utilizzando la `HostedZoneName` proprietà. Se si utilizza la `HostedZoneName` proprietà e sono presenti più zone ospitate con lo stesso nome, CloudFormation non crea lo stack.

### Aggiungere utilizzando RecordSet HostedZoneId
<a name="scenario-recordset-using-id"></a>

In questo esempio viene aggiunto un set di record della risorsa Amazon Route 53 che contiene un record `SPF` per il nome di dominio `mysite.example.com` utilizzando la proprietà `HostedZoneId` per specificare la zona ospitata.

#### JSON
<a name="quickref-route53-example-1.json"></a>

```
 1. "myDNSRecord" : {
 2.   "Type" : "AWS::Route53::RecordSet",
 3.   "Properties" : 
 4.   {
 5.     "HostedZoneId" : "Z3DG6IL3SJCGPX",
 6.     "Name" : "mysite.example.com.",
 7.     "Type" : "SPF",
 8.     "TTL" : "900",
 9.     "ResourceRecords" : [ "\"v=spf1 ip4:192.168.0.1/16 -all\"" ]
10.   }
11. }
```

#### YAML
<a name="quickref-route53-example-1.yaml"></a>

```
1. myDNSRecord:
2.   Type: AWS::Route53::RecordSet
3.   Properties:
4.     HostedZoneId: Z3DG6IL3SJCGPX
5.     Name: mysite.example.com.
6.     Type: SPF
7.     TTL: '900'
8.     ResourceRecords:
9.     - '"v=spf1 ip4:192.168.0.1/16 -all"'
```

### Aggiungere RecordSet usando HostedZoneName
<a name="scenario-recordset-using-name"></a>

In questo esempio viene aggiunto un set di record della risorsa Amazon Route 53 per il nome di dominio "mysite.example.com" utilizzando la proprietà `HostedZoneName` per specificare la zona ospitata.

#### JSON
<a name="quickref-route53-example-2.json"></a>

```
 1. "myDNSRecord2" : {
 2.             "Type" : "AWS::Route53::RecordSet",
 3.             "Properties" : {
 4.                 "HostedZoneName" : "example.com.",
 5.                 "Name" : "mysite.example.com.",
 6.                 "Type" : "A",
 7.                 "TTL" : "900",
 8.                 "ResourceRecords" : [
 9.                     "192.168.0.1",
10.                     "192.168.0.2"
11.                 ]
12.             }
13.         }
```

#### YAML
<a name="quickref-route53-example-2.yaml"></a>

```
 1. myDNSRecord2:
 2.   Type: AWS::Route53::RecordSet
 3.   Properties:
 4.     HostedZoneName: example.com.
 5.     Name: mysite.example.com.
 6.     Type: A
 7.     TTL: '900'
 8.     ResourceRecords:
 9.     - 192.168.0.1
10.     - 192.168.0.2
```

## Utilizzo RecordSetGroup per impostare set di record di risorse ponderati
<a name="scenario-recordsetgroup-weighted"></a>

Questo esempio utilizza un [AWS::Route53::RecordSetgruppo](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-route53-recordsetgroup.html) per impostare due record CNAME per «example.com». zona ospitata. La proprietà `RecordSets` contiene il set di record CNAME per il nome DNS "mysite.example.com". Ogni set di record contiene un identificatore (`SetIdentifier`) e un peso (`Weight`). La proporzione di traffico Internet instradato alle risorse si basa sui seguenti calcoli:
+ `Frontend One`: `140/(140+60)` = `140/200` = 70%
+ `Frontend Two`: `60/(140+60)` = `60/200` = 30%

Per ulteriori informazioni sui set di record di risorse ponderati, consulta [routing ponderato](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy-weighted.html) nella *Guida per lo sviluppatore di Amazon Route 53*.

### JSON
<a name="quickref-route53-example-3.json"></a>

```
 1.         "myDNSOne" : {
 2.             "Type" : "AWS::Route53::RecordSetGroup",
 3.             "Properties" : {
 4.                 "HostedZoneName" : "example.com.",
 5.                 "Comment" : "Weighted RR for my frontends.",
 6.                 "RecordSets" : [
 7.                   {
 8.                     "Name" : "mysite.example.com.",
 9.                     "Type" : "CNAME",
10.                     "TTL" : "900",
11.                     "SetIdentifier" : "Frontend One",
12.                     "Weight" : "140",
13.                     "ResourceRecords" : ["example-ec2.amazonaws.com"]
14.                   },
15.                   {
16.                     "Name" : "mysite.example.com.",
17.                     "Type" : "CNAME",
18.                     "TTL" : "900",
19.                     "SetIdentifier" : "Frontend Two",
20.                     "Weight" : "60",
21.                     "ResourceRecords" : ["example-ec2-larger.amazonaws.com"]
22.                   }
23.                   ]
24.             }
25.         }
```

### YAML
<a name="quickref-route53-example-3.yaml"></a>

```
 1. myDNSOne:
 2.   Type: AWS::Route53::RecordSetGroup
 3.   Properties:
 4.     HostedZoneName: example.com.
 5.     Comment: Weighted RR for my frontends.
 6.     RecordSets:
 7.     - Name: mysite.example.com.
 8.       Type: CNAME
 9.       TTL: '900'
10.       SetIdentifier: Frontend One
11.       Weight: '140'
12.       ResourceRecords:
13.       - example-ec2.amazonaws.com
14.     - Name: mysite.example.com.
15.       Type: CNAME
16.       TTL: '900'
17.       SetIdentifier: Frontend Two
18.       Weight: '60'
19.       ResourceRecords:
20.       - example-ec2-larger.amazonaws.com
```

## Utilizzo RecordSetGroup per impostare un set di record di risorse alias
<a name="scenario-recordsetgroup-zoneapex"></a>

Negli esempi seguenti viene utilizzato un [AWS::Route53::RecordSetgruppo](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-route53-recordsetgroup.html) per impostare un set di record di risorse alias denominato `example.com` che indirizza il traffico verso un sistema di bilanciamento del carico ELB versione 1 (classico) e un sistema di bilanciamento del carico versione 2 (applicazione o rete). La [AliasTarget](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-properties-route53-recordset-aliastarget.html)proprietà specifica l'ID e il nome DNS della zona ospitata utilizzando la `myELB` `LoadBalancer` funzione intrinseca. `GetAtt` `GetAtt`recupera diverse proprietà della `myELB` risorsa, a seconda che si stia indirizzando il traffico verso un sistema di bilanciamento del carico della versione 1 o della versione 2:
+ load balancer Versione 1: `CanonicalHostedZoneNameID` e `DNSName`
+ load balancer Versione 2: `CanonicalHostedZoneID` e `DNSName`

Per ulteriori informazioni sui set di record di risorse alias, consulta [Scelta tra record alias e non alias](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resource-record-sets-choosing-alias-non-alias.html) nella *Guida per gli sviluppatori di Route 53*.

### JSON per il load balancer Versione 1
<a name="quickref-route53-example-4.json"></a>

```
 1.       "myELB" : {
 2.         "Type" : "AWS::ElasticLoadBalancing::LoadBalancer",
 3.         "Properties" : {
 4.             "AvailabilityZones" : [ "us-east-1a" ],
 5.             "Listeners" : [ {
 6.                 "LoadBalancerPort" : "80",
 7.                 "InstancePort" : "80",
 8.                 "Protocol" : "HTTP"
 9.             } ]
10.         }
11.       },
12.       "myDNS" : {
13.         "Type" : "AWS::Route53::RecordSetGroup",
14.         "Properties" : {
15.           "HostedZoneName" : "example.com.",
16.           "Comment" : "Zone apex alias targeted to myELB LoadBalancer.",
17.           "RecordSets" : [
18.             {
19.               "Name" : "example.com.",
20.               "Type" : "A",
21.               "AliasTarget" : {
22.                   "HostedZoneId" : { "Fn::GetAtt" : ["myELB", "CanonicalHostedZoneNameID"] },
23.                   "DNSName" : { "Fn::GetAtt" : ["myELB","DNSName"] }
24.               }
25.             }
26.           ]
27.         }
28.     }
```

### YAML per il load balancer Versione 1
<a name="quickref-route53-example-4.yaml"></a>

```
 1. myELB:
 2.   Type: AWS::ElasticLoadBalancing::LoadBalancer
 3.   Properties:
 4.     AvailabilityZones:
 5.     - "us-east-1a"
 6.     Listeners:
 7.     - LoadBalancerPort: '80'
 8.       InstancePort: '80'
 9.       Protocol: HTTP
10. myDNS:
11.   Type: AWS::Route53::RecordSetGroup
12.   Properties:
13.     HostedZoneName: example.com.
14.     Comment: Zone apex alias targeted to myELB LoadBalancer.
15.     RecordSets:
16.     - Name: example.com.
17.       Type: A
18.       AliasTarget:
19.         HostedZoneId: !GetAtt 'myELB.CanonicalHostedZoneNameID'
20.         DNSName: !GetAtt 'myELB.DNSName'
```

### JSON per il load balancer Versione 2
<a name="quickref-route53-example-4-v2.json"></a>

```
 1.       "myELB" : {
 2.         "Type" : "AWS::ElasticLoadBalancing::LoadBalancer",
 3.         "Properties" : {
 4.             "Subnets" : [ 
 5.                 {"Ref": "SubnetAZ1"}, 
 6.                 {"Ref" : "SubnetAZ2"}
 7.             ]
 8.         }
 9.       },
10.       "myDNS" : {
11.         "Type" : "AWS::Route53::RecordSetGroup",
12.         "Properties" : {
13.           "HostedZoneName" : "example.com.",
14.           "Comment" : "Zone apex alias targeted to myELB LoadBalancer.",
15.           "RecordSets" : [
16.             {
17.               "Name" : "example.com.",
18.               "Type" : "A",
19.               "AliasTarget" : {
20.                   "HostedZoneId" : { "Fn::GetAtt" : ["myELB", "CanonicalHostedZoneID"] },
21.                   "DNSName" : { "Fn::GetAtt" : ["myELB","DNSName"] }
22.               }
23.             }
24.           ]
25.         }
26.     }
```

### YAML per il load balancer Versione 2
<a name="quickref-route53-example-4-v2.yaml"></a>

```
 1. myELB:
 2.   Type: AWS::ElasticLoadBalancingV2::LoadBalancer
 3.   Properties:
 4.     Subnets:
 5.     - Ref: SubnetAZ1
 6.     - Ref: SubnetAZ2
 7. myDNS:
 8.   Type: AWS::Route53::RecordSetGroup
 9.   Properties:
10.     HostedZoneName: example.com.
11.     Comment: Zone apex alias targeted to myELB LoadBalancer.
12.     RecordSets:
13.     - Name: example.com.
14.       Type: A
15.       AliasTarget:
16.         HostedZoneId: !GetAtt 'myELB.CanonicalHostedZoneID'
17.         DNSName: !GetAtt 'myELB.DNSName'
```

## Alias: record di risorse impostato per una distribuzione CloudFront
<a name="scenario-user-friendly-url-for-cloudfront-distribution"></a>

L'esempio seguente crea un alias A record che indirizza un nome di dominio personalizzato a una distribuzione esistente CloudFront . `myHostedZoneID`si presume che sia un riferimento a una `AWS::Route53::HostedZone` risorsa effettiva nello stesso modello o un parametro. `myCloudFrontDistribution`si riferisce a una `AWS::CloudFront::Distribution` risorsa all'interno dello stesso modello. Il record di alias utilizza lo standard CloudFront hosted zone ID (`Z2FDTNDATAQYW2`) e risolve automaticamente il nome di dominio della distribuzione utilizzando. `Fn::GetAtt` Questa configurazione consente di instradare il traffico web dal dominio personalizzato alla CloudFront distribuzione senza richiedere un indirizzo IP.

**Nota**  
Quando crei set di record della risorsa alias, devi specificare `Z2FDTNDATAQYW2` per la proprietà `HostedZoneId`. I set di record di risorse alias per non CloudFront possono essere creati in un'area privata.

### JSON
<a name="quickref-route53-example-5.json"></a>

```
 1. {
 2.     "myDNS": {
 3.         "Type": "AWS::Route53::RecordSetGroup",
 4.         "Properties": {
 5.             "HostedZoneId": {
 6.                 "Ref": "myHostedZoneID"
 7.             },
 8.             "RecordSets": [
 9.                 {
10.                     "Name": {
11.                         "Ref": "myRecordSetDomainName"
12.                     },
13.                     "Type": "A",
14.                     "AliasTarget": {
15.                         "HostedZoneId": "Z2FDTNDATAQYW2",
16.                         "DNSName": {
17.                             "Fn::GetAtt": [
18.                                 "myCloudFrontDistribution",
19.                                 "DomainName"
20.                             ]
21.                         },
22.                         "EvaluateTargetHealth": false
23.                     }
24.                 }
25.             ]
26.         }
27.     }
28. }
```

### YAML
<a name="quickref-route53-example-5.yaml"></a>

```
 1. myDNS:
 2.   Type: AWS::Route53::RecordSetGroup
 3.   Properties:
 4.     HostedZoneId: !Ref myHostedZoneID
 5.     RecordSets:
 6.       - Name: !Ref myRecordSetDomainName
 7.         Type: A
 8.         AliasTarget:
 9.           HostedZoneId: Z2FDTNDATAQYW2
10.           DNSName: !GetAtt 
11.             - myCloudFrontDistribution
12.             - DomainName
13.           EvaluateTargetHealth: false
```

# Frammenti di modello Amazon S3
<a name="quickref-s3"></a>

Usa questi modelli di esempio di Amazon S3 per descrivere i tuoi bucket Amazon S3 con. CloudFormation Per altri esempi, consulta la sezione [Examples](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-s3-bucket.html#aws-resource-s3-bucket--examples) nella risorsa `AWS::S3::Bucket`.

**Topics**
+ [Creazione di un bucket Amazon S3 con impostazioni predefinite](#scenario-s3-bucket)
+ [Creazione di un bucket Amazon S3 per l’hosting di siti Web con `DeletionPolicy`](#scenario-s3-bucket-website)
+ [Creazione di un sito Web statico utilizzando un dominio personalizzato](#scenario-s3-bucket-website-customdomain)

## Creazione di un bucket Amazon S3 con impostazioni predefinite
<a name="scenario-s3-bucket"></a>

Questo esempio utilizza [AWS::S3::Bucket](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-s3-bucket.html) per creare un bucket con impostazioni predefinite.

### JSON
<a name="quickref-s3-example-1.json"></a>

```
1. "myS3Bucket" : {
2.       "Type" : "AWS::S3::Bucket"
3.       }
```

### YAML
<a name="quickref-s3-example-1.yaml"></a>

```
1. MyS3Bucket:
2.     Type: AWS::S3::Bucket
```

## Creazione di un bucket Amazon S3 per l’hosting di siti Web con `DeletionPolicy`
<a name="scenario-s3-bucket-website"></a>

Questo esempio crea un bucket come sito Web e disabilita il Blocco dell’accesso pubblico (sono necessarie le autorizzazioni di lettura pubblica per la configurazione di bucket per l’hosting di siti Web). Al bucket viene quindi aggiunta una policy di bucket pubblica. Poiché questa risorsa bucket ha un `DeletionPolicy` attributo impostato su`Retain`, non CloudFormation eliminerà questo bucket quando elimina lo stack. La sezione `Output` utilizza `Fn::GetAtt` per recuperare gli attributi `WebsiteURL` e `DomainName` della risorsa `S3Bucket`.

**Nota**  
Gli esempi seguenti presuppongono che le impostazioni del Blocco dell’accesso pubblico `BlockPublicPolicy` e `RestrictPublicBuckets` siano state disabilitate a livello di account. 

### JSON
<a name="quickref-s3-example-2.json"></a>

```
 1. {
 2.     "AWSTemplateFormatVersion": "2010-09-09",
 3.     "Resources": {
 4.         "S3Bucket": {
 5.             "Type": "AWS::S3::Bucket",
 6.             "Properties": {
 7.                 "PublicAccessBlockConfiguration": {
 8.                     "BlockPublicAcls": false,
 9.                     "BlockPublicPolicy": false,
10.                     "IgnorePublicAcls": false,
11.                     "RestrictPublicBuckets": false
12.                 },
13.                 "WebsiteConfiguration": {
14.                     "IndexDocument": "index.html",
15.                     "ErrorDocument": "error.html"
16.                 }
17.             },
18.             "DeletionPolicy": "Retain",
19.             "UpdateReplacePolicy": "Retain"
20.         },
21.         "BucketPolicy": {
22.             "Type": "AWS::S3::BucketPolicy",
23.             "Properties": {
24.                 "PolicyDocument": {
25.                     "Id": "MyPolicy",
26.                     "Version": "2012-10-17", 		 	 	 
27.                     "Statement": [
28.                         {
29.                             "Sid": "PublicReadForGetBucketObjects",
30.                             "Effect": "Allow",
31.                             "Principal": "*",
32.                             "Action": "s3:GetObject",
33.                             "Resource": {
34.                                 "Fn::Join": [
35.                                     "",
36.                                     [
37.                                         "arn:aws:s3:::",
38.                                         {
39.                                             "Ref": "S3Bucket"
40.                                         },
41.                                         "/*"
42.                                     ]
43.                                 ]
44.                             }
45.                         }
46.                     ]
47.                 },
48.                 "Bucket": {
49.                     "Ref": "S3Bucket"
50.                 }
51.             }
52.         }
53.     },
54.     "Outputs": {
55.         "WebsiteURL": {
56.             "Value": {
57.                 "Fn::GetAtt": [
58.                     "S3Bucket",
59.                     "WebsiteURL"
60.                 ]
61.             },
62.             "Description": "URL for website hosted on S3"
63.         },
64.         "S3BucketSecureURL": {
65.             "Value": {
66.                 "Fn::Join": [
67.                     "",
68.                     [
69.                         "https://",
70.                         {
71.                             "Fn::GetAtt": [
72.                                 "S3Bucket",
73.                                 "DomainName"
74.                             ]
75.                         }
76.                     ]
77.                 ]
78.             },
79.             "Description": "Name of S3 bucket to hold website content"
80.         }
81.     }
82. }
```

### YAML
<a name="quickref-s3-example-2.yaml"></a>

```
 1. AWSTemplateFormatVersion: 2010-09-09
 2. Resources:
 3.   S3Bucket:
 4.     Type: AWS::S3::Bucket
 5.     Properties:
 6.       PublicAccessBlockConfiguration:
 7.         BlockPublicAcls: false
 8.         BlockPublicPolicy: false
 9.         IgnorePublicAcls: false
10.         RestrictPublicBuckets: false
11.       WebsiteConfiguration:
12.         IndexDocument: index.html
13.         ErrorDocument: error.html
14.     DeletionPolicy: Retain
15.     UpdateReplacePolicy: Retain
16.   BucketPolicy:
17.     Type: AWS::S3::BucketPolicy
18.     Properties:
19.       PolicyDocument:
20.         Id: MyPolicy
21.         Version: 2012-10-17 		 	 	 
22.         Statement:
23.           - Sid: PublicReadForGetBucketObjects
24.             Effect: Allow
25.             Principal: '*'
26.             Action: 's3:GetObject'
27.             Resource: !Join 
28.               - ''
29.               - - 'arn:aws:s3:::'
30.                 - !Ref S3Bucket
31.                 - /*
32.       Bucket: !Ref S3Bucket
33. Outputs:
34.   WebsiteURL:
35.     Value: !GetAtt 
36.       - S3Bucket
37.       - WebsiteURL
38.     Description: URL for website hosted on S3
39.   S3BucketSecureURL:
40.     Value: !Join 
41.       - ''
42.       - - 'https://'
43.         - !GetAtt 
44.           - S3Bucket
45.           - DomainName
46.     Description: Name of S3 bucket to hold website content
```

## Creazione di un sito Web statico utilizzando un dominio personalizzato
<a name="scenario-s3-bucket-website-customdomain"></a>

Puoi utilizzare Route 53 con un dominio registrato. L’esempio seguente presuppone che tu abbia già creato una zona ospitata in Route 53 per il dominio. L’esempio crea due bucket per l’hosting di siti Web. Il root bucket ospita i contenuti, mentre l’altro bucket reindirizza le richieste `www.domainname.com` al root bucket. I set di record eseguono la mappatura del nome di dominio all’endpoint Amazon S3. 

Sarà necessario aggiungere una policy di bucket, come illustrato negli esempi precedenti.

Per ulteriori informazioni sull’utilizzo di un dominio personalizzato, consulta [Tutorial: Configuring a static website using a custom domain registered with Route 53](https://docs.aws.amazon.com/AmazonS3/latest/userguide/website-hosting-custom-domain-walkthrough.html) nella *Guida per l’utente di Amazon Simple Storage Service*.

**Nota**  
Gli esempi seguenti presuppongono che le impostazioni del Blocco dell’accesso pubblico `BlockPublicPolicy` e `RestrictPublicBuckets` siano state disabilitate a livello di account. 

### JSON
<a name="quickref-s3-example-3.json"></a>

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Mappings" : {
        "RegionMap" : {
            "us-east-1" : { "S3hostedzoneID" : "Z3AQBSTGFYJSTF", "websiteendpoint" : "s3-website-us-east-1.amazonaws.com" },
            "us-west-1" : { "S3hostedzoneID" : "Z2F56UZL2M1ACD", "websiteendpoint" : "s3-website-us-west-1.amazonaws.com" },
            "us-west-2" : { "S3hostedzoneID" : "Z3BJ6K6RIION7M", "websiteendpoint" : "s3-website-us-west-2.amazonaws.com" },            
            "eu-west-1" : { "S3hostedzoneID" : "Z1BKCTXD74EZPE", "websiteendpoint" : "s3-website-eu-west-1.amazonaws.com" },
            "ap-southeast-1" : { "S3hostedzoneID" : "Z3O0J2DXBE1FTB", "websiteendpoint" : "s3-website-ap-southeast-1.amazonaws.com" },
            "ap-southeast-2" : { "S3hostedzoneID" : "Z1WCIGYICN2BYD", "websiteendpoint" : "s3-website-ap-southeast-2.amazonaws.com" },
            "ap-northeast-1" : { "S3hostedzoneID" : "Z2M4EHUR26P7ZW", "websiteendpoint" : "s3-website-ap-northeast-1.amazonaws.com" },
            "sa-east-1" : { "S3hostedzoneID" : "Z31GFT0UA1I2HV", "websiteendpoint" : "s3-website-sa-east-1.amazonaws.com" }
        }
    },
    "Parameters": {
        "RootDomainName": {
            "Description": "Domain name for your website (example.com)",
            "Type": "String"
        }
    },
    "Resources": {
        "RootBucket": {
            "Type": "AWS::S3::Bucket",
            "Properties": {
                "BucketName" : {"Ref":"RootDomainName"},
                "PublicAccessBlockConfiguration": {
                    "BlockPublicAcls": false,
                    "BlockPublicPolicy": false,
                    "IgnorePublicAcls": false,
                    "RestrictPublicBuckets": false
                },
                "WebsiteConfiguration": {
                    "IndexDocument":"index.html",
                    "ErrorDocument":"404.html"
                }
            }
        },
        "WWWBucket": {
            "Type": "AWS::S3::Bucket",
            "Properties": {
                "BucketName": {
                    "Fn::Join": ["", ["www.", {"Ref":"RootDomainName"}]]
                },
                "AccessControl": "BucketOwnerFullControl",
                "WebsiteConfiguration": {
                    "RedirectAllRequestsTo": {
                        "HostName": {"Ref": "RootBucket"}
                    }
                }
            }
        },
        "myDNS": {
            "Type": "AWS::Route53::RecordSetGroup",
            "Properties": {
                "HostedZoneName": {
                    "Fn::Join": ["", [{"Ref": "RootDomainName"}, "."]]
                },
                "Comment": "Zone apex alias.",
                "RecordSets": [
                    {
                        "Name": {"Ref": "RootDomainName"},
                        "Type": "A",
                        "AliasTarget": {
                            "HostedZoneId": {"Fn::FindInMap" : [ "RegionMap", { "Ref" : "AWS::Region" }, "S3hostedzoneID"]},
                            "DNSName": {"Fn::FindInMap" : [ "RegionMap", { "Ref" : "AWS::Region" }, "websiteendpoint"]}
                        }
                    },
                    {
                        "Name": {
                            "Fn::Join": ["", ["www.", {"Ref":"RootDomainName"}]]
                        },
                        "Type": "CNAME",
                        "TTL" : "900",
                        "ResourceRecords" : [
                            {"Fn::GetAtt":["WWWBucket", "DomainName"]}
                        ]
                    }
                ]
            }
        }
    },
    "Outputs": {
        "WebsiteURL": {
            "Value": {"Fn::GetAtt": ["RootBucket", "WebsiteURL"]},
            "Description": "URL for website hosted on S3"
        }
    }
}
```

### YAML
<a name="quickref-s3-example-3.yaml"></a>

```
Parameters:
  RootDomainName:
    Description: Domain name for your website (example.com)
    Type: String
Mappings:
  RegionMap:
    us-east-1:
      S3hostedzoneID: Z3AQBSTGFYJSTF
      websiteendpoint: s3-website-us-east-1.amazonaws.com
    us-west-1:
      S3hostedzoneID: Z2F56UZL2M1ACD
      websiteendpoint: s3-website-us-west-1.amazonaws.com
    us-west-2:
      S3hostedzoneID: Z3BJ6K6RIION7M
      websiteendpoint: s3-website-us-west-2.amazonaws.com
    eu-west-1:
      S3hostedzoneID: Z1BKCTXD74EZPE
      websiteendpoint: s3-website-eu-west-1.amazonaws.com
    ap-southeast-1:
      S3hostedzoneID: Z3O0J2DXBE1FTB
      websiteendpoint: s3-website-ap-southeast-1.amazonaws.com
    ap-southeast-2:
      S3hostedzoneID: Z1WCIGYICN2BYD
      websiteendpoint: s3-website-ap-southeast-2.amazonaws.com
    ap-northeast-1:
      S3hostedzoneID: Z2M4EHUR26P7ZW
      websiteendpoint: s3-website-ap-northeast-1.amazonaws.com
    sa-east-1:
      S3hostedzoneID: Z31GFT0UA1I2HV
      websiteendpoint: s3-website-sa-east-1.amazonaws.com
Resources:
  RootBucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: !Ref RootDomainName
      PublicAccessBlockConfiguration:
        BlockPublicAcls: false
        BlockPublicPolicy: false
        IgnorePublicAcls: false
        RestrictPublicBuckets: false
      WebsiteConfiguration:
        IndexDocument: index.html
        ErrorDocument: 404.html
  WWWBucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: !Sub
        - www.${Domain}
        - Domain: !Ref RootDomainName
      AccessControl: BucketOwnerFullControl
      WebsiteConfiguration:
        RedirectAllRequestsTo:
          HostName: !Ref RootBucket
  myDNS:
    Type: AWS::Route53::RecordSetGroup
    Properties:
      HostedZoneName: !Sub 
        - ${Domain}.
        - Domain: !Ref RootDomainName
      Comment: Zone apex alias.
      RecordSets:
        - Name: !Ref RootDomainName
          Type: A
          AliasTarget:
            HostedZoneId: !FindInMap [ RegionMap, !Ref 'AWS::Region', S3hostedzoneID]
            DNSName: !FindInMap [ RegionMap, !Ref 'AWS::Region', websiteendpoint]
        - Name: !Sub
            - www.${Domain}
            - Domain: !Ref RootDomainName
          Type: CNAME
          TTL: 900
          ResourceRecords:
            - !GetAtt WWWBucket.DomainName
Outputs:
  WebsiteURL:
    Value: !GetAtt RootBucket.WebsiteURL
    Description: URL for website hosted on S3
```

# Frammenti di modello Amazon SNS
<a name="quickref-sns"></a>

Questo esempio illustra una risorsa di argomento Amazon SNS. È necessario un indirizzo e-mail valido.

## JSON
<a name="quickref-sns-example-1.json"></a>

```
1. "MySNSTopic" : {
2.     "Type" : "AWS::SNS::Topic",
3.     "Properties" : {
4.         "Subscription" : [ {
5.             "Endpoint" : "add valid email address",
6.             "Protocol" : "email"
7.         } ]
8.     }
9. }
```

## YAML
<a name="quickref-sns-example-1.yaml"></a>

```
1. MySNSTopic:
2.   Type: AWS::SNS::Topic
3.   Properties:
4.     Subscription:
5.     - Endpoint: "add valid email address"
6.       Protocol: email
```

# Frammenti di modello Amazon SQS
<a name="scenario-sqs-queue"></a>

Questo esempio illustra una coda Amazon SQS.

## JSON
<a name="scenario-sqs-queue-example-1.json"></a>

```
1. "MyQueue" : {
2.     "Type" : "AWS::SQS::Queue",
3.     "Properties" : {
4.         "VisibilityTimeout" : "value"
5.     }
6. }
```

## YAML
<a name="scenario-sqs-queue-example-1.yaml"></a>

```
1. MyQueue:
2.   Type: AWS::SQS::Queue
3.   Properties:
4.     VisibilityTimeout: value
```

# Frammenti di modello Amazon Timestream
<a name="scenario-timestream-queue"></a>

Amazon Timestream for InfluxDB consente agli sviluppatori di applicazioni DevOps e ai team di eseguire facilmente database AWS InfluxDB completamente gestiti su applicazioni di serie temporali in tempo reale utilizzando l'open source. APIs Puoi creare rapidamente un database InfluxDB che gestisca carichi di lavoro impegnativi in serie temporali. Con poche semplici chiamate API, puoi configurare, migrare, gestire e scalare un database InfluxDB con patch, backup e ripristino automatici del software. AWS [Puoi trovare questi esempi anche su -influxdb on. awslabs/amazon-timestream-tools/tree/mainline/integrations/cloudformation/timestream](https://github.com/awslabs/amazon-timestream-tools/tree/mainline/integrations/cloudformation/timestream-influxdb) GitHub

**Topics**
+ [Esempio minimo con valori predefiniti](#scenario-timestream-influxdb-example-1)
+ [Esempio più completo con parametri](#scenario-timestream-influxdb-example-2)

Questi CloudFormation modelli creano le seguenti risorse necessarie per creare, connettersi e monitorare correttamente un'istanza Amazon Timestream for InfluxDB:

**Amazon VPC**
+ `VPC`
+ Una o più `Subnet`
+ `InternetGateway`
+ `RouteTable`
+ `SecurityGroup`

**Simple Storage Service (Amazon S3)**
+ `Bucket`

**Amazon Timestream**
+ `InfluxDBInstance`

## Esempio minimo con valori predefiniti
<a name="scenario-timestream-influxdb-example-1"></a>

Questo esempio implementa un’istanza multi-AZ accessibile pubblicamente utilizzando valori predefiniti quando possibile.

### JSON
<a name="scenario-timestream-influxdb-example-1.json"></a>

```
{
  "Metadata": {
    "AWS::CloudFormation::Interface": {
      "ParameterGroups": [
        {
          "Label": {"default": "Amazon Timestream for InfluxDB Configuration"},
          "Parameters": [
            "DbInstanceName",
            "InfluxDBPassword"
          ]
        }
      ],
      "ParameterLabels": {
        "VPCCIDR": {"default": "VPC CIDR"}
      }
    }
  },
  "Parameters": {
    "DbInstanceName": {
      "Description": "The name that uniquely identifies the DB instance when interacting with the Amazon Timestream for InfluxDB API and CLI commands. This name will also be a prefix included in the endpoint. DB instance names must be unique per customer and per Region.",
      "Type": "String",
      "Default": "mydbinstance",
      "MinLength": 3,
      "MaxLength": 40,
      "AllowedPattern": "^[a-zA-z][a-zA-Z0-9]*(-[a-zA-Z0-9]+)*$"
    },
    "InfluxDBPassword": {
      "Description": "The password of the initial admin user created in InfluxDB. This password will allow you to access the InfluxDB UI to perform various administrative tasks and also use the InfluxDB CLI to create an operator token. These attributes will be stored in a Secret created in Gestione dei segreti AWS in your account.",
      "Type": "String",
      "NoEcho": true,
      "MinLength": 8,
      "MaxLength": 64,
      "AllowedPattern": "^[a-zA-Z0-9]+$"
    }
  },
  "Resources": {
    "VPC": {
      "Type": "AWS::EC2::VPC",
      "Properties": {"CidrBlock": "10.0.0.0/16"}
    },
    "InternetGateway": {"Type": "AWS::EC2::InternetGateway"},
    "InternetGatewayAttachment": {
      "Type": "AWS::EC2::VPCGatewayAttachment",
      "Properties": {
        "InternetGatewayId": {"Ref": "InternetGateway"},
        "VpcId": {"Ref": "VPC"}
      }
    },
    "Subnet1": {
      "Type": "AWS::EC2::Subnet",
      "Properties": {
        "VpcId": {"Ref": "VPC"},
        "AvailabilityZone": {
          "Fn::Select": [
            0,
            {"Fn::GetAZs": ""}
          ]
        },
        "CidrBlock": {
          "Fn::Select": [
            0,
            {
              "Fn::Cidr": [
                {
                  "Fn::GetAtt": [
                    "VPC",
                    "CidrBlock"
                  ]
                },
                2,
                12
              ]
            }
          ]
        },
        "MapPublicIpOnLaunch": true
      }
    },
    "Subnet2": {
      "Type": "AWS::EC2::Subnet",
      "Properties": {
        "VpcId": {"Ref": "VPC"},
        "AvailabilityZone": {
          "Fn::Select": [
            1,
            {"Fn::GetAZs": ""}
          ]
        },
        "CidrBlock": {
          "Fn::Select": [
            1,
            {
              "Fn::Cidr": [
                {
                  "Fn::GetAtt": [
                    "VPC",
                    "CidrBlock"
                  ]
                },
                2,
                12
              ]
            }
          ]
        },
        "MapPublicIpOnLaunch": true
      }
    },
    "RouteTable": {
      "Type": "AWS::EC2::RouteTable",
      "Properties": {
        "VpcId": {"Ref": "VPC"}
      }
    },
    "DefaultRoute": {
      "Type": "AWS::EC2::Route",
      "DependsOn": "InternetGatewayAttachment",
      "Properties": {
        "RouteTableId": {"Ref": "RouteTable"},
        "DestinationCidrBlock": "0.0.0.0/0",
        "GatewayId": {"Ref": "InternetGateway"}
      }
    },
    "Subnet1RouteTableAssociation": {
      "Type": "AWS::EC2::SubnetRouteTableAssociation",
      "Properties": {
        "RouteTableId": {"Ref": "RouteTable"},
        "SubnetId": {"Ref": "Subnet1"}
      }
    },
    "Subnet2RouteTableAssociation": {
      "Type": "AWS::EC2::SubnetRouteTableAssociation",
      "Properties": {
        "RouteTableId": {"Ref": "RouteTable"},
        "SubnetId": {"Ref": "Subnet2"}
      }
    },
    "InfluxDBSecurityGroup": {
      "Type": "AWS::EC2::SecurityGroup",
      "Properties": {
        "GroupName": "influxdb-sg",
        "GroupDescription": "Security group allowing port 8086 ingress for InfluxDB",
        "VpcId": {"Ref": "VPC"}
      }
    },
    "InfluxDBSecurityGroupIngress": {
      "Type": "AWS::EC2::SecurityGroupIngress",
      "Properties": {
        "GroupId": {"Ref": "InfluxDBSecurityGroup"},
        "IpProtocol": "tcp",
        "CidrIp": "0.0.0.0/0",
        "FromPort": 8086,
        "ToPort": 8086
      }
    },
    "InfluxDBLogsS3Bucket": {
      "Type": "AWS::S3::Bucket",
      "DeletionPolicy": "Retain"
    },
    "InfluxDBLogsS3BucketPolicy": {
      "Type": "AWS::S3::BucketPolicy",
      "Properties": {
        "Bucket": {"Ref": "InfluxDBLogsS3Bucket"},
        "PolicyDocument": {
          "Version": "2012-10-17",		 	 	 
          "Statement": [
            {
              "Action": "s3:PutObject",
              "Effect": "Allow",
              "Resource": {"Fn::Sub": "arn:aws:s3:::${InfluxDBLogsS3Bucket}/InfluxLogs/*"},
              "Principal": {"Service": "timestream-influxdb.amazonaws.com"}
            },
            {
              "Action": "s3:*",
              "Effect": "Deny",
              "Resource": [
                {"Fn::Sub": "arn:aws:s3:::${InfluxDBLogsS3Bucket}/*"},
                {"Fn::Sub": "arn:aws:s3:::${InfluxDBLogsS3Bucket}"}
              ],
              "Principal": "*",
              "Condition": {
                "Bool": {"aws:SecureTransport": false}
              }
            }
          ]
        }
      }
    },
    "DbInstance": {
      "Type": "AWS::Timestream::InfluxDBInstance",
      "DependsOn": "InfluxDBLogsS3BucketPolicy",
      "Properties": {
        "AllocatedStorage": 20,
        "DbInstanceType": "db.influx.medium",
        "Name": {"Ref": "DbInstanceName"},
        "Password": {"Ref": "InfluxDBPassword"},
        "PubliclyAccessible": true,
        "DeploymentType": "WITH_MULTIAZ_STANDBY",
        "VpcSecurityGroupIds": [
          {"Ref": "InfluxDBSecurityGroup"}
        ],
        "VpcSubnetIds": [
          {"Ref": "Subnet1"},
          {"Ref": "Subnet2"}
        ],
        "LogDeliveryConfiguration": {
          "S3Configuration": {
            "BucketName": {"Ref": "InfluxDBLogsS3Bucket"},
            "Enabled": true
          }
        }
      }
    }
  },
  "Outputs": {
    "VPC": {
      "Description": "A reference to the VPC used to create network resources",
      "Value": {"Ref": "VPC"}
    },
    "Subnets": {
      "Description": "A list of the subnets created",
      "Value": {
        "Fn::Join": [
          ",",
          [
            {"Ref": "Subnet1"},
            {"Ref": "Subnet2"}
          ]
        ]
      }
    },
    "Subnet1": {
      "Description": "A reference to the subnet in the 1st Availability Zone",
      "Value": {"Ref": "Subnet1"}
    },
    "Subnet2": {
      "Description": "A reference to the subnet in the 2nd Availability Zone",
      "Value": {"Ref": "Subnet2"}
    },
    "InfluxDBSecurityGroup": {
      "Description": "Security group with port 8086 ingress rule",
      "Value": {"Ref": "InfluxDBSecurityGroup"}
    },
    "InfluxDBLogsS3Bucket": {
      "Description": "S3 Bucket containing InfluxDB logs from the DB instance",
      "Value": {"Ref": "InfluxDBLogsS3Bucket"}
    },
    "DbInstance": {
      "Description": "A reference to the Timestream for InfluxDB DB instance",
      "Value": {"Ref": "DbInstance"}
    },
    "InfluxAuthParametersSecretArn": {
      "Description": "The Amazon Resource Name (ARN) of the Gestione dei segreti AWS secret containing the initial InfluxDB authorization parameters. The secret value is a JSON formatted key-value pair holding InfluxDB authorization values: organization, bucket, username, and password.",
      "Value": {
        "Fn::GetAtt": [
          "DbInstance",
          "InfluxAuthParametersSecretArn"
        ]
      }
    },
    "Endpoint": {
      "Description": "The endpoint URL to connect to InfluxDB",
      "Value": {
        "Fn::Join": [
          "",
          [
            "https://",
            {
              "Fn::GetAtt": [
                "DbInstance",
                "Endpoint"
              ]
            },
            ":8086"
          ]
        ]
      }
    }
  }
}
```

### YAML
<a name="scenario-timestream-influxdb-example-1.yaml"></a>

```
Metadata: 
  AWS::CloudFormation::Interface:
    ParameterGroups:
      -
        Label:
          default: "Amazon Timestream for InfluxDB Configuration"
        Parameters:
          - DbInstanceName
          - InfluxDBPassword
    ParameterLabels:
      VPCCIDR:
        default: VPC CIDR

Parameters:
  DbInstanceName:
    Description: The name that uniquely identifies the DB instance when interacting with the Amazon Timestream for InfluxDB API and CLI commands. This name will also be a prefix included in the endpoint. DB instance names must be unique per customer and per Region.
    Type: String
    Default: mydbinstance
    MinLength: 3
    MaxLength: 40
    AllowedPattern: ^[a-zA-z][a-zA-Z0-9]*(-[a-zA-Z0-9]+)*$
  InfluxDBPassword:
    Description: The password of the initial admin user created in InfluxDB. This password will allow you to access the InfluxDB UI to perform various administrative tasks and also use the InfluxDB CLI to create an operator token. These attributes will be stored in a Secret created in Gestione dei segreti AWS in your account.
    Type: String
    NoEcho: true
    MinLength: 8
    MaxLength: 64
    AllowedPattern: ^[a-zA-Z0-9]+$

Resources:
  VPC:
    Type: AWS::EC2::VPC
    Properties:
      CidrBlock: 10.0.0.0/16
  InternetGateway:
    Type: AWS::EC2::InternetGateway
  InternetGatewayAttachment:
    Type: AWS::EC2::VPCGatewayAttachment
    Properties:
      InternetGatewayId: !Ref InternetGateway
      VpcId: !Ref VPC
  Subnet1:
    Type: AWS::EC2::Subnet
    Properties:
      VpcId: !Ref VPC
      AvailabilityZone: !Select [0, !GetAZs '']
      CidrBlock: !Select [0, !Cidr [!GetAtt VPC.CidrBlock, 2, 12 ]]
      MapPublicIpOnLaunch: true
  Subnet2:
    Type: AWS::EC2::Subnet
    Properties:
      VpcId: !Ref VPC
      AvailabilityZone: !Select [1, !GetAZs  '']
      CidrBlock: !Select [1, !Cidr [!GetAtt VPC.CidrBlock, 2, 12 ]]
      MapPublicIpOnLaunch: true
  RouteTable:
    Type: AWS::EC2::RouteTable
    Properties:
      VpcId: !Ref VPC
  DefaultRoute:
    Type: AWS::EC2::Route
    DependsOn: InternetGatewayAttachment
    Properties:
      RouteTableId: !Ref RouteTable
      DestinationCidrBlock: 0.0.0.0/0
      GatewayId: !Ref InternetGateway
  Subnet1RouteTableAssociation:
    Type: AWS::EC2::SubnetRouteTableAssociation
    Properties:
      RouteTableId: !Ref RouteTable
      SubnetId: !Ref Subnet1
  Subnet2RouteTableAssociation:
    Type: AWS::EC2::SubnetRouteTableAssociation
    Properties:
      RouteTableId: !Ref RouteTable
      SubnetId: !Ref Subnet2
  InfluxDBSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupName: "influxdb-sg"
      GroupDescription: "Security group allowing port 8086 ingress for InfluxDB"
      VpcId: !Ref VPC
  InfluxDBSecurityGroupIngress:
    Type: AWS::EC2::SecurityGroupIngress
    Properties:
      GroupId: !Ref InfluxDBSecurityGroup
      IpProtocol: tcp
      CidrIp: 0.0.0.0/0
      FromPort: 8086
      ToPort: 8086
  InfluxDBLogsS3Bucket:
    Type: AWS::S3::Bucket
    DeletionPolicy: Retain
  InfluxDBLogsS3BucketPolicy:
    Type: AWS::S3::BucketPolicy
    Properties:
      Bucket: !Ref InfluxDBLogsS3Bucket
      PolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Action: "s3:PutObject"
            Effect: Allow
            Resource: !Sub arn:aws:s3:::${InfluxDBLogsS3Bucket}/InfluxLogs/*
            Principal:
              Service: timestream-influxdb.amazonaws.com
          - Action: "s3:*"
            Effect: Deny
            Resource:
              - !Sub arn:aws:s3:::${InfluxDBLogsS3Bucket}/*
              - !Sub arn:aws:s3:::${InfluxDBLogsS3Bucket}
            Principal: "*"
            Condition:
              Bool:
                aws:SecureTransport: false
  DbInstance:
    Type: AWS::Timestream::InfluxDBInstance
    DependsOn: InfluxDBLogsS3BucketPolicy
    Properties:
      AllocatedStorage: 20
      DbInstanceType: db.influx.medium
      Name: !Ref DbInstanceName
      Password: !Ref InfluxDBPassword
      PubliclyAccessible: true
      DeploymentType: WITH_MULTIAZ_STANDBY
      VpcSecurityGroupIds: 
        - !Ref InfluxDBSecurityGroup
      VpcSubnetIds:
        - !Ref Subnet1
        - !Ref Subnet2
      LogDeliveryConfiguration:
        S3Configuration:
          BucketName: !Ref InfluxDBLogsS3Bucket
          Enabled: true

Outputs:
  # Network Resources
  VPC:
    Description: A reference to the VPC used to create network resources
    Value: !Ref VPC
  Subnets:
    Description: A list of the subnets created
    Value: !Join [",", [!Ref Subnet1, !Ref Subnet2]]
  Subnet1:
    Description: A reference to the subnet in the 1st Availability Zone
    Value: !Ref Subnet1
  Subnet2:
    Description: A reference to the subnet in the 2nd Availability Zone
    Value: !Ref Subnet2
  InfluxDBSecurityGroup:
    Description: Security group with port 8086 ingress rule
    Value: !Ref InfluxDBSecurityGroup

  # Timestream for InfluxDB Resources
  InfluxDBLogsS3Bucket:
    Description: S3 Bucket containing InfluxDB logs from the DB instance
    Value: !Ref InfluxDBLogsS3Bucket
  DbInstance:
    Description: A reference to the Timestream for InfluxDB DB instance
    Value: !Ref DbInstance
  InfluxAuthParametersSecretArn:
    Description: "The Amazon Resource Name (ARN) of the Gestione dei segreti AWS secret containing the initial InfluxDB authorization parameters. The secret value is a JSON formatted key-value pair holding InfluxDB authorization values: organization, bucket, username, and password."
    Value: !GetAtt DbInstance.InfluxAuthParametersSecretArn
  Endpoint:
    Description: The endpoint URL to connect to InfluxDB
    Value: !Join ["", ["https://", !GetAtt DbInstance.Endpoint, ":8086"]]
```

## Esempio più completo con parametri
<a name="scenario-timestream-influxdb-example-2"></a>

Questo modello di esempio modifica dinamicamente le risorse di rete in base ai parametri forniti. I parametri includono `PubliclyAccessible` e `DeploymentType`.

### JSON
<a name="scenario-timestream-influxdb-example-2.json"></a>

```
{
  "Metadata": {
    "AWS::CloudFormation::Interface": {
      "ParameterGroups": [
        {
          "Label": {"default": "Network Configuration"},
          "Parameters": ["VPCCIDR"]
        },
        {
          "Label": {"default": "Amazon Timestream for InfluxDB Configuration"},
          "Parameters": [
            "DbInstanceName",
            "InfluxDBUsername",
            "InfluxDBPassword",
            "InfluxDBOrganization",
            "InfluxDBBucket",
            "DbInstanceType",
            "DbStorageType",
            "AllocatedStorage",
            "PubliclyAccessible",
            "DeploymentType"
          ]
        }
      ],
      "ParameterLabels": {
        "VPCCIDR": {"default": "VPC CIDR"}
      }
    }
  },
  "Parameters": {
    "VPCCIDR": {
      "Description": "Please enter the IP range (CIDR notation) for the new VPC",
      "Type": "String",
      "Default": "10.0.0.0/16"
    },
    "DbInstanceName": {
      "Description": "The name that uniquely identifies the DB instance when interacting with the Amazon Timestream for InfluxDB API and CLI commands. This name will also be a prefix included in the endpoint. DB instance names must be unique per customer and per Region.",
      "Type": "String",
      "Default": "mydbinstance",
      "MinLength": 3,
      "MaxLength": 40,
      "AllowedPattern": "^[a-zA-z][a-zA-Z0-9]*(-[a-zA-Z0-9]+)*$"
    },
    "InfluxDBUsername": {
      "Description": "The username of the initial admin user created in InfluxDB. Must start with a letter and can't end with a hyphen or contain two consecutive hyphens. For example, my-user1. This username will allow you to access the InfluxDB UI to perform various administrative tasks and also use the InfluxDB CLI to create an operator token. These attributes will be stored in a Secret created in Gestione dei segreti AWS in your account.",
      "Type": "String",
      "Default": "admin",
      "MinLength": 1,
      "MaxLength": 64
    },
    "InfluxDBPassword": {
      "Description": "The password of the initial admin user created in InfluxDB. This password will allow you to access the InfluxDB UI to perform various administrative tasks and also use the InfluxDB CLI to create an operator token. These attributes will be stored in a Secret created in Gestione dei segreti AWS in your account.",
      "Type": "String",
      "NoEcho": true,
      "MinLength": 8,
      "MaxLength": 64,
      "AllowedPattern": "^[a-zA-Z0-9]+$"
    },
    "InfluxDBOrganization": {
      "Description": "The name of the initial organization for the initial admin user in InfluxDB. An InfluxDB organization is a workspace for a group of users.",
      "Type": "String",
      "Default": "org",
      "MinLength": 1,
      "MaxLength": 64
    },
    "InfluxDBBucket": {
      "Description": "The name of the initial InfluxDB bucket. All InfluxDB data is stored in a bucket. A bucket combines the concept of a database and a retention period (the duration of time that each data point persists). A bucket belongs to an organization.",
      "Type": "String",
      "Default": "bucket",
      "MinLength": 2,
      "MaxLength": 64,
      "AllowedPattern": "^[^_\\\"][^\\\"]*$"
    },
    "DeploymentType": {
      "Description": "Specifies whether the Timestream for InfluxDB is deployed as Single-AZ or with a MultiAZ Standby for High availability",
      "Type": "String",
      "Default": "WITH_MULTIAZ_STANDBY",
      "AllowedValues": [
        "SINGLE_AZ",
        "WITH_MULTIAZ_STANDBY"
      ]
    },
    "AllocatedStorage": {
      "Description": "The amount of storage to allocate for your DB storage type in GiB (gibibytes).",
      "Type": "Number",
      "Default": 400,
      "MinValue": 20,
      "MaxValue": 16384
    },
    "DbInstanceType": {
      "Description": "The Timestream for InfluxDB DB instance type to run InfluxDB on.",
      "Type": "String",
      "Default": "db.influx.medium",
      "AllowedValues": [
        "db.influx.medium",
        "db.influx.large",
        "db.influx.xlarge",
        "db.influx.2xlarge",
        "db.influx.4xlarge",
        "db.influx.8xlarge",
        "db.influx.12xlarge",
        "db.influx.16xlarge"
      ]
    },
    "DbStorageType": {
      "Description": "The Timestream for InfluxDB DB storage type to read and write InfluxDB data.",
      "Type": "String",
      "Default": "InfluxIOIncludedT1",
      "AllowedValues": [
        "InfluxIOIncludedT1",
        "InfluxIOIncludedT2",
        "InfluxIOIncludedT3"
      ]
    },
    "PubliclyAccessible": {
      "Description": "Configures the DB instance with a public IP to facilitate access.",
      "Type": "String",
      "Default": true,
      "AllowedValues": [
        true,
        false
      ]
    }
  },
  "Conditions": {
    "IsMultiAZ": {
      "Fn::Equals": [
        {"Ref": "DeploymentType"},
        "WITH_MULTIAZ_STANDBY"
      ]
    },
    "IsPublic": {
      "Fn::Equals": [
        {"Ref": "PubliclyAccessible"},
        true
      ]
    }
  },
  "Resources": {
    "VPC": {
      "Type": "AWS::EC2::VPC",
      "Properties": {
        "CidrBlock": {"Ref": "VPCCIDR"}
      }
    },
    "InternetGateway": {
      "Type": "AWS::EC2::InternetGateway",
      "Condition": "IsPublic"
    },
    "InternetGatewayAttachment": {
      "Type": "AWS::EC2::VPCGatewayAttachment",
      "Condition": "IsPublic",
      "Properties": {
        "InternetGatewayId": {"Ref": "InternetGateway"},
        "VpcId": {"Ref": "VPC"}
      }
    },
    "Subnet1": {
      "Type": "AWS::EC2::Subnet",
      "Properties": {
        "VpcId": {"Ref": "VPC"},
        "AvailabilityZone": {
          "Fn::Select": [
            0,
            {"Fn::GetAZs": ""}
          ]
        },
        "CidrBlock": {
          "Fn::Select": [
            0,
            {
              "Fn::Cidr": [
                {
                  "Fn::GetAtt": [
                    "VPC",
                    "CidrBlock"
                  ]
                },
                2,
                12
              ]
            }
          ]
        },
        "MapPublicIpOnLaunch": {
          "Fn::If": [
            "IsPublic",
            true,
            false
          ]
        }
      }
    },
    "Subnet2": {
      "Type": "AWS::EC2::Subnet",
      "Condition": "IsMultiAZ",
      "Properties": {
        "VpcId": {"Ref": "VPC"},
        "AvailabilityZone": {
          "Fn::Select": [
            1,
            {"Fn::GetAZs": ""}
          ]
        },
        "CidrBlock": {
          "Fn::Select": [
            1,
            {
              "Fn::Cidr": [
                {
                  "Fn::GetAtt": [
                    "VPC",
                    "CidrBlock"
                  ]
                },
                2,
                12
              ]
            }
          ]
        },
        "MapPublicIpOnLaunch": {
          "Fn::If": [
            "IsPublic",
            true,
            false
          ]
        }
      }
    },
    "RouteTable": {
      "Type": "AWS::EC2::RouteTable",
      "Properties": {
        "VpcId": {"Ref": "VPC"}
      }
    },
    "DefaultRoute": {
      "Type": "AWS::EC2::Route",
      "Condition": "IsPublic",
      "DependsOn": "InternetGatewayAttachment",
      "Properties": {
        "RouteTableId": {"Ref": "RouteTable"},
        "DestinationCidrBlock": "0.0.0.0/0",
        "GatewayId": {"Ref": "InternetGateway"}
      }
    },
    "Subnet1RouteTableAssociation": {
      "Type": "AWS::EC2::SubnetRouteTableAssociation",
      "Properties": {
        "RouteTableId": {"Ref": "RouteTable"},
        "SubnetId": {"Ref": "Subnet1"}
      }
    },
    "Subnet2RouteTableAssociation": {
      "Type": "AWS::EC2::SubnetRouteTableAssociation",
      "Condition": "IsMultiAZ",
      "Properties": {
        "RouteTableId": {"Ref": "RouteTable"},
        "SubnetId": {"Ref": "Subnet2"}
      }
    },
    "InfluxDBSecurityGroup": {
      "Type": "AWS::EC2::SecurityGroup",
      "Properties": {
        "GroupName": "influxdb-sg",
        "GroupDescription": "Security group allowing port 8086 ingress for InfluxDB",
        "VpcId": {"Ref": "VPC"}
      }
    },
    "InfluxDBSecurityGroupIngress": {
      "Type": "AWS::EC2::SecurityGroupIngress",
      "Properties": {
        "GroupId": {"Ref": "InfluxDBSecurityGroup"},
        "IpProtocol": "tcp",
        "CidrIp": "0.0.0.0/0",
        "FromPort": 8086,
        "ToPort": 8086
      }
    },
    "InfluxDBLogsS3Bucket": {
      "Type": "AWS::S3::Bucket",
      "DeletionPolicy": "Retain"
    },
    "InfluxDBLogsS3BucketPolicy": {
      "Type": "AWS::S3::BucketPolicy",
      "Properties": {
        "Bucket": {"Ref": "InfluxDBLogsS3Bucket"},
        "PolicyDocument": {
          "Version": "2012-10-17",		 	 	 
          "Statement": [
            {
              "Action": "s3:PutObject",
              "Effect": "Allow",
              "Resource": {"Fn::Sub": "arn:aws:s3:::${InfluxDBLogsS3Bucket}/InfluxLogs/*"},
              "Principal": {"Service": "timestream-influxdb.amazonaws.com"}
            },
            {
              "Action": "s3:*",
              "Effect": "Deny",
              "Resource": [
                {"Fn::Sub": "arn:aws:s3:::${InfluxDBLogsS3Bucket}/*"},
                {"Fn::Sub": "arn:aws:s3:::${InfluxDBLogsS3Bucket}"}
              ],
              "Principal": "*",
              "Condition": {
                "Bool": {"aws:SecureTransport": false}
              }
            }
          ]
        }
      }
    },
    "DbInstance": {
      "Type": "AWS::Timestream::InfluxDBInstance",
      "DependsOn": "InfluxDBLogsS3BucketPolicy",
      "Properties": {
        "DbStorageType": {"Ref": "DbStorageType"},
        "AllocatedStorage": {"Ref": "AllocatedStorage"},
        "DbInstanceType": {"Ref": "DbInstanceType"},
        "Name": {"Ref": "DbInstanceName"},
        "Username": {"Ref": "InfluxDBUsername"},
        "Password": {"Ref": "InfluxDBPassword"},
        "Organization": {"Ref": "InfluxDBOrganization"},
        "Bucket": {"Ref": "InfluxDBBucket"},
        "PubliclyAccessible": {
          "Fn::If": [
            "IsPublic",
            true,
            false
          ]
        },
        "DeploymentType": {"Ref": "DeploymentType"},
        "VpcSecurityGroupIds": [
          {"Ref": "InfluxDBSecurityGroup"}
        ],
        "VpcSubnetIds": {
          "Fn::If": [
            "IsMultiAZ",
            [
              {"Ref": "Subnet1"},
              {"Ref": "Subnet2"}
            ],
            [
              {"Ref": "Subnet1"}
            ]
          ]
        },
        "LogDeliveryConfiguration": {
          "S3Configuration": {
            "BucketName": {"Ref": "InfluxDBLogsS3Bucket"},
            "Enabled": true
          }
        }
      }
    }
  },
  "Outputs": {
    "VPC": {
      "Description": "A reference to the VPC used to create network resources",
      "Value": {"Ref": "VPC"}
    },
    "Subnets": {
      "Description": "A list of the subnets created",
      "Value": {
        "Fn::If": [
          "IsMultiAZ",
          {
            "Fn::Join": [
              ",",
              [
                {"Ref": "Subnet1"},
                {"Ref": "Subnet2"}
              ]
            ]
          },
          {"Ref": "Subnet1"}
        ]
      }
    },
    "Subnet1": {
      "Description": "A reference to the subnet in the 1st Availability Zone",
      "Value": {"Ref": "Subnet1"}
    },
    "Subnet2": {
      "Condition": "IsMultiAZ",
      "Description": "A reference to the subnet in the 2nd Availability Zone",
      "Value": {"Ref": "Subnet2"}
    },
    "InfluxDBSecurityGroup": {
      "Description": "Security group with port 8086 ingress rule",
      "Value": {"Ref": "InfluxDBSecurityGroup"}
    },
    "InfluxDBLogsS3Bucket": {
      "Description": "S3 Bucket containing InfluxDB logs from the DB instance",
      "Value": {"Ref": "InfluxDBLogsS3Bucket"}
    },
    "DbInstance": {
      "Description": "A reference to the Timestream for InfluxDB DB instance",
      "Value": {"Ref": "DbInstance"}
    },
    "InfluxAuthParametersSecretArn": {
      "Description": "The Amazon Resource Name (ARN) of the Gestione dei segreti AWS secret containing the initial InfluxDB authorization parameters. The secret value is a JSON formatted key-value pair holding InfluxDB authorization values: organization, bucket, username, and password.",
      "Value": {
        "Fn::GetAtt": [
          "DbInstance",
          "InfluxAuthParametersSecretArn"
        ]
      }
    },
    "Endpoint": {
      "Description": "The endpoint URL to connect to InfluxDB",
      "Value": {
        "Fn::Join": [
          "",
          [
            "https://",
            {
              "Fn::GetAtt": [
                "DbInstance",
                "Endpoint"
              ]
            },
            ":8086"
          ]
        ]
      }
    }
  }
}
```

### YAML
<a name="scenario-timestream-influxdb-example-2.yaml"></a>

```
Metadata: 
  AWS::CloudFormation::Interface:
    ParameterGroups:
      - 
        Label:
          default: "Network Configuration"
        Parameters:
          - VPCCIDR
      -
        Label:
          default: "Amazon Timestream for InfluxDB Configuration"
        Parameters:
          - DbInstanceName
          - InfluxDBUsername
          - InfluxDBPassword
          - InfluxDBOrganization
          - InfluxDBBucket
          - DbInstanceType
          - DbStorageType
          - AllocatedStorage
          - PubliclyAccessible
          - DeploymentType
    ParameterLabels:
      VPCCIDR:
        default: VPC CIDR

Parameters:
  # Network Configuration
  VPCCIDR:
    Description: Please enter the IP range (CIDR notation) for the new VPC
    Type: String
    Default: 10.0.0.0/16
  # Timestream for InfluxDB Configuration
  DbInstanceName:
    Description: The name that uniquely identifies the DB instance when interacting with the Amazon Timestream for InfluxDB API and CLI commands. This name will also be a prefix included in the endpoint. DB instance names must be unique per customer and per Region.
    Type: String
    Default: mydbinstance
    MinLength: 3
    MaxLength: 40    
    AllowedPattern: ^[a-zA-z][a-zA-Z0-9]*(-[a-zA-Z0-9]+)*$
  # InfluxDB initial user configurations
  InfluxDBUsername:
    Description: The username of the initial admin user created in InfluxDB. Must start with a letter and can't end with a hyphen or contain two consecutive hyphens. For example, my-user1. This username will allow you to access the InfluxDB UI to perform various administrative tasks and also use the InfluxDB CLI to create an operator token. These attributes will be stored in a Secret created in Gestione dei segreti AWS in your account.
    Type: String
    Default: admin
    MinLength: 1
    MaxLength: 64
  InfluxDBPassword:
    Description: The password of the initial admin user created in InfluxDB. This password will allow you to access the InfluxDB UI to perform various administrative tasks and also use the InfluxDB CLI to create an operator token. These attributes will be stored in a Secret created in AWS in your account.
    Type: String
    NoEcho: true
    MinLength: 8
    MaxLength: 64
    AllowedPattern: ^[a-zA-Z0-9]+$
  InfluxDBOrganization:
    Description: The name of the initial organization for the initial admin user in InfluxDB. An InfluxDB organization is a workspace for a group of users.
    Type: String
    Default: org
    MinLength: 1
    MaxLength: 64
  InfluxDBBucket:
    Description: The name of the initial InfluxDB bucket. All InfluxDB data is stored in a bucket. A bucket combines the concept of a database and a retention period (the duration of time that each data point persists). A bucket belongs to an organization.
    Type: String
    Default: bucket
    MinLength: 2
    MaxLength: 64
    AllowedPattern: ^[^_\"][^\"]*$
  DeploymentType:
    Description: Specifies whether the Timestream for InfluxDB is deployed as Single-AZ or with a MultiAZ Standby for High availability
    Type: String
    Default: WITH_MULTIAZ_STANDBY
    AllowedValues:
      - SINGLE_AZ
      - WITH_MULTIAZ_STANDBY
  AllocatedStorage:
    Description: The amount of storage to allocate for your DB storage type in GiB (gibibytes).
    Type: Number
    Default: 400
    MinValue: 20
    MaxValue: 16384
  DbInstanceType:
    Description: The Timestream for InfluxDB DB instance type to run InfluxDB on.
    Type: String
    Default: db.influx.medium
    AllowedValues:
      - db.influx.medium
      - db.influx.large
      - db.influx.xlarge
      - db.influx.2xlarge
      - db.influx.4xlarge
      - db.influx.8xlarge
      - db.influx.12xlarge
      - db.influx.16xlarge
  DbStorageType:
    Description: The Timestream for InfluxDB DB storage type to read and write InfluxDB data.
    Type: String
    Default: InfluxIOIncludedT1
    AllowedValues:
      - InfluxIOIncludedT1
      - InfluxIOIncludedT2
      - InfluxIOIncludedT3
  PubliclyAccessible:
    Description: Configures the DB instance with a public IP to facilitate access.
    Type: String
    Default: true
    AllowedValues:
      - true
      - false

Conditions:
  IsMultiAZ: !Equals [!Ref DeploymentType, WITH_MULTIAZ_STANDBY]
  IsPublic: !Equals [!Ref PubliclyAccessible, true]

Resources:
  VPC:
    Type: AWS::EC2::VPC
    Properties:
      CidrBlock: !Ref VPCCIDR
  InternetGateway:
    Type: AWS::EC2::InternetGateway
    Condition: IsPublic
  InternetGatewayAttachment:
    Type: AWS::EC2::VPCGatewayAttachment
    Condition: IsPublic
    Properties:
      InternetGatewayId: !Ref InternetGateway
      VpcId: !Ref VPC
  Subnet1:
    Type: AWS::EC2::Subnet
    Properties:
      VpcId: !Ref VPC
      AvailabilityZone: !Select [0, !GetAZs '']
      CidrBlock: !Select [0, !Cidr [!GetAtt VPC.CidrBlock, 2, 12 ]]
      MapPublicIpOnLaunch: !If [IsPublic, true, false]
  Subnet2:
    Type: AWS::EC2::Subnet
    Condition: IsMultiAZ
    Properties:
      VpcId: !Ref VPC
      AvailabilityZone: !Select [1, !GetAZs  '']
      CidrBlock: !Select [1, !Cidr [!GetAtt VPC.CidrBlock, 2, 12 ]]
      MapPublicIpOnLaunch: !If [IsPublic, true, false]
  RouteTable:
    Type: AWS::EC2::RouteTable
    Properties:
      VpcId: !Ref VPC
  DefaultRoute:
    Type: AWS::EC2::Route
    Condition: IsPublic
    DependsOn: InternetGatewayAttachment
    Properties:
      RouteTableId: !Ref RouteTable
      DestinationCidrBlock: 0.0.0.0/0
      GatewayId: !Ref InternetGateway
  Subnet1RouteTableAssociation:
    Type: AWS::EC2::SubnetRouteTableAssociation
    Properties:
      RouteTableId: !Ref RouteTable
      SubnetId: !Ref Subnet1
  Subnet2RouteTableAssociation:
    Type: AWS::EC2::SubnetRouteTableAssociation
    Condition: IsMultiAZ
    Properties:
      RouteTableId: !Ref RouteTable
      SubnetId: !Ref Subnet2
  InfluxDBSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupName: "influxdb-sg"
      GroupDescription: "Security group allowing port 8086 ingress for InfluxDB"
      VpcId: !Ref VPC
  InfluxDBSecurityGroupIngress:
    Type: AWS::EC2::SecurityGroupIngress
    Properties:
      GroupId: !Ref InfluxDBSecurityGroup
      IpProtocol: tcp
      CidrIp: 0.0.0.0/0
      FromPort: 8086
      ToPort: 8086
  InfluxDBLogsS3Bucket:
    Type: AWS::S3::Bucket
    DeletionPolicy: Retain
  InfluxDBLogsS3BucketPolicy:
    Type: AWS::S3::BucketPolicy
    Properties:
      Bucket: !Ref InfluxDBLogsS3Bucket
      PolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Action: "s3:PutObject"
            Effect: Allow
            Resource: !Sub arn:aws:s3:::${InfluxDBLogsS3Bucket}/InfluxLogs/*
            Principal:
              Service: timestream-influxdb.amazonaws.com
          - Action: "s3:*"
            Effect: Deny
            Resource:
              - !Sub arn:aws:s3:::${InfluxDBLogsS3Bucket}/*
              - !Sub arn:aws:s3:::${InfluxDBLogsS3Bucket}
            Principal: "*"
            Condition:
              Bool:
                aws:SecureTransport: false
  DbInstance:
    Type: AWS::Timestream::InfluxDBInstance
    DependsOn: InfluxDBLogsS3BucketPolicy
    Properties:
      DbStorageType: !Ref DbStorageType
      AllocatedStorage: !Ref AllocatedStorage
      DbInstanceType: !Ref DbInstanceType
      Name: !Ref DbInstanceName
      Username: !Ref InfluxDBUsername
      Password: !Ref InfluxDBPassword
      Organization: !Ref InfluxDBOrganization
      Bucket: !Ref InfluxDBBucket
      PubliclyAccessible: !If [IsPublic, true, false]
      DeploymentType: !Ref DeploymentType
      VpcSecurityGroupIds: 
        - !Ref InfluxDBSecurityGroup
      VpcSubnetIds: !If
        - IsMultiAZ
        -
          - !Ref Subnet1
          - !Ref Subnet2
        -
          - !Ref Subnet1
      LogDeliveryConfiguration:
        S3Configuration:
          BucketName: !Ref InfluxDBLogsS3Bucket
          Enabled: true

Outputs:
  # Network Resources
  VPC:
    Description: A reference to the VPC used to create network resources
    Value: !Ref VPC
  Subnets:
    Description: A list of the subnets created
    Value: !If
      - IsMultiAZ
      - !Join [",", [!Ref Subnet1, !Ref Subnet2]]
      - !Ref Subnet1
  Subnet1:
    Description: A reference to the subnet in the 1st Availability Zone
    Value: !Ref Subnet1
  Subnet2:
    Condition: IsMultiAZ
    Description: A reference to the subnet in the 2nd Availability Zone
    Value: !Ref Subnet2
  InfluxDBSecurityGroup:
    Description: Security group with port 8086 ingress rule
    Value: !Ref InfluxDBSecurityGroup

  # Timestream for InfluxDB Resources
  InfluxDBLogsS3Bucket:
    Description: S3 Bucket containing InfluxDB logs from the DB instance
    Value: !Ref InfluxDBLogsS3Bucket
  DbInstance:
    Description: A reference to the Timestream for InfluxDB DB instance
    Value: !Ref DbInstance
  InfluxAuthParametersSecretArn:
    Description: "The Amazon Resource Name (ARN) of the Gestione dei segreti AWS secret containing the initial InfluxDB authorization parameters. The secret value is a JSON formatted key-value pair holding InfluxDB authorization values: organization, bucket, username, and password."
    Value: !GetAtt DbInstance.InfluxAuthParametersSecretArn
  Endpoint:
    Description: The endpoint URL to connect to InfluxDB
    Value: !Join ["", ["https://", !GetAtt DbInstance.Endpoint, ":8086"]]
```

# WindowsImplementa stack basati su CloudFormation
<a name="cfn-windows-stacks"></a>

Questa pagina fornisce collegamenti alla documentazione tecnica di riferimento per CloudFormation le risorse comunemente utilizzate nelle distribuzioni Windows basate.

CloudFormation fornisce supporto per l'implementazione e la gestione Microsoft Windows degli stack tramite. Infrastructure as Code (IaC) Puoi utilizzarlo CloudFormation per il provisioning automatico di istanze EC2 Windows basate, su SQL Server Amazon RDS e tramite. Microsoft Active Directory Directory Service

AWS fornisce Amazon Machine Images (AMIs) preconfigurate specificamente per Windows le piattaforme per aiutarti a distribuire rapidamente applicazioni su Amazon EC2. Queste AMIs includono Microsoft impostazioni predefinite e AWS personalizzazioni specifiche. Con CloudFormation, puoi scegliere un'AMI appropriata, avviare un'istanza e accedervi tramite Remote Desktop Connection, proprio come faresti con qualsiasi altraWindows Server. AMIs Contiene componenti software essenziali, tra cui EC2Launch (le versioni variano in base all'Windows Serveredizione) e vari driver di rete, di archiviazione e grafici per garantire prestazioni e compatibilità ottimali con AWS i servizi. AWS Systems Manager CloudFormation AWS Strumenti per PowerShell Per ulteriori informazioni, consulta [AWS Windows AMI Reference](https://docs.aws.amazon.com/ec2/latest/windows-ami-reference/windows-amis.html).

CloudFormation supporta anche strumenti di configurazione software, come gli `UserData` script, che possono eseguire comandi PowerShell o batch al primo avvio di un'istanza EC2. Offre anche script helper (`cfn-init`, `cfn-signal`, `cfn-get-metadata` e `cfn-hup`) e supporta i metadati `AWS::CloudFormation::Init` per la gestione di pacchetti, file e servizi sulle istanze Windows.

Per gli ambienti aziendali, CloudFormation consente l'aggiunta di domini, la gestione delle Windows licenze tramite i modelli di licenza EC2 e la gestione sicura delle credenziali con. Gestione dei segreti AWS In combinazione con modelli con controllo della versione e implementazioni ripetibili, CloudFormation aiuta le organizzazioni a mantenere ambienti coerenti, sicuri e scalabili su più account. Windows Regioni AWS 

Per i dettagli sulle CloudFormation risorse comunemente utilizzate nelle distribuzioni Windows basate, consulta i seguenti argomenti di riferimento tecnico.


| Tipo di risorsa | Description | 
| --- | --- | 
|  [AWS::EC2::Instance](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-instance.html)  |  Per l’avvio di istanze EC2 Windows.  | 
|  [AWS::EC2::SecurityGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-securitygroup.html)  |  Per definire le regole del firewall per i carichi di lavoro Windows.  | 
|  [AWS::AutoScaling::AutoScalingGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html) (Gruppo) [AWS::EC2::LaunchTemplate](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ec2-launchtemplate.html)  |  Per scalare le istanze EC2 Windows.  | 
|  [AWS::DirectoryService::MicrosoftAD](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-directoryservice-microsoftad.html)  |  Per l’implementazione di Microsoft Active Directory.  | 
|  [AWS::FSx::FileSystem](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-fsx-filesystem.html)  |  Per la distribuzione FSx per Windows File Server.  | 
|  [AWS: :RDS:: DBInstance](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-rds-dbinstance.html)  |  Per il provisioning di SQL Server su Amazon RDS.  | 
|  [AWS::CloudFormation::Init](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-init.html)  |  Utilizzato all’interno dei metadati EC2 per la configurazione delle istanze.  Per ulteriori informazioni, consulta [Stack basati sul bootstrap Windows CloudFormation](cfn-windows-stacks-bootstrapping.md).  | 
|  [AWS::SecretsManager::Secret](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-secretsmanager-secret.html)  |  Per la gestione sicura di credenziali e password Windows.  | 
|  [AWS::SSM::Parameter](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-ssm-parameter.html)  |  Per archiviare i valori di configurazione in modo sicuro.  | 
|  [AWS::IAM::InstanceProfile](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-instanceprofile.html) [AWS::IAM::Role](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-role.html)  |  Per concedere autorizzazioni ad applicazioni in esecuzione su istanze EC2.  | 

# Stack basati sul bootstrap Windows CloudFormation
<a name="cfn-windows-stacks-bootstrapping"></a>

Questo argomento descrive come eseguire il bootstrap di uno stack di Windows e risolvere i problemi di creazione dello stack. 

**Topics**
+ [Dati utente nelle istanze EC2](#cfn-windows-bootstrapping-user-data)
+ [CloudFormation script di supporto](#cfn-windows-bootstrapping-helper-scripts)
+ [Esempio di processo di bootstrap di uno stack di Windows](#cfn-windows-bootstrapping-example)
+ [Evita le barre rovesciate nei percorsi dei file Windows](#cfn-windows-stacks-escape-backslashes)
+ [Gestione dei servizi Windows](#cfn-windows-stacks-manage-windows-services)
+ [Risoluzione dei problemi di creazione dello stack](#cfn-windows-stacks-troubleshooting)

## Dati utente nelle istanze EC2
<a name="cfn-windows-bootstrapping-user-data"></a>

I dati utente sono una funzionalità di Amazon EC2 che consente di trasmettere script o informazioni di configurazione a un’istanza EC2 al momento dell’avvio. 

Per le nuove istanze EC2 Windows:
+ È possibile utilizzare script batch (utilizzando i tag `<script>`) o script PowerShell (utilizzando i tag `<powershell>`).
+ L’esecuzione degli script è gestita da EC2Launch.

**Importante**  
Se stai creando la tua Windows AMI da utilizzare con CloudFormation, assicurati che la versione EC2Launch v2 sia configurata correttamente. EC2Launchv2 è necessaria per consentire agli strumenti di CloudFormation bootstrap di inizializzare e configurare Windows correttamente le istanze durante la creazione dello stack. Per ulteriori informazioni, consulta [Use the EC2Launch v2 agent to perform tasks during EC2 Windows instance launch](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2launch-v2.html) nella *Guida per l’utente Amazon EC2*.  
Per informazioni su AWS Windows AMIs, consulta l'[AWSWindowsAMI Reference](https://docs.aws.amazon.com/ec2/latest/windows-ami-reference/windows-amis.html).

## CloudFormation script di supporto
<a name="cfn-windows-bootstrapping-helper-scripts"></a>

Gli script di supporto sono utilità per configurare le istanze durante il processo di bootstrap. Utilizzati con i dati utente di Amazon EC2, forniscono potenti opzioni di configurazione.

CloudFormation fornisce i seguenti script di supporto in Python che puoi usare per installare software e avviare servizi su un'istanza Amazon EC2 che crei come parte del tuo stack:
+  `cfn-init`: utilizzalo per recuperare e interpretare i metadati delle risorse, installare pacchetti, creare file e avviare i servizi.
+  `cfn-signal`: utilizzalo per segnalare con un `CreationPolicy`, in modo da sincronizzare altre risorse nello stack quando la risorsa o l’applicazione del prerequisito è pronta.
+  `cfn-get-metadata`: utilizzalo per recuperare i metadati per una risorsa o un percorso di una chiave specifica.
+  `cfn-hup`: utilizzalo per verificare la presenza di aggiornamenti dei metadati ed eseguire gli hook personalizzati quando le modifiche vengono rilevate.

Puoi chiamare gli script direttamente dal tuo modello. Lo script funziona in combinazione con i metadati delle risorse definiti nello stesso modello. Gli script eseguiti sull’istanza Amazon EC2 durante il processo di creazione dello stack.

*Per ulteriori informazioni, consulta il riferimento agli [script di CloudFormation supporto nella Template Reference Guide](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/cfn-helper-scripts-reference.html).CloudFormation *

## Esempio di processo di bootstrap di uno stack di Windows
<a name="cfn-windows-bootstrapping-example"></a>

Esaminiamo alcuni frammenti di esempio tratti da un modello Windows Server che esegue le seguenti azioni:
+ Avvia un’istanza EC2 denominata `TestInstance` da un’AMI Windows Server 2022.
+ Crea un semplice file di test per verificare che `cfn-init` funzioni.
+ Configura `cfn-hup` per la gestione continua della configurazione.
+ Utilizza una `CreationPolicy` per garantire che l’istanza segnali il completamento con successo.

Lo script helper `cfn-init` viene utilizzato per eseguire ciascuna di tali azioni, in base alle informazioni nella risorsa `AWS::CloudFormation::Init` nel modello.

La sezione `AWS::CloudFormation::Init` è denominata `TestInstance` e inizia con la seguente dichiarazione.

```
TestInstance:
  Type: AWS::EC2::Instance
  Metadata:
    AWS::CloudFormation::Init:
      configSets:
        default:
          - create_files
          - start_services
```

Successivamente, viene dichiarata la sezione `files` di `AWS::CloudFormation::Init`.

```
      create_files:
        files:
          c:\cfn\test.txt:
            content: !Sub |
              Hello from ${AWS::StackName}
          c:\cfn\cfn-hup.conf:
            content: !Sub |
              [main]
              stack=${AWS::StackName}
              region=${AWS::Region}
              interval=2
          c:\cfn\hooks.d\cfn-auto-reloader.conf:
            content: !Sub |
              [cfn-auto-reloader-hook]
              triggers=post.update
              path=Resources.TestInstance.Metadata.AWS::CloudFormation::Init
              action=cfn-init.exe -v -s ${AWS::StackName} -r TestInstance -c default --region ${AWS::Region}
```

Qui vengono creati tre file e collocati nella directory `C:\cfn` sull’istanza del server:
+ `test.txt`, un semplice file di test che verifica il corretto funzionamento di `cfn-init` e consente di creare file con contenuto dinamico.
+ `cfn-hup.conf`, il file di configurazione per `cfn-hup` con un intervallo di controllo di 2 minuti.
+ `cfn-auto-reloader.conf`, il file di configurazione per l’hook utilizzato da `cfn-hup` per l’inizializzazione e l’aggiornamento (chiamando `cfn-init`) quando i metadati in `AWS::CloudFormation::Init` cambiano.

Quella successiva è la sezione `start_services` che configura i servizi Windows.

```
      start_services:
        services:
          windows:
            cfn-hup:
              enabled: true
              ensureRunning: true
              files:
                - c:\cfn\cfn-hup.conf
                - c:\cfn\hooks.d\cfn-auto-reloader.conf
```

Questa sezione garantisce l’avvio del servizio `cfn-hup` e si riavvierà automaticamente se i file di configurazione vengono modificati. Il servizio monitora le modifiche ai CloudFormation metadati e viene eseguito nuovamente `cfn-init` quando vengono rilevati aggiornamenti.

A seguire c’è la sezione `Properties`.

```
TestInstance:
  Type: AWS::EC2::Instance
  CreationPolicy:
    ResourceSignal:
      Timeout: PT20M
  Metadata:
    AWS::CloudFormation::Init:
      # ... metadata configuration ...
  Properties:
    InstanceType: t2.large
    ImageId: '{{resolve:ssm:/aws/service/ami-windows-latest/Windows_Server-2022-English-Full-Base}}'
    SecurityGroupIds:
      - !Ref InstanceSecurityGroup
    KeyName: !Ref KeyPairName
    UserData:
      Fn::Base64: !Sub |
        <powershell>
        cfn-init.exe -v -s ${AWS::StackName} -r TestInstance -c default --region ${AWS::Region}
        cfn-signal.exe -e $lastexitcode --stack ${AWS::StackName} --resource TestInstance --region ${AWS::Region}
        </powershell>
```

In questa sezione, la proprietà `UserData` contiene uno script PowerShell che verrà eseguito da EC2Launch, racchiuso tra tag `<powershell>`. Lo script viene eseguito `cfn-init` con `default` ConfigSet, quindi viene utilizzato `cfn-signal` per riportare il codice di uscita a. CloudFormation La `CreationPolicy` viene utilizzata per garantire che l’istanza sia configurata correttamente prima che la creazione dello stack sia considerata completa.

La proprietà `ImageId` utilizza un parametro pubblico di Systems Manager Parameter Store per recuperare automaticamente l’ID AMI 2022 di Windows Server più recente. Questo approccio elimina la necessità di mappature AMI specifiche per regione e garantisce di ottenere sempre l’AMI più recente. L'utilizzo dei parametri di Systems Manager per AMI IDs è una procedura consigliata per mantenere i riferimenti AMI correnti. Se intendi connetterti alla tua istanza, assicurati che la proprietà `SecurityGroupIds` faccia riferimento a un gruppo di sicurezza che consente l’accesso RDP.

La `CreationPolicy` viene dichiarata come parte delle proprietà della risorsa e specifica un periodo di timeout. Il comando `cfn-signal` nei dati utente segnala quando la configurazione dell’istanza è completa:

```
TestInstance:
  Type: AWS::EC2::Instance
  CreationPolicy:
    ResourceSignal:
      Timeout: PT20M
  Properties:
    # ... other properties ...
```

Poiché il processo di avvio è minimo e crea solo file e avvia i servizi, `CreationPolicy` attende 20 minuti (PT20M) prima del timeout. Il timeout viene specificato utilizzando il formato di durata ISO 8601. Tieni presente che, in genere, le istanze Windows richiedono più tempo per l’avvio rispetto alle istanze Linux, quindi esegui un test approfondito per determinare i valori di timeout più adatti alle tue esigenze.

Se va tutto bene, la `CreationPolicy` viene completata correttamente e puoi accedere all’istanza Windows Server utilizzando il suo indirizzo IP pubblico. Una volta completata la creazione dello stack, l'ID dell'istanza e l'indirizzo IP pubblico verranno visualizzati nella scheda **Output** della console. CloudFormation 

```
Outputs:
  InstanceId:
    Value: !Ref TestInstance
    Description: Instance ID of the Windows Server
  PublicIP:
    Value: !GetAtt TestInstance.PublicIp
    Description: Public IP address of the Windows Server
```

Puoi anche verificare manualmente che il bootstrap abbia funzionato correttamente connettendoti all’istanza tramite RDP e controllando che il file `C:\cfn\test.txt` esista e contenga il contenuto previsto. Per ulteriori informazioni sulla connessione a istanze Windows, consulta [Connect to your Windows instance using RDP](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connecting_to_windows_instance.html) nella *Guida per l’utente di Amazon EC2*.

## Evita le barre rovesciate nei percorsi dei file Windows
<a name="cfn-windows-stacks-escape-backslashes"></a>

Quando fai riferimento ai Windows percorsi nei CloudFormation modelli, ricorda sempre di evitare correttamente le barre rovesciate (`\`) in base al formato del modello che stai utilizzando.
+ Per i modelli JSON devi usare le doppie barre rovesciate nei percorsi dei file Windows perché JSON considera la barra rovesciata come un carattere di escape. La prima barra rovesciata sfugge alla seconda, dando come risultato l’interpretazione di una singola barra rovesciata letterale.

  ```
  "commands" : {
    "1-extract" : {
      "command" : "C:\\SharePoint\\SharePointFoundation2010.exe /extract:C:\\SharePoint\\SPF2010 /quiet /log:C:\\SharePoint\\SharePointFoundation2010-extract.log"
    }
  }
  ```
+ Per i modelli YAML, in genere sono sufficienti barre rovesciate singole.

  ```
  commands:
    1-extract:
      command: C:\SharePoint\SharePointFoundation2010.exe /extract:C:\SharePoint\SPF2010 /quiet /log:C:\SharePoint\SharePointFoundation2010-extract.log
  ```

## Gestione dei servizi Windows
<a name="cfn-windows-stacks-manage-windows-services"></a>

I servizi Windows vengono gestiti come servizi Linux, ma si utilizza una chiave `windows` anziché `sysvinit`. Nell’esempio seguente viene avviato il servizio `cfn-hup`, impostato su Automatico, e viene riavviato il servizio se `cfn-init` modifica i file di configurazione `c:\cfn\cfn-hup.conf` o `c:\cfn\hooks.d\cfn-auto-reloader.conf`.

```
        services:
          windows:
            cfn-hup:
              enabled: true
              ensureRunning: true
              files:
                - c:\cfn\cfn-hup.conf
                - c:\cfn\hooks.d\cfn-auto-reloader.conf
```

È possibile gestire altri servizi Windows nello stesso modo utilizzando il nome, non il nome visualizzato, per fare riferimento al servizio.

## Risoluzione dei problemi di creazione dello stack
<a name="cfn-windows-stacks-troubleshooting"></a>

Se si verifica un errore durante la creazione dello stack, il comportamento predefinito è il rollback in caso di errore. Sebbene sia in genere una buona impostazione predefinita perché evita costi non necessari, rende difficile il debug del motivo dell’errore di creazione dello stack.

**Per disattivare questo comportamento durante la creazione o l'aggiornamento dello stack con la CloudFormation console, scegli l'opzione **Preserva risorse con successo in Opzioni di errore** dello stack.** Per ulteriori informazioni, consulta [Scegli in che modo gestire gli errori durante il provisioning delle risorse](stack-failure-options.md). Questo consente di accedere all’istanza e visualizzare i file di log per individuare problemi rilevati durante l’esecuzione degli script di avvio.

Log importanti da guadare sono:
+ Il log di configurazione EC2 in `%ProgramData%\Amazon\EC2Launch\log\agent.log`
+ Il log **cfn-init** su `C:\cfn\log\cfn-init.log` (controlla i codici di uscita e i messaggi di errore per punti di errore specifici)

Per ulteriori log, consulta gli argomenti seguenti nella *Guida per l’utente di Amazon EC2*:
+ [EC2Launchstruttura delle cartelle](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2config-service.html#UsingConfigXML_WinAMI)
+ [Struttura di directory di EC2Launch v2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2launch-v2.html#ec2launch-v2-directory)

Per ulteriori informazioni sulla risoluzione dei problemi di bootstrap, vedi [Come posso risolvere gli script di supporto che non si avviano in uno stack](https://repost.aws/knowledge-center/cloudformation-helper-scripts-windows) con istanze? CloudFormation Windows .

# Estendi le funzionalità del tuo modello con i CloudFormation tipi di risorse forniti
<a name="cloudformation-supplied-resource-types"></a>

CloudFormation offre diversi tipi di risorse che puoi utilizzare nel tuo modello di stack per estenderne le funzionalità oltre a quelle di un semplice modello di stack.

Questi tipi di risorse includono:


| Tipo di risorsa | Description | Documentazione | 
| --- | --- | --- | 
|  Risorse personalizzate  |  Il tipo di `AWS::CloudFormation::CustomResource` risorsa consente di creare risorse personalizzate in grado di eseguire attività di approvvigionamento specifiche o includere risorse che non sono disponibili come CloudFormation tipi di risorse.  |  [Risorse personalizzate](template-custom-resources.md) | 
|  Macro  |  Il tipo di `AWS::CloudFormation::Macro` risorsa definisce una parte di codice riutilizzabile in grado di eseguire elaborazioni personalizzate sui CloudFormation modelli. Le macro possono modificare i modelli, generare risorse aggiuntive o eseguire altre operazioni personalizzate durante la creazione o gli aggiornamenti degli stack.  | [Macro di modello](template-macros.md) | 
|  Stack nidificati  |  Il tipo di `AWS::CloudFormation::Stack` risorsa consente di creare pile annidate all'interno dei CloudFormation modelli per architetture di stack più modulari e riutilizzabili.  | [Stack nidificati](using-cfn-nested-stacks.md) | 
|  StackSet  |  Il tipo di `AWS::CloudFormation::StackSet` risorsa crea o aggiorna a CloudFormation StackSet, che è un contenitore per stack che può essere distribuito su più regioni. Account AWS   | [Gestione degli stack con StackSets](what-is-cfnstacksets.md) | 
|  Condizione di attesa  |  Il tipo di risorsa `AWS::CloudFormation::WaitCondition` sospende la creazione o l’aggiornamento dello stack finché non viene soddisfatta una condizione specifica, ad esempio il completamento con successo di un processo di lunga durata o la disponibilità di risorse esterne.   | [Condizioni di attesa](using-cfn-waitcondition.md) | 
|  Handle della condizione di attesa  |  Il tipo di risorsa `AWS::CloudFormation::WaitConditionHandle` funziona con il tipo di risorsa `AWS::CloudFormation::WaitCondition`. Fornisce un URL predefinito utilizzato per inviare segnali che indicano che è stata soddisfatta una condizione specifica. Questi segnali consentono di procedere con la creazione o l’aggiornamento dello stack.  | [Condizioni di attesa](using-cfn-waitcondition.md) | 

# Creare una logica di provisioning personalizzata con risorse personalizzate
<a name="template-custom-resources"></a>

Le risorse personalizzate consentono di scrivere una logica di provisioning personalizzata nei CloudFormation modelli e di CloudFormation eseguirla ogni volta che si crea, si aggiorna (se si modifica la risorsa personalizzata) o si elimina uno stack. Ciò può essere utile quando i requisiti di provisioning coinvolgono logiche o flussi di lavoro complessi che non possono essere espressi con CloudFormation i tipi di risorse integrati.

Ad esempio, potresti voler includere risorse che non sono disponibili come tipi di CloudFormation risorse. Puoi includere tali risorse utilizzando le risorse personalizzate. In questo modo, puoi comunque gestire tutte le risorse correlate in un singolo stack.

Per definire una risorsa personalizzata nel CloudFormation modello, si utilizza il tipo di `Custom::MyCustomResourceTypeName` risorsa `AWS::CloudFormation::CustomResource` or. Le risorse personalizzate richiedono una proprietà, il token di servizio, che specifica a dove vengono CloudFormation inviate le richieste, ad esempio un argomento Amazon SNS o una funzione Lambda.

I seguenti argomenti forniscono informazioni su come utilizzare le risorse personalizzate.

**Topics**
+ [Funzionamento delle risorse personalizzate](#how-custom-resources-work)
+ [Timeout di risposta](#response-timeout)
+ [CloudFormation riferimento personalizzato alla richiesta e alla risposta delle risorse](crpg-ref.md)
+ [Risorse personalizzate supportate da Amazon SNS](template-custom-resources-sns.md)
+ [Risorse personalizzate supportate da Lambda](template-custom-resources-lambda.md)

**Nota**  
Il CloudFormation registro e le risorse personalizzate offrono ciascuno i propri vantaggi. Le risorse personalizzate offrono i seguenti vantaggi:  
Non devi registrare la risorsa.
Puoi includere un’intera risorsa come parte di un modello senza registrazione.
Supportano le operazioni `Create`, `Update` e `Delete`.
Di seguito sono elencati alcuni vantaggi delle risorse basate sul registro:  
Supporta la modellazione, il provisioning e la gestione di risorse applicative di terze parti
Supporta le operazioni `Create``Read``Update`, `Delete` e `List` (`CRUDL`)
Supporta il rilevamento della deriva su tipi di risorse private e di terze parti
A differenza delle risorse personalizzate, le risorse basate sul Registro di sistema non dovranno associare un argomento Amazon SNS o una funzione Lambda per eseguire operazioni `CRUDL`. Per ulteriori informazioni, consulta [Gestione delle estensioni con il CloudFormation registro](registry.md).

## Funzionamento delle risorse personalizzate
<a name="how-custom-resources-work"></a>

Il processo generale di configurazione di una nuova risorsa prevede i passaggi descritti di seguito. In questi passaggi sono coinvolti due ruoli: il *provider di risorse personalizzate*, proprietario della risorsa personalizzata, e lo *sviluppatore del modello*, che crea un modello contenente un tipo di risorsa personalizzata. Questi ruoli possono essere svolti dalla stessa persona; in caso contrario, il provider di risorse personalizzate deve lavorare con lo sviluppatore del modello.

1. Il provider di risorse personalizzate scrive la logica che determina come gestire le richieste CloudFormation e come eseguire azioni sulla risorsa personalizzata. 

1. Il provider di risorse personalizzato crea l'argomento Amazon SNS o la funzione Lambda a cui CloudFormation inviare richieste. L’argomento Amazon SNS o la funzione Lambda devono trovarsi nella stessa Regione in cui sarà creato lo stack.

1. Il provider di risorse personalizzate comunica l’ARN dell’argomento Amazon SNS o della funzione Lambda allo sviluppatore del modello.

1. Lo sviluppatore del modello definisce la risorsa personalizzata nel proprio CloudFormation modello. tramite un token di servizio ed eventuali parametri dei dati di input. Il token di servizio e la struttura dei dati di input sono definiti dal provider di risorse personalizzate. Il token di servizio specifica l’ARN dell’argomento Amazon SNS o della funzione Lambda ed è sempre obbligatorio, ma i dati di input sono facoltativi e dipendono dalla risorsa personalizzata.

Ora, ogni volta che qualcuno utilizza il modello per creare, aggiornare o eliminare la risorsa personalizzata, CloudFormation invia una richiesta al token di servizio specificato e quindi attende una risposta prima di procedere con l'operazione stack. 

I seguenti passaggi riassumono il flusso di creazione di uno stack dal modello: 

1. CloudFormation invia una richiesta al token di servizio specificato. La richiesta include informazioni come il tipo di richiesta e un URL del bucket Amazon S3 prefirmato, a cui la risorsa personalizzata invia le risposte. Per ulteriori informazioni sugli elementi inclusi nella richiesta, consulta [CloudFormation riferimento personalizzato alla richiesta e alla risposta delle risorse](crpg-ref.md).

   I seguenti dati di esempio mostrano cosa CloudFormation include una richiesta. `Create` In questo esempio, `ResourceProperties` consente di CloudFormation creare un payload personalizzato da inviare alla funzione Lambda.

   ```
   {
      "RequestType" : "Create",
      "RequestId" : "unique id for this create request",
      "StackId" : "arn:aws:cloudformation:us-west-2:123456789012:stack/mystack/5b918d10-cd98-11ea-90d5-0a9cd3354c10",
      "ResponseURL" : "http://pre-signed-S3-url-for-response",
      "ResourceType" : "Custom::TestResource",
      "LogicalResourceId" : "MyTestResource",
      "ResourceProperties" : {
         "Name" : "Value",
         "List" : [ "1", "2", "3" ]
      }
   }
   ```

1. Il provider di risorse personalizzato elabora la CloudFormation richiesta e restituisce una risposta `SUCCESS` o `FAILED` all'URL prefirmato. custom resource provider fornisce la risposta in un file in formato JSON e lo carica sull'URL S3 prefirmato. Per ulteriori informazioni, consulta [Uploading objects with presigned URLs](https://docs.aws.amazon.com/AmazonS3/latest/userguide/PresignedUrlUploadObject.html) nella *Amazon Simple Storage Service User Guide*.

   Nella risposta, custom resource provider può anche includere coppie nome-valore a cui template developer può accedere. Ad esempio, la risposta può includere i dati di output nel caso in cui la richiesta sia andata a buon fine o un messaggio di errore nel caso in cui la richiesta abbia avuto esito negativo. Per ulteriori informazioni sulle risposte, consulta [CloudFormation riferimento personalizzato alla richiesta e alla risposta delle risorse](crpg-ref.md).
**Importante**  
Se le coppie nome-valore contengono informazioni riservate, è necessario utilizzare il campo `NoEcho` per mascherare l'output della risorsa personalizzata. Altrimenti, i valori sono visibili attraverso i valori delle proprietà di APIs quella superficie (ad esempio`DescribeStackEvents`).  
Per ulteriori informazioni sull’utilizzo di `NoEcho` per mascherare le informazioni sensibili, consulta la best practice [Non incorporare le credenziali nei modelli](security-best-practices.md#creds).

   custom resource provider è responsabile dell'ascolto e della risposta alla richiesta. Ad esempio, per le notifiche di Amazon SNS, il provider di risorse personalizzate deve ascoltare e rispondere alle notifiche inviate a un argomento ARN specifico. CloudFormation attende e ascolta una risposta nella posizione URL prefirmata.

   I seguenti dati di esempio mostrano ciò che una risorsa personalizzata può includere in una risposta:

   ```
   {
      "Status" : "SUCCESS",
      "RequestId" : "unique id for this create request",
      "StackId" : "arn:aws:cloudformation:us-west-2:123456789012:stack/mystack/5b918d10-cd98-11ea-90d5-0a9cd3354c10",
      "LogicalResourceId" : "MyTestResource",
      "PhysicalResourceId" : "TestResource1",
      "Data" : {
         "OutputName1" : "Value1",
         "OutputName2" : "Value2",
      }
   }
   ```

1. Dopo aver ricevuto una `SUCCESS` risposta, CloudFormation procede con l'operazione stack. Se viene restituita una risposta `FAILED` o nessuna risposta, l'operazione ha esito negativo. Qualsiasi dato di output dalla risorsa personalizzata viene memorizzato nella posizione dell'URL prefirmato. Lo sviluppatore del modello può recuperare tali dati utilizzando la funzione [Fn](resources-section-structure.md#resource-properties-getatt)::. GetAtt

**Nota**  
Se lo utilizzi AWS PrivateLink, le risorse personalizzate nel VPC devono avere accesso a bucket S3 CloudFormation specifici. Le risorse personalizzate devono inviare le risposte a un Amazon S3 preregistrato. Se non possono inviare risposte ad Amazon S3, CloudFormation non riceveranno alcuna risposta e l'operazione di stack avrà esito negativo. Per ulteriori informazioni, consulta [Accesso CloudFormation tramite un endpoint di interfaccia ()AWS PrivateLink](vpc-interface-endpoints.md).

## Timeout di risposta
<a name="response-timeout"></a>

Il timeout predefinito per la risorsa personalizzata è pari a 3.600 secondi (1 ora). Se durante questo periodo non viene ricevuta alcuna risposta, l’operazione di stack ha esito negativo.

Puoi modificare il valore di timeout in base a quanto tempo prevedi sarà necessario per la risposta dalla risorsa personalizzata. Per esempio, quando esegui il provisioning di una risorsa personalizzata che invoca una funzione Lambda con un tempo di risposta previsto di cinque minuti, puoi impostare un timeout di cinque minuti nel modello di stack specificando la proprietà `ServiceTimeout`. Per ulteriori informazioni, consulta [CloudFormation riferimento personalizzato alla richiesta e alla risposta delle risorse](crpg-ref.md). In questo modo, se c'è un errore nella funzione Lambda che ne causa il blocco, l'operazione stack CloudFormation fallirà dopo cinque minuti invece di attendere l'intera ora. 

Tuttavia, fai attenzione a non impostare un valore di timeout troppo basso. Per evitare timeout imprevisti, assicurati che la risorsa personalizzata disponga di tempo sufficiente per eseguire le operazioni necessarie e restituire una risposta.

# CloudFormation riferimento personalizzato alla richiesta e alla risposta delle risorse
<a name="crpg-ref"></a>

CloudFormation gestisce le risorse personalizzate tramite un protocollo di richiesta-risposta che comunica con il fornitore di risorse personalizzato. Ogni richiesta include un tipo di richiesta (`Create``Update`, o`Delete`) e segue questo flusso di lavoro di alto livello:

1. Uno sviluppatore di modelli definisce una risorsa personalizzata con un `ServiceToken` e `ServiceTimeout` nel modello e avvia un'operazione di stack.

1. CloudFormation invia una richiesta JSON al provider di risorse personalizzato tramite SNS o Lambda.

1. Il provider di risorse personalizzato elabora la richiesta e restituisce una risposta JSON a un URL del bucket Amazon S3 predefinito prima della scadenza del periodo di timeout.

1. CloudFormation legge la risposta e procede con l'operazione stack. Se non viene ricevuta alcuna risposta prima della fine del periodo di timeout, la richiesta viene considerata non riuscita e l'operazione di stack ha esito negativo.

Per ulteriori informazioni, consulta [Funzionamento delle risorse personalizzate](template-custom-resources.md#how-custom-resources-work).

Questa sezione descrive la struttura, i parametri e le risposte previste per ogni tipo di richiesta.

**Nota**  
La dimensione totale del corpo della risposta non può superare 4096 byte.

## Configurazione del modello
<a name="crpg-ref-template-setup"></a>

Quando definisce una risorsa personalizzata in un modello, lo sviluppatore del modello utilizza [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-customresource.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-customresource.html)le seguenti proprietà:

`ServiceToken`  
ARN dell'argomento Amazon SNS o ARN della funzione Lambda della stessa regione dello stack.  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`ServiceTimeout`  
Il tempo massimo, in secondi, prima del timeout di un'operazione su una risorsa personalizzata. Deve essere un valore compreso tra 1 e 3600. Impostazione predefinita: 3600 secondi (1 ora).  
*Required*: No  
▬*Tipo:* stringa

Sono supportate proprietà aggiuntive delle risorse. Le proprietà delle risorse verranno incluse come `ResourceProperties` nella richiesta. Il fornitore di risorse personalizzate deve determinare quali proprietà sono valide e i relativi valori accettabili.

## Oggetto Request
<a name="crpg-ref-requesttypes"></a>

------
#### [ Create ]

Quando lo sviluppatore del modello crea uno stack contenente una risorsa personalizzata, CloudFormation invia una richiesta con `RequestType` set to`Create`.

Le richieste di creazione contengono i seguenti campi:

`RequestType`  
`Create`.  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`RequestId`  
Un ID univoco per la richiesta.  
La combinazione di `StackId` con `RequestId` costituisce un valore che puoi utilizzare per identificare in modo univoco una richiesta in una particolare risorsa personalizzata.  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`StackId`  
Il nome della risorsa Amazon (ARN) che identifica lo stack che contiene la risorsa personalizzata.  
La combinazione di `StackId` con `RequestId` costituisce un valore che puoi utilizzare per identificare in modo univoco una richiesta in una particolare risorsa personalizzata.  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`ResponseURL`  
L'URL di risposta identifica un bucket S3 predefinito che riceve risposte dal fornitore di risorse personalizzato a. CloudFormation  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`ResourceType`  
Il tipo di risorsa scelta dallo sviluppatore del modello della risorsa personalizzata nel modello CloudFormation . I nomi dei tipi di risorsa personalizzata possono contenere fino a 60 caratteri e possono includere caratteri alfanumerici, oltre ai caratteri seguenti: `_@-`.  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`LogicalResourceId`  
Il nome (ID logico) scelto dallo sviluppatore del modello della risorsa personalizzata nel modello CloudFormation .  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`ResourceProperties`  
Questo campo contiene il contenuto dell’oggetto `Properties` inviato dallo sviluppatore del modello. I suoi contenuti vengono definiti dal provider di risorse personalizzate.  
*Obbligatorio:* no  
*Tipo*: JSON object

*Esempio*

```
{
   "RequestType" : "Create",
   "RequestId" : "unique-request-id",
   "StackId" : "arn:aws:cloudformation:us-west-2:123456789012:stack/mystack/id",
   "ResponseURL" : "pre-signed-url-for-create-response",
   "ResourceType" : "Custom::MyCustomResourceType",
   "LogicalResourceId" : "resource-logical-id",
   "ResourceProperties" : {
      "key1" : "string",
      "key2" : [ "list" ],
      "key3" : { "key4" : "map" }
   }
}
```

------
#### [ Update ]

Quando lo sviluppatore del modello apporta modifiche alle proprietà di una risorsa personalizzata all'interno del modello e aggiorna lo stack, CloudFormation invia una richiesta al fornitore di risorse personalizzate con set to. `RequestType` `Update` Questo significa che il codice della risorsa personalizzata non deve rilevare le modifiche nelle risorse perché sa che le proprietà sono state modificate quando il tipo di richiesta è `Update`.

Le richieste di aggiornamento contengono i seguenti campi:

`RequestType`  
`Update`.  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`RequestId`  
Un ID univoco per la richiesta.  
La combinazione di `StackId` con `RequestId` costituisce un valore che puoi utilizzare per identificare in modo univoco una richiesta in una particolare risorsa personalizzata.  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`StackId`  
Il nome della risorsa Amazon (ARN) che identifica lo stack che contiene la risorsa personalizzata.  
La combinazione di `StackId` con `RequestId` costituisce un valore che puoi utilizzare per identificare in modo univoco una richiesta in una particolare risorsa personalizzata.  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`ResponseURL`  
L'URL di risposta identifica un bucket S3 predefinito che riceve risposte dal provider di risorse personalizzato a. CloudFormation  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`ResourceType`  
Il tipo di risorsa scelta dallo sviluppatore del modello della risorsa personalizzata nel modello CloudFormation . I nomi dei tipi di risorsa personalizzata possono contenere fino a 60 caratteri e possono includere caratteri alfanumerici, oltre ai caratteri seguenti: `_@-`. Non puoi modificare il tipo durante un aggiornamento.  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`LogicalResourceId`  
Il nome (ID logico) scelto dallo sviluppatore del modello della risorsa personalizzata nel modello CloudFormation .  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`PhysicalResourceId`  
Un ID fisico personalizzato definito dal provider di risorse che è unico per quel provider.  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`ResourceProperties`  
Questo campo contiene il contenuto dell’oggetto `Properties` inviato dallo sviluppatore del modello. I suoi contenuti vengono definiti dal provider di risorse personalizzate.  
*Obbligatorio:* no  
*Tipo*: JSON object

`OldResourceProperties`  
Usato solo per le richieste `Update`. I valori della proprietà della risorsa dichiarati precedentemente dal template developer nel modello CloudFormation .  
*Obbligatorio:* sì  
*Tipo*: JSON object

*Esempio*

```
{
   "RequestType" : "Update",
   "RequestId" : "unique-request-id",
   "StackId" : "arn:aws:cloudformation:us-west-2:123456789012:stack/mystack/id",
   "ResponseURL" : "pre-signed-url-for-update-response",
   "ResourceType" : "Custom::MyCustomResourceType",
   "LogicalResourceId" : "resource-logical-id",
   "PhysicalResourceId" : "provider-defined-physical-id",
   "ResourceProperties" : {
      "key1" : "new-string",
      "key2" : [ "new-list" ],
      "key3" : { "key4" : "new-map" }
   },
   "OldResourceProperties" : {
      "key1" : "string",
      "key2" : [ "list" ],
      "key3" : { "key4" : "map" }
   }
}
```

------
#### [ Delete ]

Quando lo sviluppatore del modello elimina lo stack o rimuove la risorsa personalizzata dal modello e quindi aggiorna lo stack, CloudFormation invia una richiesta con set to. `RequestType` `Delete`

Le richieste di eliminazione contengono i seguenti campi:

`RequestType`  
`Delete`.  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`RequestId`  
Un ID univoco per la richiesta.  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`StackId`  
Il nome della risorsa Amazon (ARN) che identifica lo stack che contiene la risorsa personalizzata.  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`ResponseURL`  
L'URL di risposta identifica un bucket S3 predefinito che riceve risposte dal provider di risorse personalizzato a. CloudFormation  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`ResourceType`  
Il tipo di risorsa scelta dallo sviluppatore del modello della risorsa personalizzata nel modello CloudFormation . I nomi dei tipi di risorsa personalizzata possono contenere fino a 60 caratteri e possono includere caratteri alfanumerici, oltre ai caratteri seguenti: `_@-`.  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`LogicalResourceId`  
Il nome (ID logico) scelto dallo sviluppatore del modello della risorsa personalizzata nel modello CloudFormation .  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`PhysicalResourceId`  
Un ID fisico personalizzato definito dal provider di risorse che è unico per quel provider.  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`ResourceProperties`  
Questo campo contiene il contenuto dell’oggetto `Properties` inviato dallo sviluppatore del modello. I suoi contenuti vengono definiti dal provider di risorse personalizzate.  
*Obbligatorio:* no  
*Tipo*: JSON object

*Esempio*

```
{
   "RequestType" : "Delete",
   "RequestId" : "unique-request-id",
   "StackId" : "arn:aws:cloudformation:us-west-2:123456789012:stack/mystack/id",
   "ResponseURL" : "pre-signed-url-for-delete-response",
   "ResourceType" : "Custom::MyCustomResourceType",
   "LogicalResourceId" : "resource-logical-id",
   "PhysicalResourceId" : "provider-defined-physical-id",
   "ResourceProperties" : {
      "key1" : "string",
      "key2" : [ "list" ],
      "key3" : { "key4" : "map" }
   }
}
```

------

## Oggetto Response
<a name="crpg-ref-responses"></a>

Il provider di risorse personalizzato invia una risposta all'URL prefirmato per tutti i tipi di richiesta. Se il provider di risorse personalizzato non invia una risposta, CloudFormation attende il timeout dell'operazione.

La risposta deve essere un oggetto JSON con i seguenti campi:

`Status`  
Deve essere `SUCCESS` o `FAILED`.  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`RequestId`  
Un ID univoco per la richiesta. Copia questo valore esattamente come appare nella richiesta.  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`StackId`  
Il nome della risorsa Amazon (ARN) che identifica lo stack che contiene la risorsa personalizzata. Copia questo valore esattamente come appare nella richiesta.  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`LogicalResourceId`  
Il nome (ID logico) scelto dallo sviluppatore del modello della risorsa personalizzata nel modello CloudFormation . Copia questo valore esattamente come appare nella richiesta.  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`PhysicalResourceId`  
Questo valore deve essere un identificativo univoco per il fornitore di risorse personalizzate e può avere una dimensione massima di 1 KB. Il valore deve essere una stringa non vuota e deve essere identico per tutte le risposte per la stessa risorsa.  
Quando si aggiornano risorse personalizzate, il valore restituito per `PhysicalResourceId` determina il comportamento di aggiornamento. Se il valore rimane lo stesso, lo CloudFormation considera un aggiornamento normale. Se il valore cambia, CloudFormation interpreta l'aggiornamento come sostitutivo e invia una richiesta di eliminazione alla vecchia risorsa. Per ulteriori informazioni, consulta [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-customresource.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-customresource.html).  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`Reason`  
Descrive il motivo di una risposta con esito negativo.  
Necessario se `Status` è `FAILED`. Altrimenti, è facoltativo.  
*Required*: Conditional  
▬*Tipo:* stringa

`NoEcho`  
Indica se nascondere o meno l’output della risorsa personalizzata quando viene recuperata utilizzando la funzione `Fn::GetAtt`. Se impostato su `true`, tutti i valori restituiti vengono nascosti con degli asterischi (\$1\$1\$1\$1\$1), *ad eccezione di quelli archiviati nella sezione del modello `Metadata`*. CloudFormation non trasforma, modifica o omette le informazioni incluse nella sezione `Metadata`. Il valore predefinito è `false`.  
Per ulteriori informazioni sull’utilizzo di `NoEcho` per mascherare le informazioni sensibili, consulta la best practice [Non incorporare le credenziali nei modelli](security-best-practices.md#creds).  
Disponibile solo per `Update` risposte `Create` e risposte. Non è supportata per `Delete` le risposte.  
*Obbligatorio:* no  
*Tipo*: Booleano

`Data`  
Le coppie nome-valore definite dal provider di risorse personalizzate da inviare con la risposta. Puoi accedere ai valori forniti qui in base al nome nel modello con `Fn::GetAtt`.  
Disponibile solo per `Update` risposte `Create` e risposte. Non è supportata per `Delete` le risposte.  
Se le coppie nome-valore contengono informazioni riservate, è necessario utilizzare il campo `NoEcho` per mascherare l’output della risorsa personalizzata. Altrimenti, i valori sono visibili attraverso i valori delle proprietà di APIs quella superficie (ad esempio`DescribeStackEvents`).
*Obbligatorio:* no  
*Tipo*: JSON object

### Esempi di risposte di successo
<a name="crpg-ref-success-response-examples"></a>

#### `Create`e `Update` risposta
<a name="crpg-ref-success-response-example-1"></a>

```
{
   "Status": "SUCCESS",
   "RequestId": "unique-request-id",
   "StackId": "arn:aws:cloudformation:us-west-2:123456789012:stack/name/id",
   "LogicalResourceId": "resource-logical-id", 
   "PhysicalResourceId": "provider-defined-physical-id",
   "NoEcho": true,
   "Data": {
      "key1": "value1",
      "key2": "value2"
   }
}
```

#### Risposta `Delete`
<a name="crpg-ref-success-response-example-2"></a>

```
{
   "Status": "SUCCESS",
   "RequestId": "unique-request-id",
   "StackId": "arn:aws:cloudformation:us-west-2:123456789012:stack/name/id",
   "LogicalResourceId": "resource-logical-id", 
   "PhysicalResourceId": "provider-defined-physical-id"
}
```

### Esempio di risposta fallita
<a name="crpg-ref-failed-response-example"></a>

```
{
   "Status": "FAILED",
   "RequestId": "unique-request-id",
   "StackId": "arn:aws:cloudformation:us-west-2:123456789012:stack/name/id",
   "LogicalResourceId": "resource-logical-id",
   "PhysicalResourceId": "provider-defined-physical-id",
   "Reason": "Required failure reason string"
}
```

# Risorse personalizzate supportate da Amazon SNS
<a name="template-custom-resources-sns"></a>

L'argomento seguente mostra come configurare una risorsa personalizzata con un token di servizio che specifica l'argomento Amazon SNS a CloudFormation cui inviare le richieste. Troverai anche informazioni sulla sequenza di eventi e messaggi inviati e ricevuti come conseguenza della creazione, dell’aggiornamento e dell’eliminazione di uno stack di risorse personalizzato.

Con le risorse personalizzate e Amazon SNS, puoi abilitare scenari quali l'aggiunta di nuove risorse a uno stack e l'inserimento di dati dinamici in uno stack. Ad esempio, quando crei uno stack, CloudFormation puoi inviare una `Create` richiesta a un argomento monitorato da un'applicazione in esecuzione su un'istanza Amazon EC2. La notifica Amazon SNS abilita le attività di provisioning aggiuntive nell'applicazione, come il recupero di un pool di indirizzi IP elastici consentiti. Al termine, l'applicazione invia una risposta (e tutti i dati di output) che notifica di CloudFormation procedere con l'operazione dello stack.

Quando specifichi un argomento Amazon SNS come destinazione di una risorsa personalizzata, CloudFormation invia messaggi all'argomento SNS specificato durante le operazioni di stack che coinvolgono la risorsa personalizzata. Per elaborare questi messaggi ed eseguire le operazioni necessarie, devi disporre di un endpoint supportato sottoscritto all’argomento SNS.

Per un’introduzione alle risorse personalizzate e al loro funzionamento, consulta [Funzionamento delle risorse personalizzate](template-custom-resources.md#how-custom-resources-work). Per ulteriori informazioni su Amazon SNS e su come funziona, consulta [Amazon Simple Notification Service Developer Guide](https://docs.aws.amazon.com/sns/latest/dg/).

## Utilizzo di Amazon SNS per creare risorse personalizzate
<a name="walkthrough-custom-resources-sns-adding-nonaws-resource"></a>

**Topics**
+ [Fase 1: creazione dello stack](#crpg-walkthrough-stack-creation)
+ [Fase 2: aggiornamenti degli stack](#crpg-walkthrough-stack-updates)
+ [Fase 3: eliminazione dello stack](#crpg-walkthrough-stack-deletion)

### Fase 1: creazione dello stack
<a name="crpg-walkthrough-stack-creation"></a>

1. <a name="crpg-walkthrough-stack-creation-customer-template"></a>Lo sviluppatore del modello crea uno CloudFormation stack che contiene una risorsa personalizzata. 

   Nell’esempio di modello riportato di seguito, viene utilizzato il nome `Custom::SeleniumTester` del tipo di risorsa personalizzato per la risorsa personalizzata con ID logico `MySeleniumTest`. I nomi dei tipi di risorse personalizzati devono essere alfanumerici e possono avere una lunghezza massima di 60 caratteri. 

   Il tipo di risorsa personalizzato viene dichiarato con un token di servizio, proprietà opzionali specifiche del provider e GetAtt attributi facoltativi [Fn::](resources-section-structure.md#resource-properties-getatt) definiti dal provider di risorse personalizzato. Queste proprietà e questi attributi possono essere utilizzati per trasmettere le informazioni da template developer a custom resource provider e viceversa. Il token di servizio specifica un argomento di Amazon SNS configurato dal provider di risorse.

   ```
   {
      "AWSTemplateFormatVersion" : "2010-09-09",
      "Resources" : {
         "MySeleniumTest" : {
            "Type": "Custom::SeleniumTester",
            "Version" : "1.0",
            "Properties" : {
               "ServiceToken": "arn:aws:sns:us-west-2:123456789012:CRTest",
               "seleniumTester" : "SeleniumTest()",
               "endpoints" : [ "http://mysite.com", "http://myecommercesite.com/", "http://search.mysite.com" ],
               "frequencyOfTestsPerHour" : [ "3", "2", "4" ]
            }
         }
      },
      "Outputs" : {
         "topItem" : {
            "Value" : { "Fn::GetAtt" : ["MySeleniumTest", "resultsPage"] }
         },
         "numRespondents" : {
            "Value" : { "Fn::GetAtt" : ["MySeleniumTest", "lastUpdate"] }
         }
      }
   }
   ```
**Nota**  
I nomi e i valori dei dati a cui si accede con `Fn::GetAtt` vengono restituiti dal provider di risorse personalizzate durante la risposta del provider a. CloudFormation Se custom resource provider è una terza parte, template developer deve ottenere i nomi dei valori restituiti da custom resource provider.

1. <a name="crpg-walkthrough-stack-creation-provider-request"></a>CloudFormation invia una notifica Amazon SNS al provider di risorse con una `"RequestType" : "Create"` che contiene informazioni sullo stack, le proprietà personalizzate delle risorse dal modello di stack e un URL S3 per la risposta.

   L'argomento SNS che viene utilizzato per inviare la notifica è compreso nel modello della proprietà `ServiceToken`. Per evitare l'utilizzo di un valore hardcoded, un template developer può utilizzare un parametro del modello in modo che il valore venga inserito all'avvio dello stack.

   Nel seguente esempio viene mostrata una richiesta `Create` della risorsa personalizzata contenente un nome di tipo risorsa personalizzato, `Custom::SeleniumTester`, creata con `LogicalResourceId` di `MySeleniumTester`:

   ```
   {
      "RequestType" : "Create",
      "RequestId" : "unique-request-id",
      "StackId" : "arn:aws:cloudformation:us-west-2:123456789012:stack/mystack/5b918d10-cd98-11ea-90d5-0a9cd3354c10",
      "ResponseURL" : "http://pre-signed-S3-url-for-response",
      "ResourceType" : "Custom::SeleniumTester",
      "LogicalResourceId" : "MySeleniumTester",
      "ResourceProperties" : {
         "seleniumTester" : "SeleniumTest()",
         "endpoints" : [ "http://mysite.com", "http://myecommercesite.com/", "http://search.mysite.com" ],
         "frequencyOfTestsPerHour" : [ "3", "2", "4" ]
      }
   }
   ```

   Per informazioni dettagliate sull’oggetto di richiesta per le richieste `Create`, consulta l’argomento [Riferimento alla richiesta e alla risposta](crpg-ref.md).

1. <a name="crpg-walkthrough-stack-creation-provider-response"></a>Il custom resource provider elabora i dati inviati dallo template developer e determina se la richiesta `Create` è andata a buon fine. Il provider di risorse utilizza quindi l'URL S3 inviato da CloudFormation per inviare una risposta di o. `SUCCESS` `FAILED`

   A seconda del tipo di risposta, possono essere visualizzati diversi campi in CloudFormation. Per informazioni sui campi di risposta per un particolare tipo di richiesta, consulta la documentazione relativa a quel tipo di richiesta nella sezione [Riferimento alla richiesta e alla risposta](crpg-ref.md).

   In risposta a una richiesta di creazione o aggiornamento, il provider di risorse personalizzate può restituire elementi di dati nel campo `Data` della risposta. Queste sono coppie nome/valore e i *nomi* corrispondono agli attributi `Fn::GetAtt` utilizzati con la risorsa personalizzata nel modello di stack. I *valori* sono i dati che vengono restituiti quando il template developer chiama `Fn::GetAtt` nella risorsa con il nome attributo.

   Di seguito è riportato un esempio di risposta della risorsa personalizzata:

   ```
   {
      "Status" : "SUCCESS",
      "RequestId" : "unique-request-id",
      "StackId" : "arn:aws:cloudformation:us-west-2:123456789012:stack/mystack/5b918d10-cd98-11ea-90d5-0a9cd3354c10",
      "LogicalResourceId" : "MySeleniumTester",
      "PhysicalResourceId" : "Tester1",
      "Data" : {
         "resultsPage" : "http://www.myexampledomain/test-results/guid",
         "lastUpdate" : "2012-11-14T03:30Z"
      }
   }
   ```

   Per informazioni dettagliate sull’oggetto della risposta per le richieste `Create`, consulta l’argomento [Riferimento alla richiesta e alla risposta](crpg-ref.md).

   Nei campi `StackId`, `RequestId` e `LogicalResourceId` il testo della richiesta deve essere copiato parola per parola.

1. <a name="crpg-walkthrough-stack-creation-stack-status"></a> CloudFormation dichiara lo stato dello stack come o. `CREATE_COMPLETE` `CREATE_FAILED` Se lo stack è stato creato con successo, lo sviluppatore del modello può utilizzare i valori di output della risorsa personalizzata creata accedendovi con [Fn](resources-section-structure.md#resource-properties-getatt)::. GetAtt

   Ad esempio, il modello di risorsa personalizzata utilizzato per illustrazione usa `Fn::GetAtt` per copiare gli output delle risorse nell'output dello stack:

   ```
   "Outputs" : {
      "topItem" : {
         "Value" : { "Fn::GetAtt" : ["MySeleniumTest", "resultsPage"] }
      },
      "numRespondents" : {
         "Value" : { "Fn::GetAtt" : ["MySeleniumTest", "lastUpdate"] }
      }
   }
   ```

### Fase 2: aggiornamenti degli stack
<a name="crpg-walkthrough-stack-updates"></a>

Per aggiornare uno stack esistente, devi inviare un modello che specifichi gli aggiornamenti per le proprietà delle risorse dello stack, come illustrato nell'esempio seguente. CloudFormation aggiorna solo le risorse che hanno modifiche specificate nel modello. Per ulteriori informazioni, consulta [Comprendere l’aggiornamento dei comportamenti delle risorse stack](using-cfn-updating-stacks-update-behaviors.md).

Puoi aggiornare le risorse personalizzate che richiedono una sostituzione della risorsa fisica sottostante. Quando aggiorni una risorsa personalizzata in un CloudFormation modello, CloudFormation invia una richiesta di aggiornamento a quella risorsa personalizzata. Se una risorsa personalizzata richiede una sostituzione, la nuova risorsa personalizzata deve inviare una risposta con il nuovo ID fisico. Quando CloudFormation riceve la risposta, confronta il valore di `PhysicalResourceId` della vecchia e della nuova risorsa personalizzata. Se sono diversi, CloudFormation riconosce l'aggiornamento come sostitutivo e invia una richiesta di eliminazione alla vecchia risorsa, come mostrato in[Fase 3: eliminazione dello stack](#crpg-walkthrough-stack-deletion).

**Nota**  
Se non hai apportato modifiche alla risorsa personalizzata, CloudFormation non le invierà richieste durante un aggiornamento dello stack.

1. <a name="crpg-walkthrough-stack-updates-customer-template"></a>Il template developer avvia un aggiornamento dello stack contenente una risorsa personalizzata. Durante l'esecuzione di un aggiornamento, lo template developer può specificare nuove proprietà nel modello di stack.

   Di seguito è disponibile un esempio di `Update` del modello di stack tramite un tipo di risorsa personalizzata:

   ```
   {
      "AWSTemplateFormatVersion" : "2010-09-09",
      "Resources" : {
         "MySeleniumTest" : {
            "Type": "Custom::SeleniumTester",
            "Version" : "1.0",
            "Properties" : {
               "ServiceToken": "arn:aws:sns:us-west-2:123456789012:CRTest",
               "seleniumTester" : "SeleniumTest()",
               "endpoints" : [ "http://mysite.com", "http://myecommercesite.com/", "http://search.mysite.com",
                  "http://mynewsite.com" ],
               "frequencyOfTestsPerHour" : [ "3", "2", "4", "3" ]
            }
         }
      },
      "Outputs" : {
         "topItem" : {
            "Value" : { "Fn::GetAtt" : ["MySeleniumTest", "resultsPage"] }
         },
         "numRespondents" : {
            "Value" : { "Fn::GetAtt" : ["MySeleniumTest", "lastUpdate"] }
         }
      }
   }
   ```

1. <a name="crpg-walkthrough-stack-updates-provider-request"></a>CloudFormation invia una notifica Amazon SNS al provider di risorse con una `"RequestType" : "Update"` che contiene informazioni simili alla `Create` chiamata, tranne per il fatto che il `OldResourceProperties` campo contiene le vecchie proprietà della risorsa e ResourceProperties contiene le proprietà delle risorse aggiornate (se presenti).

   Di seguito è riportato un esempio di richiesta `Update`:

   ```
   {
      "RequestType" : "Update",
      "RequestId" : "unique-request-id",
      "StackId" : "arn:aws:cloudformation:us-west-2:123456789012:stack/mystack/5b918d10-cd98-11ea-90d5-0a9cd3354c10",
      "ResponseURL" : "http://pre-signed-S3-url-for-response",
      "ResourceType" : "Custom::SeleniumTester",
      "LogicalResourceId" : "MySeleniumTester",
      "PhysicalResourceId" : "Tester1",
      "ResourceProperties" : {
         "seleniumTester" : "SeleniumTest()",
         "endpoints" : [ "http://mysite.com", "http://myecommercesite.com/", "http://search.mysite.com",
            "http://mynewsite.com" ],
         "frequencyOfTestsPerHour" : [ "3", "2", "4", "3" ]
      },
      "OldResourceProperties" : {
         "seleniumTester" : "SeleniumTest()",
         "endpoints" : [ "http://mysite.com", "http://myecommercesite.com/", "http://search.mysite.com" ],
         "frequencyOfTestsPerHour" : [ "3", "2", "4" ]
      }
   }
   ```

   Per informazioni dettagliate sull’oggetto di richiesta per le richieste `Update`, consulta l’argomento [Riferimento alla richiesta e alla risposta](crpg-ref.md).

1. <a name="crpg-walkthrough-stack-updates-provider-response"></a>Il provider di risorse personalizzate elabora i dati inviati da CloudFormation. La risorsa personalizzata esegue l'aggiornamento e invia una risposta `SUCCESS` o `FAILED` all'URL S3. CloudFormation quindi confronta le `PhysicalResourceIDs` vecchie e nuove risorse personalizzate. Se sono diverse, CloudFormation riconosce che l'aggiornamento richiede una sostituzione e invia una richiesta di eliminazione alla vecchia risorsa. L'esempio seguente mostra la risposta di un custom resource provider a una richiesta `Update`.

   ```
   {
      "Status" : "SUCCESS",
      "RequestId" : "unique-request-id",
      "StackId" : "arn:aws:cloudformation:us-west-2:123456789012:stack/mystack/5b918d10-cd98-11ea-90d5-0a9cd3354c10",
      "LogicalResourceId" : "MySeleniumTester",
      "PhysicalResourceId" : "Tester2"
   }
   ```

   Per informazioni dettagliate sull’oggetto della risposta per le richieste `Update`, consulta l’argomento [Riferimento alla richiesta e alla risposta](crpg-ref.md).

   Nei campi `StackId`, `RequestId` e `LogicalResourceId` il testo della richiesta deve essere copiato parola per parola.

1. <a name="crpg-walkthrough-stack-updates-stack-status"></a>CloudFormation dichiara lo stato dello stack come o. `UPDATE_COMPLETE` `UPDATE_FAILED` Se l'aggiornamento ha esito negativo, viene eseguito il rollback dello stack. Se lo stack è stato aggiornato senza errori, il template developer può accedere ai nuovi valori di output delle risorse personalizzate create con `Fn::GetAtt`.

### Fase 3: eliminazione dello stack
<a name="crpg-walkthrough-stack-deletion"></a>

1. <a name="crpg-walkthrough-stack-deletion-customer-template"></a>Il template developer elimina un aggiornamento dello stack contenente una risorsa personalizzata. CloudFormation ottiene le proprietà attuali specificate nel modello dello stack insieme all'argomento SNS e si prepara per effettuare una richiesta al provider di risorse personalizzate.

1. <a name="crpg-walkthrough-stack-deletion-provider-request"></a>CloudFormation invia una notifica Amazon SNS al provider di risorse con una `"RequestType" : "Delete"` che contiene informazioni correnti sullo stack, le proprietà personalizzate delle risorse dal modello di stack e un URL S3 per la risposta.

   Ogni volta che elimini uno stack o effettui un aggiornamento che rimuove o sostituisce la risorsa personalizzata, CloudFormation confronta le risorse personalizzate vecchie e nuove`PhysicalResourceId`. Se sono diverse, CloudFormation riconosce l'aggiornamento come sostituto e invia una richiesta di eliminazione per la vecchia risorsa (`OldPhysicalResource`), come illustrato nell'esempio seguente di richiesta. `Delete`

   ```
   {
      "RequestType" : "Delete",
      "RequestId" : "unique-request-id",
      "StackId" : "arn:aws:cloudformation:us-west-2:123456789012:stack/mystack/5b918d10-cd98-11ea-90d5-0a9cd3354c10",
      "ResponseURL" : "http://pre-signed-S3-url-for-response",
      "ResourceType" : "Custom::SeleniumTester",
      "LogicalResourceId" : "MySeleniumTester",
      "PhysicalResourceId" : "Tester1",
      "ResourceProperties" : {
         "seleniumTester" : "SeleniumTest()",
         "endpoints" : [ "http://mysite.com", "http://myecommercesite.com/", "http://search.mysite.com",
            "http://mynewsite.com" ],
         "frequencyOfTestsPerHour" : [ "3", "2", "4", "3" ]
      }
   }
   ```

   Per informazioni dettagliate sull’oggetto di richiesta per le richieste `Delete`, consulta l’argomento [Riferimento alla richiesta e alla risposta](crpg-ref.md).

   `DescribeStackResource`, `DescribeStackResources`e `ListStackResources` mostrano il nome definito dall'utente se è stato specificato.

1. <a name="crpg-walkthrough-stack-deletion-provider-response"></a>Il provider di risorse personalizzate elabora i dati inviati da CloudFormation e determina se la `Delete` richiesta ha avuto esito positivo. Il provider di risorse utilizza quindi l'URL S3 inviato da CloudFormation per inviare una risposta di uno `SUCCESS` o`FAILED`. Per eliminare uno stack con una risorsa personalizzata, il custom resource provider deve rispondere a una richiesta di eliminazione.

   Nel seguente esempio viene mostrata la risposta di un custom resource provider a una richiesta `Delete`:

   ```
   {
      "Status" : "SUCCESS",
      "RequestId" : "unique-request-id",
      "StackId" : "arn:aws:cloudformation:us-west-2:123456789012:stack/mystack/5b918d10-cd98-11ea-90d5-0a9cd3354c10",
      "LogicalResourceId" : "MySeleniumTester",
      "PhysicalResourceId" : "Tester1"
   }
   ```

   Per informazioni dettagliate sull’oggetto della risposta per le richieste `Delete`, consulta l’argomento [Riferimento alla richiesta e alla risposta](crpg-ref.md).

   Nei campi `StackId`, `RequestId` e `LogicalResourceId` il testo della richiesta deve essere copiato parola per parola.

1. <a name="crpg-walkthrough-stack-updates-stack-status-delete"></a>CloudFormation dichiara lo stato dello stack come o. `DELETE_COMPLETE` `DELETE_FAILED`

# Risorse personalizzate supportate da Lambda
<a name="template-custom-resources-lambda"></a>

Quando associ una funzione Lambda a una risorsa personalizzata, la funzione viene richiamata ogni volta che la risorsa personalizzata viene creata, aggiornata o eliminata. CloudFormation chiama un'API Lambda per richiamare la funzione e per trasmettere tutti i dati della richiesta (ad esempio il tipo di richiesta e le proprietà delle risorse) alla funzione. La potenza e la personalizzazione delle funzioni Lambda, combinate con, CloudFormation consentono un'ampia gamma di scenari, come la ricerca dinamica delle IDs AMI durante la creazione dello stack o l'implementazione e l'utilizzo di funzioni di utilità, come le funzioni di inversione delle stringhe.

Per un’introduzione alle risorse personalizzate e al loro funzionamento, consulta [Funzionamento delle risorse personalizzate](template-custom-resources.md#how-custom-resources-work).

**Topics**
+ [Procedura guidata: crea un meccanismo di ritardo con una risorsa personalizzata supportata da Lambda](walkthrough-lambda-backed-custom-resources.md)
+ [Modulo `cfn-response`](cfn-lambda-function-code-cfnresponsemodule.md)

# Procedura guidata: crea un meccanismo di ritardo con una risorsa personalizzata supportata da Lambda
<a name="walkthrough-lambda-backed-custom-resources"></a>

Questa procedura dettagliata mostra come configurare e avviare una risorsa personalizzata supportata da Lambda utilizzando un modello di esempio. CloudFormation Questo modello crea un meccanismo di ritardo che sospende le implementazioni di stack per un tempo specificato. Questa operazione può essere utile quando devi introdurre ritardi intenzionali durante il provisioning delle risorse, ad esempio quando aspetti che le risorse si stabilizzino prima di creare risorse dipendenti.

**Nota**  
Sebbene in precedenza le risorse personalizzate supportate da Lambda fossero consigliate per il recupero dell'AMI IDs, ora consigliamo di utilizzare i parametri. AWS Systems Manager Questo approccio rende i modelli più riutilizzabili e più facili da mantenere. Per ulteriori informazioni, consulta [Ottenimento di un valore in testo normale da Systems Manager Parameter Store](dynamic-references-ssm.md). 

**Topics**
+ [Panoramica di](#walkthrough-lambda-backed-custom-resources-overview)
+ [Modello di esempio](#walkthrough-lambda-backed-custom-resources-sample-template)
+ [Procedura guidata per il modello di esempio](#walkthrough-lambda-backed-custom-resources-sample-template-walkthrough)
+ [Prerequisiti](#walkthrough-lambda-backed-custom-resources-prerequisites)
+ [Avviare lo stack](#walkthrough-lambda-backed-custom-resources-createfunction-createstack)
+ [Pulizia delle risorse](#walkthrough-lambda-backed-custom-resources-createfunction-cleanup)
+ [Informazioni correlate](#w2aac11c45b9c24b9c23)

## Panoramica di
<a name="walkthrough-lambda-backed-custom-resources-overview"></a>

Il modello di stack di esempio utilizzato in questa procedura guidata crea una risorsa personalizzata supportata da Lambda che introduce un ritardo configurabile (60 secondi per impostazione predefinita) durante la creazione dello stack. Il ritardo si verifica durante gli aggiornamenti dello stack solo quando vengono modificate le proprietà della risorsa personalizzata.

Il modello esegue il provisioning delle seguenti risorse:
+ Una risorsa personalizzata.
+ Una funzione Lambda.
+ un ruolo IAM che consente a Lambda di scrivere i log. CloudWatch

Definisce inoltre due output:
+ Il tempo effettivo di attesa della funzione.
+ Un identificativo univoco generato durante ogni esecuzione della funzione Lambda.



**Nota**  
CloudFormation è un servizio gratuito, ma Lambda addebita in base al numero di richieste per le funzioni e al tempo di esecuzione del codice. Per ulteriori informazioni sui prezzi di Lambda, consulta la pagina [Prezzi di AWS Lambda](https://aws.amazon.com/lambda/pricing/).

## Modello di esempio
<a name="walkthrough-lambda-backed-custom-resources-sample-template"></a>

Puoi consultare di seguito il modello di esempio della risorsa personalizzata supportata da Lambda con il meccanismo di ritardo:

### JSON
<a name="walkthrough-lambda-backed-custom-resources-sample-template-json"></a>

```
{
  "AWSTemplateFormatVersion": "2010-09-09",
  "Resources": {
    "LambdaExecutionRole": {
      "Type": "AWS::IAM::Role",
      "Properties": {
        "AssumeRolePolicyDocument": {
          "Statement": [{
            "Effect": "Allow",
            "Principal": { "Service": ["lambda.amazonaws.com"] },
            "Action": ["sts:AssumeRole"]
          }]
        },
        "Path": "/",
        "Policies": [{
          "PolicyName": "AllowLogs",
          "PolicyDocument": {
            "Statement": [{
              "Effect": "Allow",
              "Action": ["logs:*"],
              "Resource": "*"
            }]
          }
        }]
      }
    },
    "CFNWaiter": {
      "Type": "AWS::Lambda::Function",
      "Properties": {
        "Handler": "index.handler",
        "Runtime": "python3.9",
        "Timeout": 900,
        "Role": { "Fn::GetAtt": ["LambdaExecutionRole", "Arn"] },
        "Code": {
          "ZipFile": { "Fn::Join": ["\n", [
            "from time import sleep",
            "import json",
            "import cfnresponse",
            "import uuid",
            "",
            "def handler(event, context):",
            "  wait_seconds = 0",
            "  id = str(uuid.uuid1())",
            "  if event[\"RequestType\"] in [\"Create\", \"Update\"]:",
            "    wait_seconds = int(event[\"ResourceProperties\"].get(\"ServiceTimeout\", 0))",
            "    sleep(wait_seconds)",
            "  response = {",
            "    \"TimeWaited\": wait_seconds,",
            "    \"Id\": id ",
            "  }",
            "  cfnresponse.send(event, context, cfnresponse.SUCCESS, response, \"Waiter-\"+id)"
          ]]}
        }
      }
    },
    "CFNWaiterCustomResource": {
      "Type": "AWS::CloudFormation::CustomResource",
      "Properties": {
        "ServiceToken": { "Fn::GetAtt": ["CFNWaiter", "Arn"] },
        "ServiceTimeout": 60
      }
    }
  },
  "Outputs": {
    "TimeWaited": {
      "Value": { "Fn::GetAtt": ["CFNWaiterCustomResource", "TimeWaited"] },
      "Export": { "Name": "TimeWaited" }
    },
    "WaiterId": {
      "Value": { "Fn::GetAtt": ["CFNWaiterCustomResource", "Id"] },
      "Export": { "Name": "WaiterId" }
    }
  }
}
```

### YAML
<a name="walkthrough-lambda-backed-custom-resources-sample-template-yaml"></a>

```
AWSTemplateFormatVersion: "2010-09-09"
Resources:
  LambdaExecutionRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Statement:
          - Effect: "Allow"
            Principal:
              Service:
                - "lambda.amazonaws.com"
            Action:
              - "sts:AssumeRole"
      Path: "/"
      Policies:
        - PolicyName: "AllowLogs"
          PolicyDocument:
            Statement:
              - Effect: "Allow"
                Action:
                  - "logs:*"
                Resource: "*"
  CFNWaiter:
    Type: AWS::Lambda::Function
    Properties:
      Handler: index.handler
      Runtime: python3.9 
      Timeout: 900
      Role: !GetAtt LambdaExecutionRole.Arn
      Code:
        ZipFile:
          !Sub |
          from time import sleep
          import json
          import cfnresponse
          import uuid
​
          def handler(event, context):
            wait_seconds = 0
            id = str(uuid.uuid1())
            if event["RequestType"] in ["Create", "Update"]:
              wait_seconds = int(event["ResourceProperties"].get("ServiceTimeout", 0))
              sleep(wait_seconds)
            response = {
              "TimeWaited": wait_seconds,
              "Id": id 
            }
            cfnresponse.send(event, context, cfnresponse.SUCCESS, response, "Waiter-"+id)
  CFNWaiterCustomResource:
    Type: AWS::CloudFormation::CustomResource
    Properties:
      ServiceToken: !GetAtt CFNWaiter.Arn
      ServiceTimeout: 60
Outputs:
  TimeWaited:
    Value: !GetAtt CFNWaiterCustomResource.TimeWaited
    Export:
      Name: TimeWaited
  WaiterId:
    Value: !GetAtt CFNWaiterCustomResource.Id
    Export:
      Name: WaiterId
```

## Procedura guidata per il modello di esempio
<a name="walkthrough-lambda-backed-custom-resources-sample-template-walkthrough"></a>

I seguenti frammenti spiegano le parti rilevanti del modello di esempio per aiutarti a comprendere come la funzione Lambda viene associata a una risorsa personalizzata e il relativo output.

[AWS::Lambda::Function](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-lambda-function.html)risorsa `CFNWaiter`  
La risorsa `AWS::Lambda::Function` specifica il codice sorgente, il nome del gestore, l’ambiente di runtime e il nome della risorsa Amazon (ARN) del ruolo di esecuzione della funzione.  
La proprietà `Handler` è impostata su `index.handler` poiché utilizza un codice sorgente Python. [Per ulteriori informazioni sugli identificatori dei gestori accettati quando si utilizzano codici sorgente di funzioni in linea, vedere Code. AWS::Lambda::Function ](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-lambda-function-code.html#cfn-lambda-function-code-zipfile)  
Il `Runtime` è specificato come `python3.9` poiché il file di origine è un codice Python.  
Il `Timeout` è impostato su 900 secondi.  
La proprietà `Role` utilizza la funzione `Fn::GetAtt` per ottenere l’ARN del ruolo di esecuzione `LambdaExecutionRole` dichiarato nella risorsa `AWS::IAM::Role` all’interno del modello.  
La proprietà `Code` definisce il codice di funzione in linea utilizzando una funzione Python. La funzione Python nel modello di esempio esegue le seguenti operazioni:  
+ Crea un ID univoco utilizzando l’UUID.
+ Verifica se la richiesta è di creazione o aggiornamento.
+ Entra in sospensione per il tempo specificato in `ServiceTimeout` durante le richieste `Create` o `Update`.
+ Restituisce il tempo di attesa e l’ID univoco.

### JSON
<a name="walkthrough-lambda-backed-custom-resources-sample-template-lambda-resource-json"></a>

```
...
    "CFNWaiter": {
      "Type": "AWS::Lambda::Function",
      "Properties": {
        "Handler": "index.handler",
        "Runtime": "python3.9",
        "Timeout": 900,
        "Role": { "Fn::GetAtt": ["LambdaExecutionRole", "Arn"] },
        "Code": {
          "ZipFile": { "Fn::Join": ["\n", [
            "from time import sleep",
            "import json",
            "import cfnresponse",
            "import uuid",
            "",
            "def handler(event, context):",
            "  wait_seconds = 0",
            "  id = str(uuid.uuid1())",
            "  if event[\"RequestType\"] in [\"Create\", \"Update\"]:",
            "    wait_seconds = int(event[\"ResourceProperties\"].get(\"ServiceTimeout\", 0))",
            "    sleep(wait_seconds)",
            "  response = {",
            "    \"TimeWaited\": wait_seconds,",
            "    \"Id\": id ",
            "  }",
            "  cfnresponse.send(event, context, cfnresponse.SUCCESS, response, \"Waiter-\"+id)"
          ]]}
        }
      }
    },
...
```

### YAML
<a name="walkthrough-lambda-backed-custom-resources-sample-template-lambda-resource-yaml"></a>

```
...
  CFNWaiter:
    Type: AWS::Lambda::Function
    Properties:
      Handler: index.handler
      Runtime: python3.9 
      Timeout: 900
      Role: !GetAtt LambdaExecutionRole.Arn
      Code:
        ZipFile:
          !Sub |
          from time import sleep
          import json
          import cfnresponse
          import uuid
​
          def handler(event, context):
            wait_seconds = 0
            id = str(uuid.uuid1())
            if event["RequestType"] in ["Create", "Update"]:
              wait_seconds = int(event["ResourceProperties"].get("ServiceTimeout", 0))
              sleep(wait_seconds)
            response = {
              "TimeWaited": wait_seconds,
              "Id": id 
            }
            cfnresponse.send(event, context, cfnresponse.SUCCESS, response, "Waiter-"+id)
...
```

[AWS::IAM::Role](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-iam-role.html)risorsa `LambdaExecutionRole`  
La risorsa `AWS::IAM:Role` crea un ruolo di esecuzione per la funzione Lambda, che include una policy di assunzione del ruolo che consente a Lambda di utilizzarlo. Contiene anche una politica che consente l'accesso ai CloudWatch registri.

### JSON
<a name="walkthrough-lambda-backed-custom-resources-sample-template-iam-role-json"></a>

```
...
    "LambdaExecutionRole": {
      "Type": "AWS::IAM::Role",
      "Properties": {
        "AssumeRolePolicyDocument": {
          "Statement": [{
            "Effect": "Allow",
            "Principal": { "Service": ["lambda.amazonaws.com"] },
            "Action": ["sts:AssumeRole"]
          }]
        },
        "Path": "/",
        "Policies": [{
          "PolicyName": "AllowLogs",
          "PolicyDocument": {
            "Statement": [{
              "Effect": "Allow",
              "Action": ["logs:*"],
              "Resource": "*"
            }]
          }
        }]
      }
    },
...
```

### YAML
<a name="walkthrough-lambda-backed-custom-resources-sample-template-iam-role-yaml"></a>

```
...
  LambdaExecutionRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Statement:
          - Effect: "Allow"
            Principal:
              Service:
                - "lambda.amazonaws.com"
            Action:
              - "sts:AssumeRole"
      Path: "/"
      Policies:
        - PolicyName: "AllowLogs"
          PolicyDocument:
            Statement:
              - Effect: "Allow"
                Action:
                  - "logs:*"
                Resource: "*"
...
```

[AWS::CloudFormation::CustomResource](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-customresource.html)risorsa `CFNWaiterCustomResource`  
La risorsa personalizzata si collega alla funzione Lambda con il relativo ARN utilizzando `!GetAtt CFNWaiter.Arn`. Implementerà un tempo di attesa di 60 secondi per le operazioni di creazione e aggiornamento, come impostato in `ServiceTimeout`. La risorsa verrà invocata per un’operazione di aggiornamento solo se le proprietà vengono modificate.

### JSON
<a name="walkthrough-lambda-backed-custom-resources-sample-template-custom-resource-json"></a>

```
...
    "CFNWaiterCustomResource": {
      "Type": "AWS::CloudFormation::CustomResource",
      "Properties": {
        "ServiceToken": { "Fn::GetAtt": ["CFNWaiter", "Arn"] },
        "ServiceTimeout": 60
      }
    }
  },
...
```

### YAML
<a name="walkthrough-lambda-backed-custom-resources-sample-template-custom-resource-yaml"></a>

```
...
  CFNWaiterCustomResource:
    Type: AWS::CloudFormation::CustomResource
    Properties:
      ServiceToken: !GetAtt CFNWaiter.Arn
      ServiceTimeout: 60
...
```

`Outputs`  
Gli `Outputs` di questo modello sono `TimeWaited` e `WaiterId`. Il valore `TimeWaited` usa una funzione `Fn::GetAtt` per fornire la quantità di tempo in cui la risorsa waiter ha effettivamente atteso. Il `WaiterId` usa una funzione `Fn::GetAtt` per fornire l’ID univoco generato e associato all’esecuzione.

### JSON
<a name="walkthrough-lambda-backed-custom-resources-sample-template-output-json"></a>

```
...
  "Outputs": {
    "TimeWaited": {
      "Value": { "Fn::GetAtt": ["CFNWaiterCustomResource", "TimeWaited"] },
      "Export": { "Name": "TimeWaited" }
    },
    "WaiterId": {
      "Value": { "Fn::GetAtt": ["CFNWaiterCustomResource", "Id"] },
      "Export": { "Name": "WaiterId" }
    }
  }
}
...
```

### YAML
<a name="walkthrough-lambda-backed-custom-resources-sample-template-output-yaml"></a>

```
...
Outputs:
  TimeWaited:
    Value: !GetAtt CFNWaiterCustomResource.TimeWaited
    Export:
      Name: TimeWaited
  WaiterId:
    Value: !GetAtt CFNWaiterCustomResource.Id
    Export:
      Name: WaiterId
...
```

## Prerequisiti
<a name="walkthrough-lambda-backed-custom-resources-prerequisites"></a>

È necessario disporre delle autorizzazioni IAM per utilizzare tutti i servizi corrispondenti, come CloudFormation Lambda e.

## Avviare lo stack
<a name="walkthrough-lambda-backed-custom-resources-createfunction-createstack"></a>

**Per creare lo stack**

1. Trova il modello che preferisci (YAML o JSON) dalla sezione [Modello di esempio](#walkthrough-lambda-backed-custom-resources-sample-template) e salvalo sul computer con il nome `samplelambdabackedcustomresource.template`.

1. Apri la CloudFormation console all'indirizzo. [https://console.aws.amazon.com/cloudformation/](https://console.aws.amazon.com/cloudformation/)

1. Dalla pagina **Stack**, scegli **Crea stack** in alto a destra, poi scegli **Con nuove risorse (standard)**.

1. In **Prerequisito - Prepara modello**, seleziona **Scegli un modello esistente**.

1. In **Specifica modello**, scegli **Carica un file di modello**, poi seleziona **Scegli file**.

1. Seleziona il file di modello `samplelambdabackedcustomresource.template` salvato in precedenza.

1. Scegli **Next (Successivo)**.

1. In **Nome stack**, digita **SampleCustomResourceStack** e scegli **Avanti**.

1. Per questa procedura guidata, non è necessario aggiungere tag o specificare impostazioni avanzate, quindi selezionare **Next (Avanti)**.

1. Assicurati che il nome dello stack sia corretto, quindi seleziona **Crea**.

La creazione dello stack potrebbe richiedere alcuni minuti. CloudFormation È possibile controllare l’avanzamento negli eventi per lo stack. Per ulteriori informazioni, consulta [Visualizza le informazioni sullo stack dalla console CloudFormation](cfn-console-view-stack-data-resources.md).

Se la creazione dello stack avviene correttamente, vengono create tutte le risorse nello stack, come la funzione Lambda e la risorsa personalizzata. Hai utilizzato correttamente una funzione Lambda e una risorsa personalizzata.

[Se la funzione Lambda restituisce un errore, visualizza i log della funzione nella CloudWatch console Logs.](https://console.aws.amazon.com/cloudwatch/home#logs:) Il nome del flusso di log è l'ID fisico della risorsa personalizzata, che puoi trovare visualizzando le risorse dello stack. Per ulteriori informazioni, consulta [Visualizza i dati di log](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#ViewingLogData) nella *Amazon CloudWatch User Guide*.

## Pulizia delle risorse
<a name="walkthrough-lambda-backed-custom-resources-createfunction-cleanup"></a>

Elimina lo stack per cancellare tutte le risorse dello stack create in modo da non pagare per le risorse superflue.

**Per eliminare lo stack**

1. Dalla CloudFormation console, scegli lo **SampleCustomResourceStack**stack.

1. Scegliere **Actions (Operazioni)** e poi **Delete Stack (Elimina stack)**.

1. Nel messaggio di conferma, scegliere **Yes, Delete (Sì, elimina)**.

Tutte le risorse create vengono eliminate.

Ora che sai come creare e utilizzare una risorsa personalizzata supportata da Lambda, puoi usare il modello e il codice di esempio di questa procedura guidata per creare e sperimentare con altri stack e altre funzioni.

## Informazioni correlate
<a name="w2aac11c45b9c24b9c23"></a>
+ [CloudFormation Riferimento a risorse personalizzate](crpg-ref.md)
+ [AWS::CloudFormation::CustomResource](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-cloudformation-customresource.html)

# Modulo `cfn-response`
<a name="cfn-lambda-function-code-cfnresponsemodule"></a>

Nel CloudFormation modello, puoi specificare una funzione Lambda come destinazione di una risorsa personalizzata. Quando utilizzi la proprietà `ZipFile` per specificare il codice sorgente della [funzione](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-lambda-function.html), puoi caricare il modulo `cfn-response` per inviare le risposte dalla funzione Lambda a una risorsa personalizzata. Il modulo `cfn-response` è una libreria che semplifica l’invio di risposte alla risorsa personalizzata che ha invocato la funzione Lambda. Il modulo ha un metodo `send` che invia un [oggetto di risposta](crpg-ref.md#crpg-ref-responses) a una risorsa personalizzata mediante un URL prefirmato Amazon S3 (`ResponseURL`).

Il modulo `cfn-response` è disponibile solo quando si utilizza la proprietà `ZipFile` per scrivere il codice d’origine. Il modulo non è disponibile per il codice di origine archiviato in bucket Amazon S3. Per il codice nei bucket, è necessario scrivere funzioni proprie per inviare le risposte.

**Nota**  
Dopo l’esecuzione del metodo `send`, la funzione Lambda termina, perciò tutto quello che si scrive dopo quel metodo verrà ignorato.

## Caricamento del modulo `cfn-response`
<a name="cfn-lambda-function-code-cfnresponsemodule-loading"></a>

Per le funzioni Node.js, utilizza la funzione `require()` per caricare il modulo `cfn-response`. Ad esempio, il seguente esempio di codice crea un oggetto `cfn-response` con il nome `response`:

```
var response = require('cfn-response');
```

Per Python, utilizza l’istruzione `import` per caricare il modulo `cfnresponse`, come mostrato nel seguente esempio:

**Nota**  
Utilizzare questa istruzione di importazione esatta. Se si utilizzano altre varianti di istruzione di importazione, CloudFormation non include il modulo di risposta.

```
import cfnresponse
```

## Parametri del metodo `send`
<a name="cfn-lambda-function-code-cfnresponsemodule-send-parameters"></a>

Si possono utilizzare i seguenti parametri con il metodo `send`:

`event`  
I campi in una [richiesta di risorse personalizzata](crpg-ref.md#crpg-ref-requesttypes).

`context`  
Un oggetto, specifico per le funzioni Lambda, che è possibile utilizzare per specificare quando la funzione e qualsiasi callback hanno completato l’esecuzione o per accedere alle informazioni dall’interno dell’ambiente di esecuzione Lambda. Per ulteriori informazioni, consulta [Building Lambda functions with Node.js](https://docs.aws.amazon.com/lambda/latest/dg/lambda-nodejs.html) nella *Guida per gli sviluppatori di AWS Lambda *.

`responseStatus`  
Se la funzione è stata completata. Utilizza le costanti del modulo `cfnresponse` per specificare lo stato: `SUCCESS` per esecuzioni di successo e `FAILED` per esecuzioni non riuscite.

`responseData`  
Il campo `Data` di un [oggetto di risposta](crpg-ref.md#crpg-ref-responses) della risorsa personalizzata. I dati corrispondono a un elenco di coppie nome-valore.

`physicalResourceId`  
Opzionale. L’ID univoco della risorsa personalizzata che ha invocato la funzione. Per impostazione predefinita, il modulo utilizza il nome del flusso di log di Amazon CloudWatch Logs associato alla funzione Lambda.  
Il valore restituito per un `PhysicalResourceId` può modificare le operazioni personalizzate di aggiornamento delle risorse. Se il valore restituito è lo stesso, viene considerato un aggiornamento normale. Se il valore restituito è diverso, CloudFormation riconosce l'aggiornamento come sostituto e invia una richiesta di eliminazione alla vecchia risorsa. Per ulteriori informazioni, consulta [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-customresource.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-customresource.html).

`noEcho`  
Opzionale. Indica se nascondere o meno l’output della risorsa personalizzata quando viene recuperata utilizzando la funzione `Fn::GetAtt`. Se impostato su `true`, tutti i valori restituiti vengono mascherati con asterischi (\$1\$1\$1\$1\$1), ad eccezione delle informazioni archiviate nelle posizioni specificate di seguito. Di default, il valore è `false`.  
L’utilizzo dell’attributo `NoEcho` non maschera le informazioni memorizzate nei seguenti elementi:  
+ La sezione dei `Metadata` modelli. CloudFormation non trasforma, modifica o oscura le informazioni incluse nella `Metadata` sezione. Per ulteriori informazioni, vedere [Metadati](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/metadata-section-structure.html).
+ Sezione dei modelli `Outputs`. Per ulteriori informazioni, consulta [Output](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/outputs-section-structure.html).
+ Attributo `Metadata` di una definizione di risorsa. Per ulteriori informazioni, consulta [Attributo `Metadata`](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-metadata.html).
Si consiglia vivamente di non utilizzare questi meccanismi per includere informazioni sensibili, come password o segreti.
Per ulteriori informazioni sull’utilizzo di `NoEcho` per mascherare le informazioni sensibili, consulta la best practice [Non incorporare le credenziali nei modelli](security-best-practices.md#creds).

## Esempi
<a name="cfn-lambda-function-code-cfnresponsemodule-examples"></a>

### Node.js
<a name="cfn-lambda-function-code-zipfile-examplenodejs"></a>

In questo esempio Node.js, la funzione in linea Lambda utilizza un valore di input e lo moltiplica per 5. Le funzioni in linea sono particolarmente utili per le funzioni più piccole perché consentono di specificare il codice di origine direttamente nel modello, invece di creare un pacchetto e caricarlo in un bucket Amazon S3. La funzione utilizza il metodo `cfn-response` `send` per inviare il risultato alla risorsa personalizzata che la richiama.

#### JSON
<a name="cfn-lambda-function-code-zipfile-examplenodejs.json"></a>

```
"ZipFile": { "Fn::Join": ["", [
  "var response = require('cfn-response');",
  "exports.handler = function(event, context) {",
  "  var input = parseInt(event.ResourceProperties.Input);",
  "  var responseData = {Value: input * 5};",
  "  response.send(event, context, response.SUCCESS, responseData);",
  "};"
]]}
```

#### YAML
<a name="cfn-lambda-function-code-zipfile-examplenodejs-yaml"></a>

```
ZipFile: >
  var response = require('cfn-response');
  exports.handler = function(event, context) {
    var input = parseInt(event.ResourceProperties.Input);
    var responseData = {Value: input * 5};
    response.send(event, context, response.SUCCESS, responseData);
  };
```

### Python
<a name="cfn-lambda-function-code-zipfile-examplepython"></a>

In questo esempio Python, la funzione inline Lambda utilizza un valore intero e lo moltiplica per 5.

#### JSON
<a name="cfn-lambda-function-code-zipfile-examplepython.json"></a>

```
"ZipFile" : { "Fn::Join" : ["\n", [
  "import json",
  "import cfnresponse",
  "def handler(event, context):",
  "   responseValue = int(event['ResourceProperties']['Input']) * 5",
  "   responseData = {}",
  "   responseData['Data'] = responseValue",
  "   cfnresponse.send(event, context, cfnresponse.SUCCESS, responseData, \"CustomResourcePhysicalID\")"
]]}
```

#### YAML
<a name="cfn-lambda-function-code-zipfile-examplepython.yaml"></a>

```
ZipFile: |
  import json
  import cfnresponse
  def handler(event, context):
    responseValue = int(event['ResourceProperties']['Input']) * 5
    responseData = {}
    responseData['Data'] = responseValue
    cfnresponse.send(event, context, cfnresponse.SUCCESS, responseData, "CustomResourcePhysicalID")
```

## Codice di origine del modulo
<a name="cfn-lambda-function-code-cfnresponsemodule-source"></a>

**Topics**
+ [Codice sorgente asincrono di Node.js](#cfn-lambda-function-code-cfnresponsemodule-source-nodejs-async)
+ [Codice sorgente Node.js](#cfn-lambda-function-code-cfnresponsemodule-source-nodejs)
+ [Codice sorgente Python](#cfn-lambda-function-code-cfnresponsemodule-source-python)

### Codice sorgente asincrono di Node.js
<a name="cfn-lambda-function-code-cfnresponsemodule-source-nodejs-async"></a>

Il seguente è il codice sorgente del modulo di risposta per le funzioni Node.js se il gestore è asincrono. Esaminarlo per comprendere ciò che il modulo fa e per facilitare l’implementazione di funzioni di risposta personalizzate.

```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: MIT-0

exports.SUCCESS = "SUCCESS";
exports.FAILED = "FAILED";

exports.send = function(event, context, responseStatus, responseData, physicalResourceId, noEcho) {

    return new Promise((resolve, reject) => {
        var responseBody = JSON.stringify({
            Status: responseStatus,
            Reason: "See the details in CloudWatch Log Stream: " + context.logStreamName,
            PhysicalResourceId: physicalResourceId || context.logStreamName,
            StackId: event.StackId,
            RequestId: event.RequestId,
            LogicalResourceId: event.LogicalResourceId,
            NoEcho: noEcho || false,
            Data: responseData
        });

        console.log("Response body:\n", responseBody);

        var https = require("https");
        var url = require("url");

        var parsedUrl = url.parse(event.ResponseURL);
        var options = {
            hostname: parsedUrl.hostname,
            port: 443,
            path: parsedUrl.path,
            method: "PUT",
            headers: {
                "content-type": "",
                "content-length": responseBody.length
            }
        };

        var request = https.request(options, function(response) {
            console.log("Status code: " + parseInt(response.statusCode));
            resolve(context.done());
        });

        request.on("error", function(error) {
            console.log("send(..) failed executing https.request(..): " + maskCredentialsAndSignature(error));
            reject(context.done(error));
        });

        request.write(responseBody);
        request.end();
    })
}
 
function maskCredentialsAndSignature(message) {
    return message.replace(/X-Amz-Credential=[^&\s]+/i, 'X-Amz-Credential=*****')
        .replace(/X-Amz-Signature=[^&\s]+/i, 'X-Amz-Signature=*****');
}
```

### Codice sorgente Node.js
<a name="cfn-lambda-function-code-cfnresponsemodule-source-nodejs"></a>

Il seguente è il codice sorgente del modulo di risposta per le funzioni Node.js se il gestore non è asincrono. Esaminarlo per comprendere ciò che il modulo fa e per facilitare l’implementazione di funzioni di risposta personalizzate.

```
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: MIT-0
 
exports.SUCCESS = "SUCCESS";
exports.FAILED = "FAILED";

exports.send = function(event, context, responseStatus, responseData, physicalResourceId, noEcho) {

    var responseBody = JSON.stringify({
        Status: responseStatus,
        Reason: "See the details in CloudWatch Log Stream: " + context.logStreamName,
        PhysicalResourceId: physicalResourceId || context.logStreamName,
        StackId: event.StackId,
        RequestId: event.RequestId,
        LogicalResourceId: event.LogicalResourceId,
        NoEcho: noEcho || false,
        Data: responseData
    });

    console.log("Response body:\n", responseBody);

    var https = require("https");
    var url = require("url");

    var parsedUrl = url.parse(event.ResponseURL);
    var options = {
        hostname: parsedUrl.hostname,
        port: 443,
        path: parsedUrl.path,
        method: "PUT",
        headers: {
            "content-type": "",
            "content-length": responseBody.length
        }
    };

    var request = https.request(options, function(response) {
        console.log("Status code: " + parseInt(response.statusCode));
        context.done();
    });

    request.on("error", function(error) {
        console.log("send(..) failed executing https.request(..): " + maskCredentialsAndSignature(error));
        context.done();
    });

    request.write(responseBody);
    request.end();
}
```

### Codice sorgente Python
<a name="cfn-lambda-function-code-cfnresponsemodule-source-python"></a>

Il seguente è il codice sorgente del modulo di risposta per le funzioni Python:

```
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: MIT-0
 
from __future__ import print_function
import urllib3
import json
import re

SUCCESS = "SUCCESS"
FAILED = "FAILED"

http = urllib3.PoolManager()


def send(event, context, responseStatus, responseData, physicalResourceId=None, noEcho=False, reason=None):
    responseUrl = event['ResponseURL']

    responseBody = {
        'Status' : responseStatus,
        'Reason' : reason or "See the details in CloudWatch Log Stream: {}".format(context.log_stream_name),
        'PhysicalResourceId' : physicalResourceId or context.log_stream_name,
        'StackId' : event['StackId'],
        'RequestId' : event['RequestId'],
        'LogicalResourceId' : event['LogicalResourceId'],
        'NoEcho' : noEcho,
        'Data' : responseData
    }

    json_responseBody = json.dumps(responseBody)

    print("Response body:")
    print(json_responseBody)

    headers = {
        'content-type' : '',
        'content-length' : str(len(json_responseBody))
    }

    try:
        response = http.request('PUT', responseUrl, headers=headers, body=json_responseBody)
        print("Status code:", response.status)


    except Exception as e:

        print("send(..) failed executing http.request(..):", mask_credentials_and_signature(e))
 
 
def mask_credentials_and_signature(message):
    message = re.sub(r'X-Amz-Credential=[^&\s]+', 'X-Amz-Credential=*****', message, flags=re.IGNORECASE)
    return re.sub(r'X-Amz-Signature=[^&\s]+', 'X-Amz-Signature=*****', message, flags=re.IGNORECASE)
```

# Esegui elaborazioni personalizzate su CloudFormation modelli con macro di modelli
<a name="template-macros"></a>

Con le macro, puoi eseguire elaborazioni personalizzate sui modelli, da azioni semplici come find-and-replace operazioni a trasformazioni estese di interi modelli.

Per avere un'idea della gamma di possibilità, prendete in considerazione le `AWS::Serverless` trasformazioni `AWS::Include` and, che sono macro ospitate da: CloudFormation
+ Le [trasformazioni AWS::Include](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/transform-aws-include.html) ti consentono di inserire frammenti di modello boilerplate nei modelli.
+ [AWS::Serverlesstransform](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/transform-aws-serverless.html) prende un intero modello scritto nella sintassi AWS Serverless Application Model (AWS SAM) e lo trasforma ed espande in un modello conforme. CloudFormation [Per ulteriori informazioni sulle applicazioni serverless e, consulta la Developer Guide. AWS SAMAWS Serverless Application Model](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html)

**Topics**
+ [Fatturazione](#template-macros-billing)
+ [Esempi di macro](#template-macros-examples-list)
+ [Risorse correlate](#template-macros-related-resources)
+ [Panoramica delle CloudFormation macro](template-macros-overview.md)
+ [Creare una definizione di CloudFormation macro](template-macros-author.md)
+ [Esempio di una macro semplice di sostituzione delle stringhe](macros-example.md)
+ [Risolvi i problemi relativi al modello elaborato](template-macros-troubleshoot-processed-template.md)

## Fatturazione
<a name="template-macros-billing"></a>

Quando una macro viene eseguita, al proprietario della funzione Lambda vengono addebitati i costi relativi all'esecuzione di quella funzione.

Le `AWS::Serverless` trasformazioni `AWS::Include` e sono macro ospitate da. CloudFormation Il loro utilizzo non comporta alcun costo.

## Esempi di macro
<a name="template-macros-examples-list"></a>

[Oltre agli esempi in questa sezione, nel nostro repository puoi trovare macro di esempio, tra cui codice sorgente e modelli. GitHub ](https://github.com/aws-cloudformation/aws-cloudformation-templates/tree/main/CloudFormation/MacrosExamples) Questi esempi vengono forniti "così come sono" per scopi didattici.

## Risorse correlate
<a name="template-macros-related-resources"></a>
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-macro.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-macro.html)
+ [CloudFormation Transformsezione modello](transform-section-structure.md)
+ [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-transform.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/intrinsic-function-reference-transform.html)
+ [Trasformazione AWS::Serverless](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/transform-aws-serverless.html)
+ [Trasformazione AWS::Include](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/transform-aws-include.html)

# Panoramica delle CloudFormation macro
<a name="template-macros-overview"></a>

L'elaborazione di modelli mediante macro comporta due fasi principali: la creazione della macro stessa e quindi l'utilizzo della macro per eseguire l'elaborazione sui modelli.

Per creare una definizione di macro, devi creare quanto segue:
+ Una funzione Lambda per eseguire l’elaborazione dei modelli. Questa funzione Lambda accetta un frammento di modello o un intero modello e qualsiasi parametro supplementare che definisci. Restituisce quindi l'intero modello o il frammento di modello elaborato come risposta.
+ Una risorsa di tipo [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-macro.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-macro.html), che consente agli utenti di chiamare la funzione Lambda dall'interno CloudFormation dei modelli. Questa risorsa specifica l'ARN della funzione Lambda da richiamare per questa macro nonché ulteriori proprietà facoltative per facilitare il debug. Per creare questa risorsa all'interno di un account, crea un modello che includa la `AWS::CloudFormation::Macro` risorsa, quindi crea uno stack o un set di stack con le autorizzazioni gestite automaticamente dal modello. CloudFormation StackSetsattualmente non supporta la creazione o l'aggiornamento di set di stack con autorizzazioni gestite dai servizi da modelli che fanno riferimento alle macro.

Per utilizzare una macro, fai riferimento alla macro nel modello:
+ Per elaborare una sezione o parte di un modello, fai riferimento alla macro in una funzione `Fn::Transform` posizionata in relazione al contenuto del modello che intendi trasformare. Quando utilizzi `Fn::Transform`, puoi anche passare qualsiasi parametro specificato di cui necessita.
+ Per elaborare un intero modello, fai riferimento alla macro nella sezione [Transform](transform-section-structure.md) del modello.

Quindi, crea in genere un set di modifiche ed eseguilo. (L'elaborazione di macro può aggiungere molteplici risorse di cui potresti non essere a conoscenza. Per assicurarti di essere a conoscenza di tutte le modifiche introdotte dalle macro, ti consigliamo di utilizzare set di modifiche). CloudFormation passa il contenuto di modello specificato, insieme a eventuali altri parametri definiti, alla funzione Lambda indicata nella risorsa di macro. La funzione Lambda restituisce il contenuto di modello elaborato, che si tratti di un frammento o di un intero modello.

Dopo aver richiamato tutte le macro del modello, CloudFormation genera un set di modifiche che include il contenuto del modello elaborato. Dopo aver esaminato il set di modifiche, eseguilo per applicare le modifiche.

![\[Utilizza la funzione intrinseca Fn::Transform o la sezione Transform del modello per passare il contenuto del modello e i parametri associati alla funzione Lambda sottostante della macro, che restituisce il contenuto di modello elaborato.\]](http://docs.aws.amazon.com/it_it/AWSCloudFormation/latest/UserGuide/images/template-macro-use.png)


## Come creare stack in modo diretto
<a name="template-macros-change-sets"></a>

Per creare o aggiornare uno stack utilizzando un modello che fa riferimento a macro, crea un set di modifiche e quindi eseguilo. Un set di modifiche descrive le operazioni eseguite da CloudFormation in base al modello elaborato. L'elaborazione di macro può aggiungere molteplici risorse di cui potresti non essere a conoscenza. Per assicurarti di essere a conoscenza di tutte le modifiche introdotte dalle macro, ti consigliamo di utilizzare set di modifiche. Dopo aver esaminato il set di modifiche, puoi eseguirlo per applicare le modifiche.

Una macro può aggiungere risorse IAM al modello. Per queste risorse, CloudFormation richiede l'[accettazione delle funzionalità](control-access-with-iam.md#using-iam-capabilities). Poiché non è CloudFormation possibile sapere quali risorse vengono aggiunte prima di elaborare il modello, potrebbe essere necessario riconoscere le funzionalità IAM quando si crea il set di modifiche, a seconda che le macro a cui si fa riferimento contengano risorse IAM. In questo modo, quando si esegue il set di modifiche, CloudFormation dispone delle funzionalità necessarie per creare risorse IAM.

Per creare o aggiornare uno stack direttamente da un modello elaborato senza prima rivedere le modifiche proposte in un set di modifiche, specifica la funzionalità `CAPABILITY_AUTO_EXPAND` durante una richiesta `CreateStack` o `UpdateStack`. È sufficiente creare stack direttamente da un modello di stack che contiene macro se si conosce l'elaborazione della macro. Non puoi utilizzare set di modifiche con macro di set di stack; è necessario aggiornare il set di stack direttamente.

Per ulteriori informazioni, vedi [https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html) o [https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_UpdateStack.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_UpdateStack.html) nella *documentazione di riferimento dell’API AWS CloudFormation *.

**Importante**  
Se il modello di set di stack contiene riferimenti a una o più macro, devi creare il set di stack direttamente dal modello elaborato, senza prima esaminare le modifiche risultanti in un set di modifiche. L'elaborazione di macro può aggiungere molteplici risorse di cui potresti non essere a conoscenza. Prima di creare o aggiornare un set di stack da un modello che fa riferimento direttamente alle macro, assicurarsi di sapere che elaborazione eseguono le macro.

Per ridurre il numero di passaggi necessari per avviare stack da modelli che fanno riferimento a macro, puoi utilizzare i `package` comandi and. `deploy` AWS CLI Per ulteriori informazioni, consultare [Carica gli artefatti locali in un bucket S3 con AWS CLI](using-cfn-cli-package.md) e [Crea uno stack che includa le trasformazioni](service_code_examples.md#deploy-sdk).

## Considerazioni
<a name="template-macros-considerations"></a>

Quando lavori con le macro, tieni presente le seguenti note e limitazioni:
+ Le macro sono supportate solo Regioni AWS dove è disponibile Lambda. Per l'elenco delle Regioni in cui Lambda è disponibile, consulta l'argomento relativo a [endpoint e quote di AWS Lambda](https://docs.aws.amazon.com/general/latest/gr/lambda-service.html).
+ Qualsiasi frammento di modello elaborato deve essere in formato JSON valido.
+ Qualsiasi frammento di modello elaborato deve superare controlli di convalida per un'operazione di creazione o aggiornamento di stack e creazione o aggiornamento di set di stack.
+ CloudFormation risolve prima le macro e poi elabora il modello. Il modello risultante deve essere in formato JSON valido e non deve superare il limite di dimensioni stabilito.
+ A causa dell'ordine in cui CloudFormation elabora gli elementi di un modello, una macro non può includere moduli nel contenuto del modello elaborato a cui ritorna. CloudFormation Per ulteriori informazioni, consulta [Ordine di valutazione delle macro](template-macros-author.md#template-macros-order).
+ Quando si utilizza la funzione di ripristino dell'aggiornamento, CloudFormation utilizza una copia del modello originale. Il rollback del modello originale viene eseguito anche se il frammento incluso è stato modificato.
+ L’inclusione di macro in altre macro non funziona in quanto non vengono elaborate in modo ripetuto.
+ La funzione intrinseca `Fn::ImportValue` non è attualmente supportata nelle macro.
+ Le funzioni intrinseche incluse nel modello sono valutate dopo le macro. Pertanto, il contenuto di modello elaborato restituito dalla macro può includere chiamate alle funzioni intrinseche, che vengono valutate normalmente.
+ StackSets attualmente non supporta la creazione o l'aggiornamento di set di stack con autorizzazioni gestite dal servizio da modelli che fanno riferimento alle macro. CloudFormation

## Autorizzazioni e ambito dell’account di macro
<a name="template-macros-permissions"></a>

Puoi utilizzare le macro solo nell'account in cui sono state create come risorsa. Il nome della macro deve essere univoco in un determinato account. Tuttavia, puoi rendere disponibile la stessa funzionalità in vari account abilitando l'accesso tra più account sulla funzione Lambda sottostante e quindi creando definizioni di macro che fanno riferimento a quella funzione in molteplici account. Nell'esempio seguente, tre account contengono definizioni di macro che puntano alla stessa funzione Lambda.

![\[Consentendo l'accesso tra account alla funzione Lambda AWS , consente di creare macro in più account che fanno riferimento a tale funzione.\]](http://docs.aws.amazon.com/it_it/AWSCloudFormation/latest/UserGuide/images/template-macro-accounts.png)


Per creare una definizione di macro, l'utente deve disporre delle autorizzazioni per creare uno stack o set di stack nell'account specificato.

 CloudFormation Per eseguire correttamente una macro inclusa in un modello, l'utente deve disporre delle `Invoke` autorizzazioni per la funzione Lambda sottostante. Per evitare un potenziale aumento delle autorizzazioni, CloudFormation impersona l'utente durante l'esecuzione della macro.

Per ulteriori informazioni, consulta [Managing permissions in AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-permissions.html) nella *Guida per sviluppatori di AWS Lambda * e [Actions, resources, and condition keys for AWS Lambda](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awslambda.html) in *Service Authorization Reference*.

# Creare una definizione di CloudFormation macro
<a name="template-macros-author"></a>

Quando si crea una definizione di macro, la definizione della macro rende disponibile la funzione Lambda sottostante nell'account specificato in modo che la CloudFormation richiami per elaborare i modelli.

## Mappatura degli eventi
<a name="template-macros-event-mapping"></a>

Quando CloudFormation richiama la funzione Lambda di una macro, invia una richiesta in formato JSON con la seguente struttura:

```
{
    "region" : "us-east-1",
    "accountId" : "$ACCOUNT_ID",
    "fragment" : { ... },
    "transformId" : "$TRANSFORM_ID",
    "params" : { ... },
    "requestId" : "$REQUEST_ID",
    "templateParameterValues" : { ... }
}
```
+ `region`

  La Regione in cui si trova la macro.
+ `accountId`

  L'ID account dell'account da cui la macro richiama la funzione Lambda.
+ `fragment`

  Il contenuto di modello disponibile per l'elaborazione personalizzata, in formato JSON.
  + Per le macro incluse nella sezione `Transform` del modello, si tratta dell'intero modello tranne la sezione `Transform`.
  + Per le macro incluse nella chiamata della funzione intrinseca `Fn::Transform`, include tutti i nodi di pari livello (e i relativi figli) in base alla posizione della funzione intrinseca nel modello ad eccezione della funzione `Fn::Transform`. Per ulteriori informazioni, consulta [Ambito dei modelli delle macro](#template-macros-scope).
+ `transformId`

  Il nome della macro che richiama questa funzione.
+ `params`

  Per le chiamate di `Fn::Transform` funzione, qualsiasi parametro specificato per la funzione. CloudFormation non valuta questi parametri prima di passarli alla funzione.

  Per le macro incluse nella sezione `Transform` del modello, questa sezione è vuota.
+ `requestId`

  L'ID della richiesta che richiama questa funzione.
+ `templateParameterValues`

  Qualsiasi parametro specificato nella [Parameters](parameters-section-structure.md) sezione del modello. CloudFormation valuta questi parametri prima di passarli alla funzione.

## Formato della risposta
<a name="template-macros-response-format"></a>

CloudFormation si aspetta che la funzione Lambda restituisca una risposta nel seguente formato JSON:

```
{
    "requestId" : "$REQUEST_ID",
    "status" : "$STATUS",
    "fragment" : { ... },
    "errorMessage": "optional error message for failures"
}
```
+ `requestId`

  L'ID della richiesta che richiama questa funzione. Deve corrispondere all'ID della richiesta fornito da CloudFormation quando si richiama la funzione.
+ `status`

  Lo stato della richiesta (senza distinzione tra maiuscole e minuscole). Dovrebbe essere impostato su. `success` CloudFormation considera ogni altra risposta come un fallimento.
+ `fragment`

  Il contenuto del modello elaborato CloudFormation da includere nel modello elaborato, inclusi i fratelli. CloudFormation sostituisce il contenuto del modello passato alla funzione Lambda con il frammento di modello che riceve nella risposta Lambda.

  Il contenuto di modello elaborato deve essere in formato JSON valido e l'inclusione dello stesso nel modello elaborato deve generare un modello valido.

  Se la funzione non modifica effettivamente il contenuto di modello che CloudFormation passa alla stessa, ma è ancora necessario includere quel contenuto nel modello elaborato, la funzione deve restituire quel contenuto a CloudFormation nella relativa risposta.
+ `errorMessage`

  Il messaggio di errore che spiega perché la trasformazione non è riuscita. CloudFormation visualizza questo messaggio di errore nel riquadro **Eventi** della pagina dei **Dettagli dello stack** per lo stack.

  Esempio:

  ```
  Error creating change set: Transform
                              Account AWS account
                              number::macro name failed with:
                              error message string.
  ```

## Crea una definizione di macro
<a name="create-a-macro-definition"></a>

**Per creare una definizione di macro CloudFormation**

1. [Crea una funzione Lambda](https://docs.aws.amazon.com/lambda/latest/dg/getting-started.html) che gestirà l’elaborazione dei contenuti del modello. La funzione può elaborare qualsiasi parte di un modello, anche l’intero modello. 

1. Create un CloudFormation modello contenente un tipo di `AWS::CloudFormation::Macro` risorsa e specificate le `FunctionName` proprietà `Name` and. La `FunctionName` proprietà deve contenere l'ARN della funzione Lambda da richiamare quando viene eseguita la macro. CloudFormation 

1. (Opzionale) Per facilitare il debug, puoi anche specificare le proprietà `LogGroupName` e `LogRoleArn` quando crei il tipo di risorsa `AWS::CloudFormation::Macro` per la macro. Queste proprietà consentono di specificare il gruppo di log CloudWatch Logs a cui CloudFormation inviare le informazioni di registrazione degli errori quando si richiama la funzione Lambda sottostante della macro e il ruolo da CloudFormation assumere quando si inviano le voci di registro a tali registri.

1. [Crea uno stack](cfn-console-create-stack.md) utilizzando il modello con la macro nell’account in cui desideri utilizzarlo. In alternativa, [crea un set di stack con autorizzazioni gestite dal cliente](stacksets-getting-started-create-self-managed.md) utilizzando il modello con la macro nell’account amministratore, quindi crea istanze stack negli account di destinazione.

1. Dopo aver CloudFormation creato con successo gli stack che contengono la definizione della macro, la macro è disponibile per l'uso all'interno di tali account. Puoi utilizzare una macro facendo riferimento alla stessa in un modello, nella posizione appropriata relativa al contenuto del modello che desideri elaborare.

## Ambito dei modelli delle macro
<a name="template-macros-scope"></a>

Le macro a cui si fa riferimento nella sezione `Transform` di un modello possono elaborare l'intero contenuto di quel modello.

Le macro a cui si fa riferimento in una funzione `Fn::Transform` possono elaborare il contenuto di qualsiasi elemento di pari livello (inclusi i figli) di quella funzione `Fn::Transform` nel modello.

Ad esempio, nell'esempio di modello seguente, `AWS::Include` può elaborare tutte le proprietà `MyBucket` in base alla posizione della funzione `Fn::Transform` che la contiene. `MyMacro` può elaborare il contenuto dell'intero modello per via della relativa inclusione nella sezione `Transform`.

```
# Start of processable content for MyMacro
AWSTemplateFormatVersion: 2010-09-09 
 Transform: [MyMacro]
 Resources:
    WaitCondition:
      Type: AWS::CloudFormation::WaitCondition
    MyBucket:
      Type: AWS::S3::Bucket
      # Start of processable content for AWS::Include
      Properties:
        BucketName: amzn-s3-demo-bucket1
        Tags: [{"key":"value"}] 
        'Fn::Transform':
          - Name: 'AWS::Include'
              Parameters:
                Location: s3://amzn-s3-demo-bucket2/MyFileName.yaml
        CorsConfiguration: []
        # End of processable content for AWS::Include
    MyEc2Instance:
      Type: AWS::EC2::Instance
      Properties:
        ImageID: ami-1234567890abcdef0
# End of processable content for MyMacro
```

## Ordine di valutazione delle macro
<a name="template-macros-order"></a>

È possibile fare riferimento a più macro in un determinato modello, incluse le trasformazioni ospitate da CloudFormation, ad esempio and. [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/transform-aws-include.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/transform-aws-include.html)

Le macro vengono valutate nell'ordine, secondo la relativa posizione nel modello, da quella più nidificata a quella più generale. Le macro nella stessa posizione nel modello vengono valutate in serie in base all'ordine in cui sono elencate.

Le trasformazioni come `AWS::Include` e `AWS::Transform` vengono gestite come qualsiasi altra macro in termini di ordine e ambito dell'operazione.

Ad esempio, nell'esempio di modello riportato di seguito, CloudFormation valuta per prima cosa la `PolicyAdder` macro, perché è la macro con il nido più profondo del modello. CloudFormation quindi valuta `MyMacro` prima della valutazione `AWS::Serverless` perché è elencata in precedenza nella sezione. `AWS::Serverless` `Transform`

```
AWSTemplateFormatVersion: 2010-09-09
 Transform: [MyMacro, AWS::Serverless]
 Resources:
    WaitCondition:
      Type: AWS::CloudFormation::WaitCondition
    MyBucket:
      Type: AWS::S3::Bucket
      Properties:
        BucketName: amzn-s3-demo-bucket
        Tags: [{"key":"value"}]
        'Fn::Transform':
          - Name: PolicyAdder
        CorsConfiguration: []
    MyEc2Instance:
      Type: AWS::EC2::Instance
      Properties:
        ImageID: ami-1234567890abcdef0
```

# Esempio di una macro semplice di sostituzione delle stringhe
<a name="macros-example"></a>

L’esempio seguente descrive il processo di utilizzo di macro, dalla definizione dalla macro in un modello alla creazione di una funzione Lambda per la macro e all’utilizzo della macro in un modello.

In questo esempio, creeremo una macro semplice che inserisce la stringa specificata al posto del contenuto di destinazione specificato nel modello elaborato. Quindi la utilizzeremo per inserire un campo `WaitHandleCondition` vuoto nella posizione specificata nel modello elaborato.

## Creazione di una macro
<a name="macros-example-definiton"></a>

Prima di utilizzare una macro, dobbiamo prima completare due operazioni: creare la funzione Lambda che esegue l'elaborazione del modello desiderata e quindi rendere disponibile tale funzione CloudFormation Lambda creando una definizione di macro.

L’esempio di modello seguente contiene la definizione del nostro esempio di macro. Per rendere disponibile la macro in uno specifico Account AWS, create uno stack dal modello. La definizione della macro specifica il nome della macro, una breve descrizione e fa riferimento all'ARN della funzione Lambda CloudFormation che viene richiamata quando questa macro viene utilizzata in un modello. (non abbiamo incluso una proprietà `LogGroupName` o `LogRoleARN` per la registrazione degli errori). 

In questo esempio, supponiamo che lo stack creato da questo modello sia denominato `JavaMacroFunc`. Poiché la proprietà `Name` della macro viene impostata sul nome dello stack, anche la macro risultante è denominata `JavaMacroFunc`.

```
AWSTemplateFormatVersion: 2010-09-09
  Resources:
    Macro:
      Type: AWS::CloudFormation::Macro
      Properties:
        Name: !Sub '${AWS::StackName}'
        Description: Adds a blank WaitConditionHandle named WaitHandle
        FunctionName: 'arn:aws:lambda:us-east-1:012345678910:function:JavaMacroFunc'
```

## Utilizzo della macro
<a name="macros-example-usage"></a>

In questo caso, per utilizzare la nostra macro, la includeremo in un modello utilizzando la funzione intrinseca `Fn::Transform`.

Quando creiamo uno stack utilizzando il modello seguente, richiama la nostra macro di esempio. CloudFormation La funzione Lambda sottostante sostituisce una stringa specificata con un’altra stringa specificata. In questo caso, il risultato è una risorsa `AWS::CloudFormation::WaitConditionHandle` vuota che viene inserita nel modello elaborato.

```
Parameters:
  ExampleParameter:
    Type: String
    Default: 'SampleMacro'

Resources:
  2a:
    Fn::Transform:
      Name: "JavaMacroFunc"
      Parameters:
        replacement: 'AWS::CloudFormation::WaitConditionHandle'
        target: '$$REPLACEMENT$$'
    Type: '$$REPLACEMENT$$'
```
+ La macro da invocare è specificata come `JavaMacroFunc`, ovvero la macro dell’esempio di definizione di macro precedente.
+ Alla macro vengono passati due parametri, `target` e `replacement`, che rappresentano la stringa di destinazione e il valore di sostituzione desiderato.
+ La macro può funzionare sul contenuto del nodo `Type` in quanto `Type` è un elemento di pari livello della funzione `Fn::Transform` che fa riferimento alla macro.
+ La risorsa `AWS::CloudFormation::WaitConditionHandle` risultante è denominata `2a`.
+ Il modello contiene inoltre un parametro di modello, `ExampleParameter`, a cui la macro ha accesso (ma che non utilizza in questo caso).

## Dati di input Lambda
<a name="macros-example-request"></a>

Quando CloudFormation elabora il nostro modello di esempio durante la creazione dello stack, passa la seguente mappatura degli eventi alla funzione Lambda a cui si fa riferimento nella definizione della macro. `JavaMacroFunc`
+ `region` : `us-east-1`
+ `accountId` : `012345678910`
+ `fragment` :

  ```
  {
    "Type": "$$REPLACEMENT$$"
  }
  ```
+ `transformId` : `012345678910::JavaMacroFunc`
+ `params` : 

  ```
  {
      "replacement": "AWS::CloudFormation::WaitConditionHandle",
      "target": "$$REPLACEMENT$$"
  }
  ```
+ `requestId` : `5dba79b5-f117-4de0-9ce4-d40363bfb6ab`
+ `templateParameterValues` :

  ```
  {
      "ExampleParameter": "SampleMacro"
  }
  ```

`fragment` contiene codice JSON che rappresenta il frammento di modello che la macro può elaborare. Questo frammento comprende elementi di pari livello della chiamata di funzione `Fn::Transform`, ma non la chiamata stessa. Inoltre, `params` contiene codice JSON che rappresenta i parametri di macro. In questo caso, sostituzione e destinazione. Analogamente, `templateParameterValues` contiene codice JSON che rappresenta i parametri specificati per il modello nel complesso.

## Codice della funzione Lambda
<a name="macros-example-function"></a>

Di seguito è riportato il codice effettivo della funzione Lambda sottostante l’esempio di macro `JavaMacroFunc`. L’esempio esegue l’iterazione del frammento di modello incluso nella risposta (che sia in un formato di stringa, elenco o mappa), alla ricerca della stringa di destinazione specificata. Se trova la stringa di destinazione specificata, la funzione Lambda sostituisce la stringa di destinazione con la stringa di sostituzione specificata. In caso contrario, la funzione lascia il frammento di modello invariato. Quindi, la funzione restituisce una mappa delle proprietà previste, discusse in dettaglio di seguito, a. CloudFormation

```
package com.macroexample.lambda.demo;

import java.util.List;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;

public class LambdaFunctionHandler implements RequestHandler<Map<String, Object>, Map<String, Object>> {

	private static final String REPLACEMENT = "replacement";
	private static final String TARGET = "target";
	private static final String PARAMS = "params";
	private static final String FRAGMENT = "fragment";
	private static final String REQUESTID = "requestId";
	private static final String STATUS = "status";
	private static final String SUCCESS = "SUCCESS";
	private static final String FAILURE = "FAILURE";
    @Override
    public Map<String, Object> handleRequest(Map<String, Object> event, Context context) {
        // TODO: implement your handler
    	final Map<String, Object> responseMap = new HashMap<String, Object>();
        responseMap.put(REQUESTID, event.get(REQUESTID));
        responseMap.put(STATUS, FAILURE);
    	try {
	        if (!event.containsKey(PARAMS)) {
	        	throw new RuntimeException("Params are required");
	        }
	    	
	        final Map<String, Object> params = (Map<String, Object>) event.get(PARAMS);
	        if (!params.containsKey(REPLACEMENT) || !params.containsKey(TARGET)) {
	        	throw new RuntimeException("replacement or target under Params are required");
	        }
	    	
	    	final String replacement = (String) params.get(REPLACEMENT);
	    	final String target = (String) params.get(TARGET);
	    	final Object fragment = event.getOrDefault(FRAGMENT, new HashMap<String, Object>());
	    	final Object retFragment;
	    	if (fragment instanceof String) {
	    		retFragment = iterateAndReplace(replacement, target, (String) fragment);
	    	} else if (fragment instanceof List) {
	    		retFragment = iterateAndReplace(replacement, target, (List<Object>) fragment);
	    	} else if (fragment instanceof Map) {
	    		retFragment = iterateAndReplace(replacement, target, (Map<String, Object>) fragment);
	    	} else {
	    		retFragment = fragment;
	    	}
	        responseMap.put(STATUS, SUCCESS);
	        responseMap.put(FRAGMENT, retFragment);
	        return responseMap;
    	} catch (Exception e) {
    		e.printStackTrace();
    		context.getLogger().log(e.getMessage());
    		return responseMap;
    	}
    }
    
    private Map<String, Object> iterateAndReplace(final String replacement, final String target, final Map<String, Object> fragment) {
    	final Map<String, Object> retFragment = new HashMap<String, Object>();
    	final List<String> replacementKeys = new ArrayList<>();
    	fragment.forEach((k, v) -> {
    		if (v instanceof String) {
    			retFragment.put(k, iterateAndReplace(replacement, target, (String)v));
    		} else if (v instanceof List) {
    			retFragment.put(k, iterateAndReplace(replacement, target, (List<Object>)v));
    		} else if (v instanceof Map ) {
    			retFragment.put(k, iterateAndReplace(replacement, target, (Map<String, Object>) v));
    		} else {
    			retFragment.put(k, v);
    		}
    	});
    	return retFragment;
    }

    private List<Object> iterateAndReplace(final String replacement, final String target, final List<Object> fragment) {
    	final List<Object> retFragment = new ArrayList<>();
    	fragment.forEach(o -> {
    		if (o instanceof String) {
    			retFragment.add(iterateAndReplace(replacement, target, (String) o));
    		} else if (o instanceof List) {
    			retFragment.add(iterateAndReplace(replacement, target, (List<Object>) o));
    		} else if (o instanceof Map) {
    			retFragment.add(iterateAndReplace(replacement, target, (Map<String, Object>) o));
    		} else {
    			retFragment.add(o);
    		}
    	});
    	return retFragment;
    }
    
    private String iterateAndReplace(final String replacement, final String target, final String fragment) {
    	System.out.println(replacement + " == " + target + " == " + fragment );
    	if (fragment != null AND_AND fragment.equals(target))
    		return replacement;
    	return fragment;
    }
}
```

## Risposta della funzione Lambda
<a name="macros-example-response"></a>

Di seguito è riportata la mappatura a cui torna la funzione Lambda CloudFormation per l'elaborazione. 
+ `requestId` : `5dba79b5-f117-4de0-9ce4-d40363bfb6ab`
+ `status` : `SUCCESS`
+ `fragment` :

  ```
  {
    "Type": "AWS::CloudFormation::WaitConditionHandle"
  }
  ```

Le `requestId` corrispondenze inviate da CloudFormation e il `status` valore di `SUCCESS` indicano che la funzione Lambda ha elaborato correttamente il frammento di modello incluso nella richiesta. In questa risposta, `fragment` contiene codice JSON che rappresenta il contenuto da inserire nel modello elaborato al posto del frammento del modello originale.

## Modello elaborato risultante
<a name="macros-example-processed"></a>

Dopo aver CloudFormation ricevuto una risposta corretta dalla funzione Lambda, inserisce il frammento di modello restituito nel modello elaborato.

Di seguito è riportato il modello elaborato risultante per il nostro esempio. La chiamata della funzione intrinseca `Fn::Transform` che faceva riferimento alla macro `JavaMacroFunc` non è più inclusa. Il frammento di modello restituito dalla funzione Lambda è incluso nella posizione appropriata, con il risultato che il contenuto `"Type": "$$REPLACEMENT$$"` è stato sostituito con `"Type": "AWS::CloudFormation::WaitConditionHandle"`.

```
{
    "Parameters": {
        "ExampleParameter": {
            "Default": "SampleMacro",
            "Type": "String"
        }
    },
    "Resources": {
        "2a": {
            "Type": "AWS::CloudFormation::WaitConditionHandle"
        }
    }
}
```

# Risolvi i problemi relativi al modello elaborato
<a name="template-macros-troubleshoot-processed-template"></a>

Quando si utilizza una macro, il modello elaborato è disponibile nella CloudFormation console.

La fase di un modello indica lo stato di elaborazione:
+ `Original`: il modello che l'utente ha originariamente inviato per creare o aggiornare lo stack o set di stack.
+ `Processed`: il modello CloudFormation utilizzato per creare o aggiornare lo stack o il set di stack dopo l'elaborazione di tutte le macro a cui si fa riferimento. Il modello elaborato è in formato JSON, anche se il modello originale è in formato YAML.

Utilizza il modello elaborato per la risoluzione dei problemi. Se un modello non fa riferimento a macro, il modello originale e quello elaborato sono identici.

Per ulteriori informazioni, consulta [Visualizza le informazioni sullo stack dalla console CloudFormation](cfn-console-view-stack-data-resources.md).

Per utilizzare il AWS CLI per ottenere il modello elaborato, usa il comando. [get-template](service_code_examples.md#get-template-sdk)

## Limiti di dimensioni
<a name="template-macros-size-limitation"></a>

La dimensione massima per un modello di stack elaborato è di 51.200 byte quando viene passata direttamente a una richiesta `CreateStack`, `UpdateStack` o `ValidateTemplate`, oppure 1 MB quando viene passata come un oggetto S3 usando un URL del modello Amazon S3. Tuttavia, durante l'elaborazione CloudFormation aggiorna lo stato temporaneo del modello mentre elabora in serie le macro contenute nel modello. Per questo motivo, le dimensioni del modello durante l'elaborazione possono temporaneamente superare le dimensioni consentite di un modello completamente elaborato. CloudFormation consente un certo buffer per questi modelli in corso di elaborazione. Tuttavia, è opportuno progettare i modelli e le macro tenendo presenti le dimensioni massime consentite per un modello di stack elaborato.

Se CloudFormation restituisce un `Transformation data limit exceeded` errore durante l'elaborazione del modello, significa che il modello ha superato la dimensione massima CloudFormation consentita durante l'elaborazione.

Per risolvere questo problema, valutare se eseguire le seguenti operazioni:
+ Ristrutturate il modello in più modelli per evitare di superare le dimensioni massime per i modelli in corso di elaborazione. Ad esempio:
  + Utilizzare modelli di stack nidificati per incapsulare parti del modello. Per ulteriori informazioni, consulta [Dividi un modello in pezzi riutilizzabili usando stack nidificati](using-cfn-nested-stacks.md).
  + Creare più stack e utilizzare riferimenti tra stack per scambiare informazioni tra loro. Per ulteriori informazioni, consulta [Fai riferimento agli output di risorse in un altro stack CloudFormation](walkthrough-crossstackref.md).
+ Ridurre la dimensione del frammento di modello restituito da una determinata macro. CloudFormation non altera il contenuto dei frammenti restituiti dalle macro.

# Dividi un modello in pezzi riutilizzabili usando stack nidificati
<a name="using-cfn-nested-stacks"></a>

Man mano che la tua infrastruttura cresce, potresti ritrovarti a creare ripetutamente configurazioni di risorse identiche su più modelli. Per evitare questa ridondanza, puoi separare queste configurazioni comuni in modelli dedicati. Poi, puoi utilizzare la risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-stack.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-stack.html) negli altri modelli per fare riferimento a questi modelli dedicati, creando così degli stack nidificati.

Ad esempio, immagina di avere una configurazione del bilanciatore del carico che utilizzi per la maggior parte dei tuoi stack. Invece di copiare e incollare le stesse configurazioni nei modelli, puoi creare un modello dedicato per il sistema di load balancer. Così, puoi fare riferimento a questo modello dall’interno di altri modelli che richiedono la stessa configurazione del bilanciatore del carico.

Gli stack nidificati possono a loro volta contenere altri stack nidificati, generando una gerarchia di stack, come mostrato nel diagramma di seguito. Lo *stack radice* è lo stack di primo livello al quale sostanzialmente appartengono tutti gli stack nidificati. Ciascuno stack nidificato ha un proprio stack padre. Per il primo livello di stack nidificati, lo stack radice è anche lo stack padre. 
+ Lo stack A è lo stack padre per tutti gli altri stack nidificati della gerarchia.
+ Per lo stack B, lo stack A è sia lo stack padre che lo stack radice.
+ Per lo stack D, lo stack C è lo stack padre; mentre per lo stack C, lo stack padre è lo stack B.

![\[Gli stack nidificati creati come parte di un altro stack hanno uno stack padre immediatamente superiore, e uno stack radice di primo livello.\]](http://docs.aws.amazon.com/it_it/AWSCloudFormation/latest/UserGuide/images/cfn-console-nested-stacks.png)


**Topics**
+ [Esempio del prima e dopo della suddivisione di un modello](#create-nested-stack-template)
+ [Esempio di architettura degli stack nidificati](#nested-stack-examples)
+ [Esecuzione di operazioni di stack su stack nidificati](#perform-stack-operations-on-nested-stacks)
+ [Informazioni correlate](#nested-stacks-related-information)

## Esempio del prima e dopo della suddivisione di un modello
<a name="create-nested-stack-template"></a>

Questo esempio dimostra come è possibile prendere un unico CloudFormation modello di grandi dimensioni e riorganizzarlo in un design più strutturato e riutilizzabile utilizzando modelli annidati. Inizialmente, il modello “Before nesting stacks” mostra tutte le risorse definite in un unico file. Questo può diventare complicato e difficile da gestire man mano che il numero di risorse aumenta. Il modello “After nesting stacks” suddivide le risorse in modelli più piccoli e separati. Ogni stack nidificato gestisce un insieme specifico di risorse correlate, rendendo la struttura generale più organizzata e facile da gestire.


| Prima degli stack nidificati | Dopo gli stack nidificati | 
| --- | --- | 
| <pre>AWSTemplateFormatVersion: 2010-09-09<br />Parameters:<br />  InstanceType:<br />    Type: String<br />    Default: t2.micro<br />    Description: The EC2 instance type<br />  <br />  Environment:<br />    Type: String<br />    Default: Production<br />    Description: The deployment environment<br /><br />Resources:<br />  MyEC2Instance:<br />    Type: AWS::EC2::Instance<br />    Properties:<br />      ImageId: ami-1234567890abcdef0<br />      InstanceType: !Ref InstanceType<br /><br />  MyS3Bucket:<br />    Type: AWS::S3::Bucket</pre> | <pre>AWSTemplateFormatVersion: 2010-09-09<br />Resources:<br />  MyFirstNestedStack:<br />    Type: AWS::CloudFormation::Stack<br />    Properties:<br />      TemplateURL: https://s3.amazonaws.com/amzn-s3-demo-bucket/first-nested-stack.yaml<br />      Parameters:<br />        # Pass parameters to the nested stack if needed<br />        InstanceType: t3.micro<br /><br />  MySecondNestedStack:<br />    Type: AWS::CloudFormation::Stack<br />    Properties:<br />      TemplateURL: https://s3.amazonaws.com/amzn-s3-demo-bucket/second-nested-stack.yaml<br />      Parameters:<br />        # Pass parameters to the nested stack if needed<br />        Environment: Testing<br />    DependsOn: MyFirstNestedStack</pre> | 

## Esempio di architettura degli stack nidificati
<a name="nested-stack-examples"></a>

Questa sezione dimostra un’architettura di stack nidificata costituita da uno stack di primo livello che fa riferimento a uno stack nidificato. Lo stack nidificato implementa una funzione Lambda Node.js, riceve il valore di un parametro dallo stack di primo livello e restituisce un output esposto attraverso lo stack di primo livello.

**Topics**
+ [Passaggio 1: crea un modello per lo stack nidificato sul sistema locale](#create-a-nested-stack-template)
+ [Passaggio 2: crea un modello per lo stack di primo livello sul sistema locale](#create-a-nested-stack-parent-template)
+ [Passaggio 3: stack e implementazione dei modelli](#create-a-nested-stack-parent-template)

### Passaggio 1: crea un modello per lo stack nidificato sul sistema locale
<a name="create-a-nested-stack-template"></a>

L’esempio seguente mostra il formato per il modello dello stack nidificato.

#### YAML
<a name="nested-stack-child-example.yaml"></a>

```
 1. AWSTemplateFormatVersion: 2010-09-09
 2. Description: Nested stack template for Lambda function deployment
 3. Parameters:
 4.   MemorySize:
 5.     Type: Number
 6.     Default: 128
 7.     MinValue: 128
 8.     MaxValue: 10240
 9.     Description: Lambda function memory allocation (128-10240 MB)
10. Resources:
11.   LambdaFunction:
12.     Type: AWS::Lambda::Function
13.     Properties:
14.       FunctionName: !Sub "${AWS::StackName}-Function"
15.       Runtime: nodejs18.x
16.       Handler: index.handler
17.       Role: !GetAtt LambdaExecutionRole.Arn
18.       Code:
19.         ZipFile: |
20.           exports.handler = async (event) => {
21.             return {
22.               statusCode: 200,
23.               body: JSON.stringify('Hello from Lambda!')
24.             };
25.           };
26.       MemorySize: !Ref MemorySize
27.   LambdaExecutionRole:
28.     Type: AWS::IAM::Role
29.     Properties:
30.       AssumeRolePolicyDocument:
31.         Version: '2012-10-17'
32.         Statement:
33.           - Effect: Allow
34.             Principal:
35.               Service: lambda.amazonaws.com
36.             Action: sts:AssumeRole
37.       ManagedPolicyArns:
38.         - 'arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole'
39. Outputs:
40.   LambdaArn:
41.     Description: ARN of the created Lambda function
42.     Value: !GetAtt LambdaFunction.Arn
```

### Passaggio 2: crea un modello per lo stack di primo livello sul sistema locale
<a name="create-a-nested-stack-parent-template"></a>

L’esempio seguente mostra il formato del modello di stack di primo livello e la risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-stack.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-stack.html) che fa riferimento allo stack creato nel passaggio precedente.

#### YAML
<a name="nested-stack-parent-example.yaml"></a>

```
 1. AWSTemplateFormatVersion: 2010-09-09
 2. Description: Top-level stack template that deploys a nested stack
 3. Resources:
 4.   NestedStack:
 5.     Type: AWS::CloudFormation::Stack
 6.     Properties:
 7.       TemplateURL: /path_to_template/nested-template.yaml
 8.       Parameters:
 9.         MemorySize: 256
10. Outputs:
11.   NestedStackLambdaArn:
12.     Description: ARN of the Lambda function from nested stack
13.     Value: !GetAtt NestedStack.Outputs.LambdaArn
```

### Passaggio 3: stack e implementazione dei modelli
<a name="create-a-nested-stack-parent-template"></a>

**Nota**  
Quando lavorate con i modelli a livello locale, il AWS CLI **package** comando può aiutarvi a preparare i modelli per la distribuzione. Infatti, gestisce automaticamente il caricamento di artefatti locali su Amazon S3 (`TemplateURL` incluso) e genera un nuovo file del modello con riferimenti aggiornati a queste posizioni S3. Per ulteriori informazioni, consulta [Carica gli artefatti locali in un bucket S3 con AWS CLI](using-cfn-cli-package.md). 

Successivamente, puoi utilizzare il comando [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/package.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/package.html) per caricare il modello nidificato su un bucket Amazon S3.

```
aws cloudformation package \
  --s3-bucket amzn-s3-demo-bucket \
  --template /path_to_template/top-level-template.yaml \
  --output-template-file packaged-template.yaml \
  --output json
```

Il comando genera un nuovo modello nel percorso specificato da `--output-template-file`. Sostituisce il riferimento a `TemplateURL` con la posizione di Amazon S3, come di seguito.

**Modello risultante**

```
AWSTemplateFormatVersion: 2010-09-09
Description: Top-level stack template that deploys a nested stack
Resources:
  NestedStack:
    Type: AWS::CloudFormation::Stack
    Properties:
      TemplateURL: https://s3.us-west-2.amazonaws.com/amzn-s3-demo-bucket/8b3bb7aa7abfc6e37e2d06b869484bed.template
      Parameters:
        MemorySize: 256
Outputs:
  NestedStackLambdaArn:
    Description: ARN of the Lambda function from nested stack
    Value:
      Fn::GetAtt:
      - NestedStack
      - Outputs.LambdaArn
```

Dopo aver eseguito il comando **package**, puoi distribuire il modello elaborato utilizzando il comando [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deploy/](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deploy/). Devi confermare le funzionalità di IAM per gli stack nidificati contenenti le risorse IAM includendo l’opzione `--capabilities`.

```
aws cloudformation deploy \
  --template-file packaged-template.yaml \
  --stack-name stack-name \
  --capabilities CAPABILITY_NAMED_IAM
```

## Esecuzione di operazioni di stack su stack nidificati
<a name="perform-stack-operations-on-nested-stacks"></a>

Quando lavori con stack nidificati, devi gestirli con attenzione durante le operazioni. Alcune operazioni relative agli stack, ad esempio gli aggiornamenti, devono essere avviati dallo stack radice anziché effettuati direttamente sugli stack nidificati. Quando aggiorni uno stack radice, vengono aggiornati solo gli stack nidificati con modifiche al modello. 

Inoltre, la presenza degli stack nidificati può influire sulle operazioni sullo stack radice. Ad esempio, se uno stack nidificato rimane bloccato nello stato `UPDATE_ROLLBACK_IN_PROGRESS`, lo stack radice aspetterà che lo stack nidificato completi il suo rollback prima di continuare. Prima di procedere con le operazioni di aggiornamento, assicurati di disporre delle autorizzazioni IAM per annullare un aggiornamento dello stack in caso di rollback. Per ulteriori informazioni, consulta [Controlla CloudFormation l'accesso con AWS Identity and Access Management](control-access-with-iam.md).

Utilizza le seguenti procedure per trovare lo stack radice e gli stack nidificati.

**Per visualizzare lo stack radice di uno stack nidificato**

1. Accedi Console di gestione AWS e apri la CloudFormation console all'indirizzo [https://console.aws.amazon.com/cloudformazione.](https://console.aws.amazon.com/cloudformation/)

1. Nella pagina **Stack**, seleziona il nome dello stack nidificato di cui desideri visualizzare lo stack radice.

   Gli stack nidificati sono contrassegnati dalla dicitura **NESTED** accanto al nome.

1. Nel riquadro **Informazioni stack**, nella sezione **Panoramica**, seleziona il nome dello stack presente in elenco come **Stack radice**.

**Per visualizzare gli stack nidificati che appartengono a uno stack radice**

1. Dallo stack radice di cui desideri visualizzare gli stack nidificati, seleziona la scheda **Risorse**.

1. Nella colonna **Tipo**, cerca le risorse di tipo. **AWS::CloudFormation::Stack**

## Informazioni correlate
<a name="nested-stacks-related-information"></a>
+ [Nidificazione di uno stack esistente](resource-import-nested-stacks.md)
+ [Comprendere l’aggiornamento dei comportamenti delle risorse stack](using-cfn-updating-stacks-update-behaviors.md)
+ [Continuare il rollback da aggiornamenti non riusciti di stack nidificati](using-cfn-updating-stacks-continueupdaterollback.md#nested-stacks)
+ [Errore di rollback degli stack nidificati](troubleshooting.md#troubleshooting-errors-nested-stacks-are-stuck)

# Creare condizioni di attesa in un CloudFormation modello
<a name="using-cfn-waitcondition"></a>

Questo argomento spiega come creare una condizione di attesa in un modello per coordinare la creazione delle risorse dello stack o per monitorare l’avanzamento di un processo di configurazione. Ad esempio, puoi iniziare la creazione di un'altra risorsa al parziale completamento della configurazione di un'applicazione oppure puoi inviare segnali durante un processo di installazione e configurazione per monitorarne l'avanzamento. 

Quando CloudFormation crea uno stack che include una condizione di attesa:
+ Crea una condizione di attesa proprio come qualsiasi altra risorsa e imposta il relativo stato su `CREATE_IN_PROGRESS`.
+ CloudFormation attende che riceva il numero richiesto di segnali di successo o che il periodo di timeout della condizione di attesa sia scaduto. 
+ Se riceve il numero richiesto di segnali di operazione riuscita prima della scadenza del periodo di timeout:
  + Lo stato della condizione di attesa viene modificato in `CREATE_COMPLETE`.
  + La creazione dello stack continua.
+ Se il timeout scade o viene ricevuto un segnale di errore:
  + Lo stato della condizione di attesa viene modificato in `CREATE_FAILED`.
  + Viene eseguito il rollback dello stack.

**Importante**  
Per le risorse Amazon EC2 e Auto Scaling, consigliamo di utilizzare CreationPolicy un attributo anziché condizioni di attesa. Aggiungi un CreationPolicy attributo a tali risorse e utilizza lo script di supporto cfn-signal per segnalare quando il processo di creazione di un'istanza è stato completato con successo.  
Per ulteriori informazioni, consulta [Attributo CreationPolicy](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-creationpolicy.html).

**Nota**  
Se lo utilizzi AWS PrivateLink, le risorse nel VPC che rispondono alle condizioni di attesa devono avere accesso a bucket Amazon Simple Storage Service (Amazon S3) S3) CloudFormation specifici. Le risorse devono inviare le risposte della condizione di attesa a un URL Amazon S3 prefirmato. Se non sono in grado di inviare risposte per Amazon S3, CloudFormation non riceverà una risposta e il funzionamento dello stack ha esito negativo. Per ulteriori informazioni, consulta le pagine [Accesso CloudFormation tramite un endpoint di interfaccia ()AWS PrivateLink](vpc-interface-endpoints.md) e [Controlling access from VPC endpoints with bucket policies](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-bucket-policies-vpc-endpoint.html).

**Topics**
+ [Creare una condizione di attesa nel modello](#creating-wait-condition)
+ [Sintassi del segnale di condizione di attesa](#wait-condition-signal-syntax)
+ [Accedere ai dati del segnale](#wait-condition-access-signal-data)

## Creare una condizione di attesa nel modello
<a name="creating-wait-condition"></a>

**1. Handle della condizione di attesa**  
Inizia definendo una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-waitconditionhandle.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-waitconditionhandle.html) nel modello dello stack. Questa risorsa genera l’URL prefirmato necessario per l’invio dei segnali, che permette di inviare un segnale senza dover specificare le credenziali AWS . Esempio: 

```
Resources:
  MyWaitHandle:
    Type: AWS::CloudFormation::WaitConditionHandle
```

**2. Condizione di attesa**  
Poi, devi dichiarare una risorsa [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-waitcondition.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-cloudformation-waitcondition.html) nel modello dello stack. La struttura di base di `AWS::CloudFormation::WaitCondition` è come la seguente: 

```
  MyWaitCondition:
    Type: AWS::CloudFormation::WaitCondition
    Properties:
      Handle: String
      Timeout: String
      Count: Integer
```

La risorsa `AWS::CloudFormation::WaitCondition` dispone di due proprietà obbligatorie e una facoltativa.
+ `Handle` (obbligatoria): un riferimento a `WaitConditionHandle` dichiarato nel modello.
+ `Timeout`(obbligatorio): il numero di secondi di attesa CloudFormation per la ricezione del numero richiesto di segnali. `Timeout`è una proprietà con limite minimo, il che significa che il timeout non si verifica prima del tempo specificato, ma può verificarsi poco dopo. Il tempo massimo che puoi specificare è 43200 secondi (12 ore).
+ `Count`(opzionale) — Il numero di segnali di successo che CloudFormation devono essere ricevuti prima di impostare lo stato di quella condizione di attesa su `CREATE_COMPLETE` e riprendere la creazione dello stack. Se non viene specificato, il valore predefinito è 1.

In genere, la condizione di attesa deve iniziare subito dopo la creazione di una risorsa specifica. A tale scopo, aggiungi l'`DependsOn`attributo a una condizione di attesa. Quando aggiungi un `DependsOn` attributo a una condizione di attesa, CloudFormation crea prima la risorsa nell'`DependsOn`attributo, quindi crea la condizione di attesa. Per ulteriori informazioni, consulta [Attributo DependsOn](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-dependson.html).

Il seguente esempio illustra una condizione di attesa che: 
+ Inizia dopo la corretta creazione della risorsa `MyEC2Instance`.
+ Usa la risorsa `MyWaitHandle` come `WaitConditionHandle`.
+ Ha un timeout di 4.500 secondi.
+ Ha un valore predefinito di `Count` pari a 1 (dato che non è specificata alcuna proprietà `Count`)

```
  MyWaitCondition:
    Type: AWS::CloudFormation::WaitCondition
    DependsOn: MyEC2Instance
    Properties:
      Handle: !Ref MyWaitHandle
      Timeout: '4500'
```

**3. Inviare un segnale**  
Per segnalare l'esito positivo o negativo CloudFormation, in genere si esegue un codice o uno script. Ad esempio, un'applicazione in esecuzione su un'istanza EC2 potrebbe eseguire alcune attività di configurazione aggiuntive e quindi inviare un segnale CloudFormation a per indicare il completamento.

Il segnale deve essere inviato all’URL prefirmato generato dall’handle della condizione di attesa. Devi utilizzare l’URL prefirmato per segnalare le operazioni riuscite o non riuscite.

**Per inviare un segnale**

1. Per recuperare l’URL prefirmato all’interno del modello, usa la funzione intrinseca `Ref` con il nome logico dell’handle della condizione di attesa. 

   Come mostrato nell’esempio seguente, il modello può dichiarare un’istanza Amazon EC2 e trasmettere l’URL prefirmato alle istanze EC2 utilizzando la proprietà Amazon EC2 `UserData`. Ciò consente agli script o alle applicazioni in esecuzione su tali istanze di segnalare l'esito positivo o negativo. CloudFormation

   ```
     MyEC2Instance:
       Type: AWS::EC2::Instance
       Properties:
       InstanceType: t2.micro  # Example instance type
       ImageId: ami-055e3d4f0bbeb5878  # Change this as needed (Amazon Linux 2023 in us-west-2)
       UserData:
         Fn::Base64: 
           Fn::Join: 
             - ""
             - - "SignalURL="
               - { "Ref": "MyWaitHandle" }
   ```

   Viene restituito un output `UserData` simile al seguente:

   ```
   SignalURL=https://amzn-s3-demo-bucket.s3.amazonaws.com/....
   ```

   Nota: negli strumenti Console di gestione AWS e nella riga di comando, l'URL predefinito viene visualizzato come ID fisico della risorsa wait condition handle.

1. (Facoltativo) Per rilevare quando lo stack entra nella condizione di attesa, puoi utilizzare uno dei seguenti metodi:
   + Se crei lo stack con le notifiche abilitate, CloudFormation pubblica una notifica per ogni evento dello stack per l'argomento specificato. Se tu o l'applicazione effettua la sottoscrizione a tale argomento, puoi monitorare le notifiche relative all'evento di reazione degli handle delle condizioni di attesa e recuperare l'URL prefirmato dal messaggio di notifica.
   + Puoi anche monitorare gli eventi dello stack utilizzando la Console di gestione AWS, AWS CLI o un SDK.

1. Per inviare un segnale, invia un messaggio di richiesta HTTP utilizzando l'URL prefirmato. Il metodo della richiesta deve essere `PUT` e l'intestazione `Content-Type` deve essere una stringa vuota o deve essere omessa. Il messaggio di richiesta deve essere una struttura JSON con il formato specificato nel [Sintassi del segnale di condizione di attesa](#wait-condition-signal-syntax).

   È necessario inviare il numero di segnali di successo specificati dalla `Count` proprietà per CloudFormation continuare la creazione dello stack. Se il valore della proprietà `Count` è maggiore di 1, il valore `UniqueId` per ogni segnale deve essere univoco per tutti i segnali inviati a una determinata condizione di attesa. Il valore `UniqueId` è una stringa alfanumerica arbitraria.

   Un comando `curl` è un modo per inviare un segnale. L'esempio seguente mostra una riga di comando `curl` che segnala l'operazione riuscita a una condizione di attesa.

   ```
   $ curl -T /tmp/a \
     "https://amzn-s3-demo-bucket.s3.amazonaws.com/arn%3Aaws%3Acloudformation%3Aus-west-2%3A034017226601%3Astack%2Fstack-gosar-20110427004224-test-stack-with-WaitCondition--VEYW%2Fe498ce60-70a1-11e0-81a7-5081d0136786%2FmyWaitConditionHandle?Expires=1303976584&AWSAccessKeyId=AKIAIOSFODNN7EXAMPLE&Signature=ik1twT6hpS4cgNAw7wyOoRejVoo%3D"
   ```

   Il file *`/tmp/a`* contiene la seguente struttura JSON:

   ```
   {
      "Status" : "SUCCESS",
      "Reason" : "Configuration Complete",
      "UniqueId" : "ID1234",
      "Data" : "Application has completed configuration."
   }
   ```

   Questo esempio illustra una riga di comando `curl` che invia lo stesso segnale di operazione riuscita, ma che invia la struttura JSON come parametro alla riga di comando.

   ```
   $ curl -X PUT \
     -H 'Content-Type:' --data-binary '{"Status" : "SUCCESS","Reason" : "Configuration Complete","UniqueId" : "ID1234","Data" : "Application has completed configuration."}' \
     "https://amzn-s3-demo-bucket.s3.amazonaws.com/arn%3Aaws%3Acloudformation%3Aus-west-2%3A034017226601%3Astack%2Fstack-gosar-20110427004224-test-stack-with-WaitCondition--VEYW%2Fe498ce60-70a1-11e0-81a7-5081d0136786%2FmyWaitConditionHandle?Expires=1303976584&AWSAccessKeyId=AKIAIOSFODNN7EXAMPLE&Signature=ik1twT6hpS4cgNAw7wyOoRejVoo%3D"
   ```

## Sintassi del segnale di condizione di attesa
<a name="wait-condition-signal-syntax"></a>

Quando invii segnali all’URL generato dall’handle della condizione di attesa, devi utilizzare il seguente formato JSON:

```
{
  "Status" : "StatusValue",
  "UniqueId" : "Some UniqueId",
  "Data" : "Some Data",
  "Reason" : "Some Reason"
}
```

### Properties
<a name="wait-condition-signal-properties"></a>

Il campo `Status` deve essere uno dei seguenti valori:
+ `SUCCESS`
+ `FAILURE`

Il `UniqueId` campo identifica il segnale a. CloudFormation Se la `Count` proprietà della condizione di attesa è maggiore di 1, il `UniqueId` valore deve essere unico per tutti i segnali inviati per una particolare condizione di attesa; in caso contrario, CloudFormation considererà il segnale una ritrasmissione del segnale inviato in precedenza con lo stesso `UniqueId` e lo ignorerà.

Il campo `Data` può contenere qualsiasi informazione desideri inviare con il segnale. È possibile accedere al `Data` valore utilizzando la GetAtt funzione [Fn::](resources-section-structure.md#resource-properties-getatt) all'interno del modello.

Il campo `Reason` è una stringa senza altre restrizioni relative ai contenuti, oltre alla conformità JSON.

## Accedere ai dati del segnale
<a name="wait-condition-access-signal-data"></a>

Per accedere ai dati inviati da segnali validi, puoi creare un valore di output per la condizione di attesa nel tuo CloudFormation modello. Esempio:

```
Outputs:
  WaitConditionData:
    Description: The data passed back as part of signalling the WaitCondition
    Value: !GetAtt MyWaitCondition.Data
```

È quindi possibile visualizzare questi dati utilizzando il [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-stacks.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/describe-stacks.html)comando o la scheda **Output** della CloudFormation console.

La `Fn::GetAtt` funzione restituisce `UniqueId` e `Data` come name/value coppia all'interno di una struttura JSON. Esempio:

```
{"Signal1":"Application has completed configuration."}
```

# Crea configurazioni di risorse riutilizzabili che possono essere incluse nei modelli con moduli CloudFormation
<a name="modules"></a>

I *moduli* sono un modo per creare pacchetti di configurazioni delle risorse per l’inclusione su modelli di stack, in modo trasparente, gestibile e ripetibile. I moduli possono incapsulare configurazioni di servizio comuni e best practice come blocchi predefiniti modulari e personalizzabili da includere nei modelli di stack. I moduli consentono di includere configurazioni delle risorse che incorporano best practice, conoscenza esperta del settore e linee guida accettate (per ambiti quali sicurezza, conformità, governance e normative di settore) nei modelli, senza dover acquisire una conoscenza approfondita delle complessità dell’implementazione delle risorse.

Ad esempio, un esperto di settore nel settore delle reti potrebbe creare un modulo che contenga gruppi e ingress/egress regole di sicurezza integrati che rispettano le linee guida sulla sicurezza. Potresti quindi includere quel modulo nel tuo modello per fornire un'infrastruttura di rete sicura nel tuo stack, senza dover perdere tempo a capire come funzionano le sottoreti VPCs, i gruppi di sicurezza e i gateway. E poiché i moduli hanno più versioni, se le linee guida di sicurezza cambiano nel tempo, l’autore del modulo può creare una nuova versione che incorpora tali modifiche.

Le caratteristiche dell’utilizzo dei moduli nei modelli includono:
+ **Prevedibilità**: un modulo deve rispettare lo schema che registra nel CloudFormation registro, in modo da sapere in quali risorse può risolversi una volta incluso nel modello.
+ **Riutilizzo**: puoi usare lo stesso modulo su più modelli e account.
+ **Tracciabilità**: CloudFormation conserva la conoscenza di quali risorse di uno stack sono state fornite da un modulo, consentendoti di comprendere facilmente l'origine delle modifiche alle risorse.
+ **Gestibilità**: dopo aver registrato un modulo, è possibile gestirlo tramite il CloudFormation registro, compresi il controllo delle versioni e la disponibilità dell'account e a livello regionale.

Un modulo può contenere:
+ Una o più risorse di cui eseguire il provisioning dal modulo, insieme a tutti i dati associati, come output o condizioni.
+ Qualsiasi parametro del modulo, che consente di specificare valori personalizzati ogni volta che viene utilizzato il modulo.

Per informazioni sullo sviluppo di moduli, consulta [Developing modules](https://docs.aws.amazon.com/cloudformation-cli/latest/userguide/modules.html) nella *CloudFormation CLI User Guide*.

**Topics**
+ [Considerazioni su quando utilizzare i moduli](#module-considerations)
+ [Comprensione del controllo delle versioni dei moduli](module-versioning.md)
+ [Usa i moduli del registro CloudFormation privato](modules-using.md)
+ [Utilizzo dei parametri per specificare i valori dei moduli](module-using-params.md)
+ [Risorse del modulo di riferimento nei CloudFormation modelli](module-ref-resources.md)

## Considerazioni su quando utilizzare i moduli
<a name="module-considerations"></a>
+ L’utilizzo dei moduli non comporta costi supplementari. Si paga solo per le risorse che i moduli risolvono negli stack.
+ CloudFormation le quote, come il numero massimo di risorse consentite in uno stack o la dimensione massima del corpo del modello, si applicano al modello elaborato indipendentemente dal fatto che le risorse incluse in quel modello provengano da moduli o meno. Per ulteriori informazioni, consulta [Comprendi le CloudFormation quote](cloudformation-limits.md).
+ I tag specificati a livello di stack vengono assegnati alle singole risorse derivate dal modulo.
+ Gli script di supporto specificati a livello di modulo non si propagano alle singole risorse contenute nel modulo durante l'elaborazione del modello. CloudFormation 
+ Gli output specificati nel modulo vengono propagati agli output a livello di modello.

  Ad ogni output verrà assegnato un ID logico che è una concatenazione del nome logico del modulo e del nome di output così come definito nel modulo. Per ulteriori informazioni, consulta [Ottieni gli output esportati da uno stack distribuito CloudFormation](using-cfn-stack-exports.md).
+ I parametri specificati nel modulo non vengono propagati ai parametri a livello di modello.

  Tuttavia, è possibile creare parametri a livello di modello che fanno riferimento ai parametri a livello di modulo. Per ulteriori informazioni, consulta [Utilizzo dei parametri per specificare i valori dei moduli](module-using-params.md).

# Comprensione del controllo delle versioni dei moduli
<a name="module-versioning"></a>

Il CloudFormation registro funge da archivio in cui è possibile registrare e gestire i moduli da utilizzare all'interno della propria Account AWS regione. Puoi registrare moduli da varie fonti, tra cui editori di terze parti AWS, e le tue estensioni personalizzate, all'interno del tuo account e della tua regione. Per ulteriori informazioni, consulta [Gestione delle estensioni con il CloudFormation registro](registry.md).

I moduli possono avere versioni diverse, quindi puoi specificare quale versione di un modulo desideri utilizzare. Questa funzionalità di controllo delle versioni è particolarmente utile quando devi aggiornare o modificare un modulo senza interrompere gli stack esistenti che dipendono da esso.

Quando utilizzi più versioni di un modulo, tieni presente le seguenti considerazioni:
+ Durante le operazioni di stack, CloudFormation utilizza qualsiasi versione del modulo attualmente registrata come versione predefinita nella regione Account AWS e nella regione in cui viene eseguita l'operazione di stack. Sono inclusi i moduli che sono nidificati in altri moduli.

  Tenere quindi presente che se si dispone di versioni diverse dello stesso modulo registrate come versione predefinita in account o regioni diversi, l’utilizzo dello stesso modello può comportare risultati diversi.
+ Durante le operazioni di stack, CloudFormation utilizza qualsiasi versione della risorsa attualmente registrata come versione predefinita nella regione Account AWS e nella regione in cui viene eseguita l'operazione di stack. Ciò include le risorse generate includendo i moduli.
+ La modifica della versione predefinita di un modulo non inizia alcuna operazione di aggiornamento stack. Tuttavia, la prossima volta che eseguirete un'operazione di stack con qualsiasi modello contenente quel modulo, ad esempio un aggiornamento dello stack, CloudFormation utilizzerà la nuova versione predefinita nell'operazione.

  L’unica eccezione a ciò è l’esecuzione di un aggiornamento dello stack con l’opzione **usa modello precedente** specificata, come descritto di seguito.
+ Per le operazioni di aggiornamento dello stack, se specificate l'opzione **Usa modello precedente**, CloudFormation utilizza il modello elaborato in precedenza per l'aggiornamento dello stack e non rielabora il modulo per eventuali modifiche che potreste avervi apportato.
+ Per garantire risultati uniformi, se includi moduli in un modello stack da utilizzare con set di stack, devi assicurarti che la stessa versione del modulo sia impostata come versione predefinita in tutti gli account e le Regioni in cui si prevede di distribuire le istanze dello stack. Sono inclusi i moduli che sono nidificati in altri moduli. Per ulteriori informazioni, consulta [Gestione degli stack tra account e regioni con StackSets](what-is-cfnstacksets.md).

## Requisiti per l’attivazione di moduli pubblici di terze parti
<a name="requirements-for-modules"></a>

Per attivare correttamente un modulo pubblico di terze parti nell’account e nella Regione, devono essere rispettati i seguenti requisiti per ogni estensione pubblica di terze parti (risorsa o modulo) inclusa nel modulo:
+ **Attivazione dell’estensione**: l’estensione deve essere attivata nell’account e nella regione in cui desideri utilizzarla. Per ulteriori informazioni, consulta [Usa estensioni pubbliche di terze parti dal CloudFormation registro](registry-public.md).
+ **Registrazione dell’alias**: se l’estensione nel modulo utilizza un alias del nome del tipo, deve essere registrata nell’account e nella Regione utilizzando lo stesso alias del nome del tipo. Per ulteriori informazioni, consulta [Uso degli alias di riferimento alle estensioni](registry-public.md#registry-public-enable-alias).
+ **Compatibilità delle versioni**: la versione dell’estensione attualmente attivata deve essere una delle versioni principali supportate dell’estensione specificata nel modulo.

Se non sono attivate le estensioni pubbliche e le versioni di estensione di terze parti corrette, l'operazione CloudFormation avrà esito negativo con un errore che elenca le estensioni e le versioni che devono essere attivate prima che il modulo possa essere attivato correttamente.

# Usa i moduli del registro CloudFormation privato
<a name="modules-using"></a>

Questo argomento spiega come utilizzare i moduli nei CloudFormation modelli. Pensa ai moduli come a pacchetti di risorse predefiniti che puoi aggiungere ai tuoi modelli.

Per utilizzare un modulo, i passaggi sono i seguenti:
+ **Registrazione del modulo**: i moduli vengono registrati nel CloudFormation registro come estensioni private. Assicurati che siano registrati in Account AWS e nella Regione in cui operi. Per ulteriori informazioni, consulta [CloudFormation concetti di registro](registry-concepts.md).
+ **Includilo nel tuo modello**: aggiungi il modulo alla [Resources](resources-section-structure.md) sezione del CloudFormation modello, proprio come faresti con altre risorse. Dovrai inoltre fornire tutte le proprietà richieste per il modulo.
+ **Crea o aggiorna lo stack**: quando avvii un'operazione di stack, CloudFormation genera un modello elaborato che risolve tutti i moduli inclusi nelle risorse appropriate. 
+ **Visualizza le modifiche in anteprima**: prima di effettuare cambiamenti, puoi utilizzare un set di modifiche per verificare quali risorse verranno aggiunte o modificate. Per ulteriori informazioni, consulta [Aggiorna CloudFormation gli stack utilizzando i set di modifiche](using-cfn-updating-stacks-changesets.md).

Considera il seguente esempio: disponi di un modello che contiene sia risorse che moduli. Il modello contiene una singola risorsa, `ResourceA`, oltre a un modulo, `ModuleParent`. Tale modulo contiene due risorse, `ResourceB` e `ResourceC`, oltre a un modulo nidificato, `ModuleChild`. `ModuleChild` contiene una singola risorsa, `ResourceD`. Se crei uno stack da questo modello, CloudFormation elabora il modello e risolve i moduli nelle risorse appropriate. Lo stack risultante ha quattro risorse: `ResourceA`, `ResourceB`, `ResourceC` e `ResourceD`.

![\[Durante un'operazione di stack, CloudFormation risolve i due moduli inclusi nel modello di stack nelle quattro risorse appropriate.\]](http://docs.aws.amazon.com/it_it/AWSCloudFormation/latest/UserGuide/images/modules-resource-inclusion.png)


CloudFormation tiene traccia di quali risorse in uno stack sono state create dai moduli. Puoi visualizzare queste informazioni nelle schede **Eventi**, **Risorse** e **Derive** per un determinato stack e sono incluse anche nelle anteprime del set di modifiche.

I moduli sono distinguibili dalle risorse di un modello perché adottano la seguente convenzione di denominazione in quattro parti, in contrasto con la classica convenzione in tre parti utilizzata dalle risorse:

```
organization::service::use-case::MODULE
```

# Utilizzo dei parametri per specificare i valori dei moduli
<a name="module-using-params"></a>

In CloudFormation, puoi utilizzare i parametri dei modelli per personalizzare gli stack fornendo valori di input durante la creazione o l'aggiornamento dello stack. Questi parametri consentono di modificare alcuni aspetti dello stack in base alle proprie esigenze. Per ulteriori informazioni sulla definizione dei parametri del modello, consulta [CloudFormation Parameterssintassi del modello](parameters-section-structure.md).

Allo stesso modo, i moduli possono avere anche dei parametri. Questi parametri del modulo consentono di inserire valori personalizzati nel modulo dal modello (o da un altro modulo) che lo utilizza. Il modulo può quindi utilizzare questi valori personalizzati per impostare i valori delle proprietà delle risorse che contiene.

Puoi anche definire i parametri del modello che impostano le proprietà del modulo, in modo che tu possa inserire valori che vengono trasferiti al modulo al momento dell’operazione di stack. 

Se un modulo contiene un modulo nidificato con dei propri parametri del modulo, puoi:
+ specificare i valori dei parametri del modulo nidificato direttamente nel modulo padre;
+ definire i parametri del modulo corrispondenti nel modulo padre che consentono al modello (o modulo) di impostare i parametri del modulo nidificato in cui è contenuto il modulo padre;

## utilizzare dei parametri modello per specificare i valori dei parametri del modulo.
<a name="module-using-params-example-1"></a>

Nell’esempio seguente viene illustrato come definire i parametri del modello che trasferiscono i valori a un modulo.

Questo modello contenente `My::S3::SampleBucket::MODULE` definisce un parametro di modello, `BucketName`, che consente all’utente di specificare un nome bucket S3 durante l’operazione di stack.

```
# Template containing My::S3::SampleBucket::MODULE
Parameters:
  BucketName:
    Description: Name for your sample bucket
    Type: String
Resources:
  MyBucket:
    Type: 'My::S3::SampleBucket::MODULE'
    Properties:
      BucketName: !Ref BucketName
```

## Specifica delle proprietà sulle risorse in un modulo figlio dal modulo padre
<a name="module-using-params-example-2"></a>

Nell’esempio seguente viene illustrato come specificare i valori dei parametri in un modulo nidificato all’interno di un altro modulo.

Questo primo modulo, `My::S3::SampleBucketPrivate::MODULE`, sarà il modulo secondario. Definisce due parametri: `BucketName` e `AccessControl`. I valori specificati per questi parametri vengono utilizzati per specificare le proprietà `BucketName` e `AccessControl` della risorsa `AWS::S3::Bucket` contenuta nel modulo. Di seguito è riportato il frammento del modello per `My::S3::SampleBucketPrivate::MODULE`.

```
# My::S3::SampleBucketPrivate::MODULE
AWSTemplateFormatVersion: 2010-09-09
Description: A sample S3 Bucket with Versioning and DeletionPolicy.
Parameters:
  BucketName:
    Description: Name for the bucket
    Type: String
  AccessControl:
    Description: AccessControl for the bucket
    Type: String
Resources:
  S3Bucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: !Ref BucketName
      AccessControl: !Ref AccessControl
      DeletionPolicy: Retain
      VersioningConfiguration:
        Status: Enabled
```

Successivamente, il modulo precedente è nidificato all’interno di un modulo padre, `My::S3::SampleBucket::MODULE`. Il modulo padre, `My::S3::SampleBucket::MODULE`, imposta i parametri del modulo figlio nei seguenti modi:
+ Imposta il parametro `AccessControl` di `My::S3::SampleBucketPrivate::MODULE` su `Private`.
+ Per `BucketName`, definisce un parametro modulo, che consentirà di specificare il nome del bucket nel modello (o modulo) che contiene `My::S3::SampleBucket::MODULE`.

```
# My::S3::SampleBucket::MODULE
AWSTemplateFormatVersion: 2010-09-09
Description: A sample S3 Bucket. With Private AccessControl.
Parameters:
  BucketName:
    Description: Name for your sample bucket
    Type: String
Resources:
  MyBucket:
    Type: 'My::S3::SampleBucketPrivate::MODULE'
    Properties:
      BucketName: !Ref BucketName
      AccessControl: Private
```

## Specifica dei vincoli per i parametri del modulo
<a name="modules-using-parameters-constraints"></a>

I parametri del modulo non supportano l’imposizione Vincolo. Per eseguire il controllo del vincolo su un parametro del modulo, crea un parametro del modello con i vincoli desiderati. Quindi, fai riferimento a quel parametro del modello nel parametro del tuo modulo. Per ulteriori informazioni sulla definizione dei parametri del modello, consulta [CloudFormation Parameterssintassi del modello](parameters-section-structure.md).

# Risorse del modulo di riferimento nei CloudFormation modelli
<a name="module-ref-resources"></a>

Nei CloudFormation modelli, spesso è necessario impostare le proprietà di una risorsa in base al nome o alla proprietà di un'altra risorsa. Per ulteriori informazioni, consulta [Riferimento delle risorse](resources-section-structure.md#using-cross-resource-references).

Per fare riferimento a una risorsa contenuta in un modulo del CloudFormation modello, è necessario combinare due nomi logici:
+ Il nome logico che hai dato al modulo stesso quando lo hai incluso nel modello.
+ Il nome logico della risorsa specifica all’interno del modulo.

Puoi combinare questi due nomi logici utilizzando o meno un punto (.) tra di loro. Ad esempio, se il nome logico del modulo è `MyModule` e il nome logico della risorsa è `MyBucket`, puoi fare riferimento a tale risorsa come `MyModule.MyBucket` o `MyModuleMyBucket`.

Per trovare i nomi logici delle risorse all'interno di un modulo, puoi consultare lo schema del modulo, disponibile nel CloudFormation registro o utilizzando l'[https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_DescribeType.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_DescribeType.html)operazione. Lo schema elenca tutte le risorse e i relativi nomi logici che fanno parte del modulo.

Una volta ottenuto il nome logico completo, è possibile utilizzare CloudFormation funzioni come `GetAtt` e accedere `Ref` ai valori delle proprietà sulle risorse del modulo. 

Mettiamo, ad esempio, che tu abbia un modulo `My::S3::SampleBucket::MODULE` che contiene una risorsa `AWS::S3::Bucket` con il nome logico `S3Bucket`. Per fare riferimento al nome di questo bucket utilizzando la funzione `Ref`, combina il nome del modulo nel modello (`MyBucket`) con il nome logico della risorsa nel modulo (`S3Bucket`). Il nome logico completo è `MyBucket.S3Bucket` o `MyBucketS3Bucket`.

**Modello di esempio**  
Il modello di esempio seguente crea un bucket S3 utilizzando il modulo `My::S3::SampleBucket::MODULE`. Inoltre, crea una coda Amazon SQS e ne imposta il nome in modo che sia lo stesso del nome del bucket del modulo. Inoltre, il modello genera il nome della risorsa Amazon (ARN) del bucket S3 creato.

```
# Template that uses My::S3::SampleBucket::MODULE
Parameters:
  BucketName:
    Description: Name for your sample bucket
    Type: String
Resources:
  MyBucket:
    Type: My::S3::SampleBucket::MODULE
    Properties:
      BucketName: !Ref BucketName
  exampleQueue:
    Type: AWS::SQS::Queue
    Properties:
      QueueName: !Ref MyBucket.S3Bucket
Outputs:
  BucketArn:
    Value: !GetAtt MyBucket.S3Bucket.Arn
```