Questa è la nuova *Guida di riferimento ai modelli CloudFormation *. Aggiorna i segnalibri e i link. Per informazioni su come iniziare CloudFormation, consulta la [Guida AWS CloudFormation per l'utente](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html).

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

# Attributo `UpdatePolicy`
<a name="aws-attribute-updatepolicy"></a>

Utilizzate l'`UpdatePolicy`attributo per specificare come CloudFormation gestisce gli aggiornamenti di determinate risorse durante le operazioni di aggiornamento dello stack. 

**Topics**
+ [Panoramica di](#aws-resource-update-policies)
+ [WorkSpaces Politica di aggiornamento delle applicazioni](#aws-attribute-update-policy-app-stream-fleet)
+ [AutoScalingReplacingUpdate politica](#cfn-attributes-updatepolicy-replacingupdate)
+ [AutoScalingRollingUpdate politica](#cfn-attributes-updatepolicy-rollingupdate)
+ [AutoScalingScheduledAction politica](#cfn-attributes-updatepolicy-scheduledactions)
+ [UseOnlineResharding politica](#cfn-attributes-updatepolicy-useonlineresharding)
+ [EnableVersionUpgrade politica](#cfn-attributes-updatepolicy-upgradeopensearchdomain)
+ [CodeDeployLambdaAliasUpdate politica](#cfn-attributes-updatepolicy-codedeploylambdaaliasupdate)
+ [Esempi](#aws-attribute-updatepolicy-examples)

## Panoramica di
<a name="aws-resource-update-policies"></a>

Utilizzando l’attributo `UpdatePolicy`, puoi controllare il modo in cui vengono aggiornate le seguenti risorse, come descritto di seguito:
+ **[AWS::AppStream::Fleet](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-appstream-fleet.html)**— CloudFormation può arrestare e avviare un parco istanze, il che comporta la sostituzione delle istanze del parco macchine. In questo modo, a tutte le istanze verranno applicate le modifiche più recenti immediatamente dopo un aggiornamento dello stack.
+ **[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 i gruppi Auto Scaling, è possibile utilizzare uno o più criteri di aggiornamento per controllare la modalità di gestione di determinati CloudFormation aggiornamenti. Queste policy includono:
  + **`AutoScalingReplacingUpdate`e `AutoScalingRollingUpdate` politiche**: CloudFormation possono sostituire il gruppo Auto Scaling e le relative istanze con una `AutoScalingReplacingUpdate` policy oppure sostituire solo le istanze con una policy. `AutoScalingRollingUpdate` Queste operazioni di sostituzione si verificano quando apporti una o più delle seguenti modifiche:
    + Modifica [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) del gruppo Auto Scaling.
    + Modifica la proprietà `VPCZoneIdentifier` del gruppo con scalabilità automatica.
    + Modifica la proprietà `LaunchTemplate` del gruppo con scalabilità automatica.
    + Modifica la proprietà `PlacementGroup` del gruppo con scalabilità automatica.
    + Aggiorna un gruppo Auto Scaling che contiene istanze che non corrispondono all'attuale `LaunchConfiguration`.

    Se sono specificate entrambe le policy, `AutoScalingReplacingUpdate` e `AutoScalingRollingUpdate`, l'impostazione della proprietà `WillReplace` su `true` da la precedenza a `AutoScalingReplacingUpdate`.
  + **`AutoScalingScheduledAction`politica**: questa politica si applica quando si aggiorna uno stack che include un gruppo Auto Scaling con azioni pianificate che ridimensionano il gruppo in momenti specifici. CloudFormation non può modificare la dimensione minima, la dimensione massima o la capacità desiderata del gruppo a meno che non siano state modificate esplicitamente nel modello di stack. Questa policy aiuta a prevenire eventuali aggiornamenti imprevisti che potrebbero interferire con le attività di dimensionamento pianificate.
+ **[https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticache-replicationgroup.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticache-replicationgroup.html)**— CloudFormation può modificare gli shard di un gruppo di replica aggiungendo o rimuovendo shard, anziché sostituire l'intera risorsa. 
+ **[https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-opensearchservice-domain.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-opensearchservice-domain.html)**e **[https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticsearch-domain.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticsearch-domain.html)**(legacy): CloudFormation può aggiornare un dominio di OpenSearch servizio a una nuova versione di Elasticsearch OpenSearch o Elasticsearch senza sostituire l'intera risorsa. 
+ **[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)**— CloudFormation può eseguire una CodeDeploy distribuzione quando la versione cambia sull'alias. 

Le sezioni che seguono descrivono la sintassi e le proprietà dell’attributo `UpdatePolicy` supportato da ogni tipo di risorsa.

## WorkSpaces Politica di aggiornamento delle applicazioni
<a name="aws-attribute-update-policy-app-stream-fleet"></a>

Per interrompere un parco WorkSpaces applicazioni prima di un aggiornamento e riavviarlo dopo un aggiornamento, utilizza la politica di aggiornamento WorkSpaces delle applicazioni. 

### Sintassi
<a name="aws-attribute-update-policy-app-stream-fleet-syntax"></a>

#### JSON
<a name="aws-attribute-update-policy-app-stream-fleet-syntax-json"></a>

```
{
    "UpdatePolicy": {
        "StopBeforeUpdate": {
            "Type": "{{Boolean}}"
        },
        "StartAfterUpdate": {
            "Type": "{{Boolean}}"
        }
    }
}
```

#### YAML
<a name="aws-attribute-update-policy-app-stream-fleet-syntax-yaml"></a>

```
UpdatePolicy:
  StopBeforeUpdate:
    Type: {{Boolean}}
  StartAfterUpdate:
    Type: {{Boolean}}
```

`StopBeforeUpdate`  <a name="cfn-attributes-updatepolicy-replacingupdate-StopBeforeUpdate"></a>
Arresta il parco istanze specificato prima dell'aggiornamento.  
*Obbligatorio:* no

`StartAfterUpdate`  <a name="cfn-attributes-updatepolicy-replacingupdate-StartAfterUpdate"></a>
Avvia il parco istanze specificato dopo l'aggiornamento.  
*Obbligatorio:* no

## AutoScalingReplacingUpdate politica
<a name="cfn-attributes-updatepolicy-replacingupdate"></a>

Per sostituire il gruppo Auto Scaling e le istanze in esso contenute, utilizza la policy `AutoScalingReplacingUpdate`.

Prima di tentare un aggiornamento, assicurati di disporre di capacità Amazon EC2 sufficiente sia per i vecchi che per i nuovi gruppi Auto Scaling.

### Sintassi
<a name="cfn-attributes-updatepolicy-replacingupdate-syntax"></a>

#### JSON
<a name="aws-attribute-updatepolicy-replacingupdate-syntax.json"></a>

```
"UpdatePolicy" : {
  "AutoScalingReplacingUpdate" : {
    "WillReplace" : {{Boolean}}
  }
}
```

#### YAML
<a name="aws-attribute-updatepolicy-replacingupdate-syntax.yaml"></a>

```
UpdatePolicy:
  AutoScalingReplacingUpdate:
    WillReplace: {{Boolean}}
```

### Properties
<a name="cfn-attributes-updatepolicy-replacingupdate-properties"></a>

`WillReplace`  <a name="cfn-attributes-updatepolicy-replacingupdate-willreplace"></a>
Specifica se un gruppo con dimensionamento automatico e le istanze in esso contenute vengono sostituiti durante un aggiornamento. Durante la sostituzione, CloudFormation mantiene il vecchio gruppo fino al termine della creazione di quello nuovo. Se l'aggiornamento fallisce, CloudFormation puoi tornare al vecchio gruppo Auto Scaling ed eliminare il nuovo gruppo Auto Scaling.  
Durante la CloudFormation creazione del nuovo gruppo, non scollega o collega alcuna istanza. Dopo aver creato correttamente il nuovo gruppo Auto Scaling, CloudFormation elimina il vecchio gruppo Auto Scaling durante il processo di pulizia.  
Quando si imposta il parametro `WillReplace`, è necessario specificare un attributo [Attributo `CreationPolicy`](aws-attribute-creationpolicy.md) corrispondente. Se il numero minimo di istanze (specificato dalla `MinSuccessfulInstancesPercent` proprietà) non segnala l'esito positivo entro il `Timeout` periodo specificato nell'`CreationPolicy`attributo, l'aggiornamento sostitutivo non riesce e CloudFormation torna al vecchio gruppo Auto Scaling.  
*Tipo*: Booleano  
*Obbligatorio:* no

## AutoScalingRollingUpdate politica
<a name="cfn-attributes-updatepolicy-rollingupdate"></a>

Per eseguire un aggiornamento in sequenza delle istanze in un gruppo Auto Scaling anziché attendere che le attività di dimensionamento sostituiscano gradualmente le istanze più vecchie con quelle più nuove, utilizza la policy `AutoScalingRollingUpdate`. Questa politica offre la flessibilità di specificare se CloudFormation sostituire le istanze che si trovano in un gruppo di Auto Scaling in batch o tutte contemporaneamente senza sostituire l'intera risorsa. 

Aspetti da considerare quando si utilizza una policy `AutoScalingRollingUpdate`:
+ Quando CloudFormation ripristina un aggiornamento, utilizza la `UpdatePolicy` configurazione specificata nel modello prima dell'aggiornamento dello stack corrente. Ad esempio, si modifica il valore `MaxBatchSize` da 1 a 10 in`UpdatePolicy`, si esegue un aggiornamento dello stack e tale aggiornamento ha esito negativo. CloudFormation utilizzerà 1 come dimensione massima del batch quando esegue il rollback, non 10. Per evitare questo scenario, apporta le modifiche a `UpdatePolicy` in un aggiornamento separato prima di qualsiasi aggiornamento al gruppo Auto Scaling che può avviare aggiornamenti in sequenza.
+ CloudFormation consiglia di specificare la `SuspendProcesses` proprietà per sospendere temporaneamente i processi di Amazon EC2 Auto Scaling che potrebbero interferire con l'aggiornamento continuo e causarne il fallimento. Per ulteriori informazioni, vedi [Come posso aggiornare il mio gruppo Auto Scaling quando aggiorno il mio CloudFormation ](https://repost.aws/knowledge-center/auto-scaling-group-rolling-updates) stack?
+ CloudFormation supporta l'utilizzo degli hook del ciclo di vita di Amazon EC2 Auto Scaling all'avvio o alla chiusura delle istanze. In questo modo puoi eseguire operazioni personalizzate su un’istanza prima che passi allo stato successivo. Per assicurarti che le nuove istanze raggiungano lo stato `InService`, completa l’hook del ciclo di vita con un risultato `CONTINUE` al termine dell’operazione personalizzata. Per impostazione predefinita, se non viene ricevuta alcuna risposta e l’hook del ciclo di vita scade, l’avvio dell’istanza viene considerato non eseguito correttamente e abbandonato. Se nessuna istanza raggiunge lo stato `InService`, l’aggiornamento in sequenza non verrà eseguito correttamente.
+ Le funzionalità di Amazon EC2 Auto Scaling come le politiche di manutenzione delle istanze, le politiche di terminazione e la protezione scalabile non sono disponibili per l'uso con gli aggiornamenti continui. CloudFormation Pianifica i tuoi aggiornamenti in sequenza di conseguenza.
+ Se utilizzate un `AutoScalingRollingUpdate` criterio e rimuovete l'impostazione del gruppo di posizionamento, il gruppo di posizionamento verrà rimosso dal gruppo Auto Scaling e dal CloudFormation modello. Inoltre, ciò attiva un aggiornamento in sequenza, in modo che nuove istanze non vengano avviate in un gruppo di posizionamento.

### Sintassi
<a name="cfn-attributes-updatepolicy-rollingupdate-syntax"></a>

#### JSON
<a name="aws-attribute-updatepolicy-rollingupdate-syntax.json"></a>

```
"UpdatePolicy" : {
  "AutoScalingRollingUpdate" : {
    "MaxBatchSize" : {{Integer}},
    "MinActiveInstancesPercent" : {{Integer}},
    "MinInstancesInService" : {{Integer}},
    "MinSuccessfulInstancesPercent" : {{Integer}},
    "PauseTime" : {{String}},
    "SuspendProcesses" : [ {{List of processes}} ],
    "WaitOnResourceSignals" : {{Boolean}}
  }
}
```

#### YAML
<a name="aws-attribute-updatepolicy-rollingupdate-syntax.yaml"></a>

```
UpdatePolicy:
  AutoScalingRollingUpdate:
    MaxBatchSize: {{Integer}}
    MinActiveInstancesPercent: {{Integer}}
    MinInstancesInService: {{Integer}}
    MinSuccessfulInstancesPercent: {{Integer}}
    PauseTime: {{String}}
    SuspendProcesses:
      - {{List of processes}}
    WaitOnResourceSignals: {{Boolean}}
```

### Properties
<a name="aws-attribute-updatepolicy-rollingupdate-properties"></a>

`MaxBatchSize`  <a name="cfn-attributes-updatepolicy-rollingupdate-maxbatchsize"></a>
Specifica il numero massimo di istanze che possono essere sostituite contemporaneamente.  
*Default*: `1`  
*Maximum*: `100`  
*Tipo*: integer  
*Obbligatorio:* no

`MinActiveInstancesPercent`  <a name="cfn-attributes-updatepolicy-rollingupdate-minactiveinstancespercent"></a>
Specifica la percentuale di istanze in un gruppo Auto Scaling che devono trovarsi nello stato `InService` relativo alla capacità desiderata di tale gruppo durante un aggiornamento in sequenza affinché un aggiornamento venga completato correttamente. È possibile specificare un valore compreso tra 0 e 100. CloudFormation arrotonda al decimo di percentuale più vicino. Ad esempio, se aggiorni cinque istanze con una percentuale di `InService` minima di 50, almeno tre istanze devono essere nello stato `InService`. Se un'istanza non passa allo `InService` stato entro un periodo di tempo fisso di 1 ora, si CloudFormation presuppone che l'istanza non sia stata aggiornata.  
L’impostazione di `MinActiveInstancesPercent` nella `UpdatePolicy` influirà anche sulle istanze avviate quando la proprietà `DesiredCapacity` della risorsa `AWS::AutoScaling::AutoScalingGroup` è impostata su un valore superiore alla capacità attualmente desiderata per quel gruppo Auto Scaling.  
*Default*: `100`  
*Tipo*: integer  
*Obbligatorio:* no

`MinInstancesInService`  <a name="cfn-attributes-updatepolicy-rollingupdate-mininstancesinservice"></a>
Speciifica il numero minimo di istanze che devono essere in servizio all'interno del gruppo Auto Scaling CloudFormation durante l'aggiornamento delle vecchie istanze. Questo valore deve essere inferiore a [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html#cfn-autoscaling-autoscalinggroup-maxsize](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html#cfn-autoscaling-autoscalinggroup-maxsize) del gruppo Auto Scaling.  
Consigliamo di impostare il valore della proprietà `MinInstancesInService` ad almeno [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html#cfn-autoscaling-autoscalinggroup-minsize](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html#cfn-autoscaling-autoscalinggroup-minsize) del gruppo Auto Scaling. In questo modo si evitano potenziali problemi di disponibilità durante un aggiornamento in sequenza dovuti al fatto che 0 istanze servono il traffico dei clienti. 
*Default*: `0`  
*Tipo*: integer  
*Obbligatorio:* no

`MinSuccessfulInstancesPercent`  <a name="cfn-attributes-updatepolicy-rollingupdate-minsuccessfulinstancespercent"></a>
Specifica la percentuale di istanze in un aggiornamento in sequenza Auto Scaling che devono essere segnalate come riuscite perché un aggiornamento riesca. È possibile specificare un valore compreso tra 0 e 100. CloudFormationarrotonda al decimo di percentuale più vicino. Ad esempio, se aggiorni cinque istanze con una percentuale di riuscita minima pari a `50`, tre istanze devono inviare segnali di successo. Se un'istanza non invia un segnale entro il tempo specificato nella `PauseTime` proprietà, CloudFormation presuppone che l'istanza non sia stata aggiornata.  
Consigliamo di impostare il valore della proprietà `MinSuccessfulInstancesPercent` su un valore maggiore di 0. Quando la `MinSuccessfulInstancesPercent` proprietà è impostata su 0, CloudFormation attende che lo 0% delle istanze con capacità si trovi in uno stato. `InService` `MinSuccessfulInstancesPercent`ritorna immediatamente e prima di considerare lo stato del gruppo Auto Scaling `UPDATE_COMPLETE` per passare alle risorse successive definite nel modello di stack. Se nel CloudFormation modello sono definiti altri gruppi di Auto Scaling, questi verranno aggiornati contemporaneamente. Quando tutti i gruppi con scalabilità automatica vengono implementati contemporaneamente con lo 0% delle istanze di capacità in uno stato `InService`, si verificano problemi di disponibilità, in quanto 0 istanze gestiscono il traffico dei clienti.  
*Default*: `100`  
*Tipo*: integer  
*Obbligatorio:* no

`PauseTime`  <a name="cfn-attributes-updatepolicy-rollingupdate-pausetime"></a>
La quantità di tempo che intercorre dopo aver apportato una modifica a un batch di istanze per dare a tali istanze il tempo di avviare le CloudFormation applicazioni software.   
Specificate `PauseTime` il [formato della ISO8601 durata](https://en.wikipedia.org/wiki/ISO_8601#Durations) (nel formato`PT{{#}}H{{#}}M{{#}}S`, dove ciascuno {{\#}} corrisponde rispettivamente al numero di ore, minuti e secondi). Il valore massimo di `PauseTime` è 1 ora (`PT1H`).  
Quando `WaitOnResourceSignals` è impostato su `true`, `PauseTime` funge da valore di timeout. Determina il tempo massimo di CloudFormation attesa per ricevere il numero richiesto di segnali validi dalle istanze sostituite durante un aggiornamento continuo e dalle nuove istanze aggiunte aumentando la [https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html#cfn-autoscaling-autoscalinggroup-desiredcapacity](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-autoscaling-autoscalinggroup.html#cfn-autoscaling-autoscalinggroup-desiredcapacity)proprietà della risorsa. `AWS::AutoScaling::AutoScalingGroup` Se `PauseTime` viene superato prima che CloudFormation riceva i segnali previsti, l'aggiornamento fallisce. Per ottenere risultati ottimali, specifica un periodo di tempo sufficiente a consentire l’avvio delle applicazioni. Se deve essere eseguito il rollback dell'aggiornamento, un `PauseTime` breve può comprometterne la riuscita.
*Impostazione predefinita*: `PT5M` (5 minuti) quando la proprietà `WaitOnResourceSignals` è impostata su `true`. In caso contrario, non viene impostato alcun valore predefinito.   
▬*Tipo:* stringa  
*Obbligatorio:* no

`SuspendProcesses`  <a name="cfn-attributes-updatepolicy-rollingupdate-suspendprocesses"></a>
Specifica i processi Auto Scaling da sospendere durante un aggiornamento dello stack. La sospensione dei processi impedisce ad Auto Scaling interferire con un aggiornamento dello stack. Ad esempio, è possibile sospendere la generazione di allarmi in modo che Amazon EC2 Auto Scaling non esegua le policy di dimensionamento associate a un allarme. Per i valori validi, consulta [Tipi di processi](https://docs.aws.amazon.com/autoscaling/ec2/userguide/as-suspend-resume-processes.html#process-types) nella *Guida per l’utente di Amazon EC2 Auto Scaling*.  
*Impostazione predefinita*: non specificato  
*Tipo*: elenco di processi Auto Scaling  
*Obbligatorio:* no

`WaitOnResourceSignals`  <a name="cfn-attributes-updatepolicy-rollingupdate-waitonresourcesignals"></a>
Speciifica se CloudFormation attende i segnali di successo provenienti da nuove istanze prima di continuare l'aggiornamento. CloudFormation attende i segnali di successo per la `PauseTime` durata specificata.  
Per l’invio del segnale al gruppo Auto Scaling, utilizza lo script helper [cfn-signal](cfn-signal.md). Per i gruppi Auto Scaling associati a Elastic Load Balancing, prendi in considerazione l’aggiunta di un controllo dell’integrità per garantire che le istanze siano integre prima di segnalare il completamento utilizzando lo script helper [cfn-init](cfn-init.md). [Per un esempio, consulta il `verify_instance_health` comando nei modelli di esempio per gli aggiornamenti GitHub di Amazon EC2 Auto Scaling nel nostro repository.](https://github.com/aws-cloudformation/aws-cloudformation-templates/tree/main/AutoScaling)  
*Default*: `false`  
*Tipo*: Booleano  
*Obbligatorio:* condizionale. Se specifichi la proprietà `MinSuccessfulInstancesPercent`, devi impostare la proprietà `WaitOnResourceSignals` su `true`.

## AutoScalingScheduledAction politica
<a name="cfn-attributes-updatepolicy-scheduledactions"></a>

Per specificare come CloudFormation gestisce gli aggiornamenti per `MinSize``MaxSize`, e `DesiredCapacity` le proprietà quando alla `AWS::AutoScaling::AutoScalingGroup` risorsa è associata un'azione pianificata, utilizza la `AutoScalingScheduledAction` politica.

Con le operazioni programmate, le proprietà delle dimensioni dei gruppi per un gruppo con dimensionamento automatico possono variare in qualsiasi momento. Quando aggiorni uno stack con un gruppo Auto Scaling e un'azione pianificata CloudFormation , imposta sempre i valori delle proprietà delle dimensioni del gruppo del gruppo Auto Scaling sui valori definiti nella risorsa `AWS::AutoScaling::AutoScalingGroup` del modello, anche se è in corso un'azione pianificata.

Se non desideri modificare nessuno dei valori delle proprietà relative CloudFormation alla dimensione del gruppo quando hai in corso un'azione pianificata, utilizza il criterio di `AutoScalingScheduledAction` aggiornamento e imposta in modo CloudFormation da `IgnoreUnmodifiedGroupSizeProperties` `true` evitare di modificare le `DesiredCapacity` proprietà `MinSize``MaxSize`, o a meno che tu non abbia modificato questi valori nel tuo modello.



### Sintassi
<a name="cfn-attributes-updatepolicy-scheduledactions-syntax"></a>

#### JSON
<a name="aws-attribute-updatepolicy-scheduledactions-syntax.json"></a>

```
"UpdatePolicy" : {
  "AutoScalingScheduledAction" : {
    "IgnoreUnmodifiedGroupSizeProperties" : {{Boolean}}
  }
}
```

#### YAML
<a name="aws-attribute-updatepolicy-scheduledactions-syntax.yaml"></a>

```
UpdatePolicy:
  AutoScalingScheduledAction:
    IgnoreUnmodifiedGroupSizeProperties: {{Boolean}}
```

### Properties
<a name="cfn-attributes-updatepolicy-scheduledactions-properties"></a>

`IgnoreUnmodifiedGroupSizeProperties`  <a name="cfn-attributes-updatepolicy-scheduledactions-ignoreunmodifiedgroupsizeproperties"></a>
If`true`, CloudFormation ignora le differenze nelle proprietà delle dimensioni del gruppo tra il gruppo Auto Scaling corrente e il gruppo Auto Scaling descritto nella risorsa del modello durante un aggiornamento `AWS::AutoScaling::AutoScalingGroup` dello stack. Se modifichi uno qualsiasi dei valori della proprietà della dimensione del gruppo nel modello, CloudFormation utilizza i valori modificati e aggiorna il gruppo con scalabilità automatica.  
Questa proprietà viene ignorata durante un rollback dello stack.
*Default*: `false`  
*Tipo*: Booleano  
*Obbligatorio:* no

## UseOnlineResharding politica
<a name="cfn-attributes-updatepolicy-useonlineresharding"></a>

Per modificare shard del gruppo di replica aggiungendo o rimuovendo shard, anziché sostituendo l’intera risorsa [AWS::ElastiCache::ReplicationGroup](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticache-replicationgroup.html), utilizza la policy di aggiornamento `UseOnlineResharding`.

Se `UseOnlineResharding` è impostato su`true`, è possibile aggiornare le `NodeGroupConfiguration` proprietà `NumNodeGroups` e della `AWS::ElastiCache::ReplicationGroup` risorsa e tali proprietà CloudFormation verranno aggiornate senza interruzioni. Quando `UseOnlineResharding` è impostato `false` su o non è specificato, l'aggiornamento delle `NodeGroupConfiguration` proprietà `NumNodeGroups` and comporta la CloudFormation sostituzione dell'intera `AWS::ElastiCache::ReplicationGroup` risorsa.

La policy di aggiornamento `UseOnlineResharding` non ha proprietà.

Aspetti da considerare quando si imposta la policy di aggiornamento `UseOnlineResharding` su `true`:
+ Ti consigliamo di eseguire gli aggiornamenti alle proprietà `NumNodeGroups` e `NodeGroupConfiguration` come unici aggiornamenti in una determinata operazione di aggiornamento dello stack.

  L'aggiornamento della configurazione del gruppo di nodi di un gruppo di replica è un'operazione che richiede un uso intensivo delle risorse. Se un aggiornamento dello stack fallisce, CloudFormation non ripristina le modifiche alla configurazione del gruppo di nodi di un gruppo di replica. Tuttavia, CloudFormation ripristinerà tutte le altre proprietà che sono state modificate come parte dell'operazione di aggiornamento non riuscita.
+ Qualsiasi aggiornamento di gruppo di nodi richiede l'identificazione di tutti i gruppi di nodi.

  Se si specifica la `NodeGroupConfiguration` proprietà, è necessario specificare anche la configurazione NodeGroupId per ogni gruppo di nodi per CloudFormation aggiornare il numero di nodi senza interruzioni.

  Quando si crea un gruppo di replica, se non si specifica un ID per ciascun gruppo di nodi, ElastiCache genera automaticamente un ID per ciascun gruppo di nodi. Per aggiornare il gruppo di replica senza interruzioni, utilizzate la ElastiCache console ([https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)) o [DescribeReplicationGroups](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeReplicationGroups.html)recuperate il file IDs per tutti i gruppi di nodi del gruppo di replica. Quindi specifica l'ID per ciascun gruppo di nodi nel tuo modello di stack prima di tentare di aggiungere o rimuovere shard.
**Nota**  
Come best practice, quando crei un gruppo di replica in un modello di stack, includi un ID per ciascun gruppo di nodi specificato.

  Inoltre, l'aggiornamento del numero di nodi senza interruzioni richiede che tu abbia specificato con precisione le proprietà `PrimaryAvailabilityZone`, `ReplicaAvailabilityZones` e `ReplicaCount` per ciascun `NodeGroupConfiguration` . Anche in questo caso, potete utilizzare la ElastiCache console ([https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)) o [DescribeReplicationGroups](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeReplicationGroups.html)recuperare i valori effettivi per ogni gruppo di nodi e confrontarli con i valori del modello di stack. Puoi aggiornare i valori di proprietà del gruppo di nodi come aggiornamento dello stack separato oppure come parte dello stesso aggiornamento dello stack che modifica il numero dei gruppi di nodi.

  Quando utilizzate una politica di `UseOnlineResharding` aggiornamento per aggiornare il numero di gruppi di nodi senza interruzioni, distribuisce ElastiCache uniformemente gli spazi chiave tra il numero di slot specificato. Questo non può essere aggiornato in seguito. Pertanto, dopo l'aggiornamento del numero dei gruppi di nodi in questo modo, devi rimuovere il valore specificato per la proprietà `Slots` di ciascuna `NodeGroupConfiguration` dal modello dello stack, in quanto non riflette più i valori effettivi in ciascun gruppo di nodi.
+ I risultati effettivi della rimozione del gruppo di nodi potrebbero variare

  Quando si specifica un `NumNodeGroups` valore inferiore al numero corrente di gruppi di nodi, CloudFormation indica di ElastiCache rimuovere tutti i gruppi di nodi necessari per raggiungere il numero di nodi specificato. Tuttavia, ElastiCache potrebbe non essere sempre possibile rimuovere il numero desiderato di gruppi di nodi. Nel caso in cui non sia ElastiCache possibile rimuovere il numero desiderato di gruppi di nodi, CloudFormation genera un evento stack che avvisa l'utente in merito. Nei casi in cui non è ElastiCache possibile rimuovere *alcun* gruppo di nodi, l'aggiornamento delle CloudFormation risorse non riesce.

Per ulteriori informazioni sulla modifica dei gruppi di replica, consulta [ModifyReplicationGroupShardConfiguration](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyReplicationGroupShardConfiguration.html)*Amazon ElastiCache API* Reference.

### Sintassi
<a name="cfn-attributes-updatepolicy-useonlineresharding-syntax"></a>

#### JSON
<a name="cfn-attributes-updatepolicy-useonlineresharding-syntax.json"></a>

```
"UpdatePolicy" : {
  "UseOnlineResharding" : {{Boolean}}
}
```

#### YAML
<a name="cfn-attributes-updatepolicy-useonlineresharding-syntax.yaml"></a>

```
UpdatePolicy:
  UseOnlineResharding: {{Boolean}}
```

## EnableVersionUpgrade politica
<a name="cfn-attributes-updatepolicy-upgradeopensearchdomain"></a>

Per aggiornare un dominio di OpenSearch servizio a una nuova versione di OpenSearch Elasticsearch anziché sostituire l'intera [AWS::OpenSearchService::Domain[AWS::Elasticsearch::Domain](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticsearch-domain.html)](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-opensearchservice-domain.html)risorsa, utilizza la politica di `EnableVersionUpgrade` aggiornamento.

Se `EnableVersionUpgrade` è impostato su`true`, puoi aggiornare la `EngineVersion` proprietà della `AWS::OpenSearchService::Domain` risorsa (o la `ElasticsearchVersion` proprietà della `AWS::Elasticsearch::Domain` risorsa precedente) e CloudFormation aggiornerai tale proprietà senza interruzioni. Quando `EnableVersionUpgrade` è impostato su`false`, o non è specificato, l'aggiornamento della `ElasticsearchVersion` proprietà `EngineVersion` o comporta la CloudFormation sostituzione dell'intera `AWS::Elasticsearch::Domain` risorsa`AWS::OpenSearchService::Domain`/.

La policy di aggiornamento `EnableVersionUpgrade` non ha proprietà.

Per ulteriori informazioni, consulta [Upgrading OpenSearch Service domains nella Amazon OpenSearch Service](https://docs.aws.amazon.com/opensearch-service/latest/developerguide/version-migration.html) Developer Guide.

### Sintassi
<a name="cfn-attributes-updatepolicy-upgradeopensearchdomain-syntax"></a>

#### JSON
<a name="cfn-attributes-updatepolicy-upgradeopensearchdomain-syntax.json"></a>

```
"UpdatePolicy" : {
  "EnableVersionUpgrade" : {{Boolean}}
}
```

#### YAML
<a name="cfn-attributes-updatepolicy-upgradeopensearchdomain-syntax.yaml"></a>

```
UpdatePolicy:
  EnableVersionUpgrade: {{Boolean}}
```

## CodeDeployLambdaAliasUpdate politica
<a name="cfn-attributes-updatepolicy-codedeploylambdaaliasupdate"></a>

Per eseguire una CodeDeploy distribuzione quando la versione cambia su una `AWS::Lambda::Alias` risorsa, utilizza la politica di `CodeDeployLambdaAliasUpdate` aggiornamento.

### Sintassi
<a name="cfn-attributes-updatepolicy-codedeploylambdaaliasupdate-syntax"></a>

#### JSON
<a name="aws-attribute-updatepolicy-codedeploylambdaaliasupdate-syntax.json"></a>

```
"UpdatePolicy" : {
  "CodeDeployLambdaAliasUpdate" : {
    "AfterAllowTrafficHook" : {{String}},
    "ApplicationName" : {{String}},
    "BeforeAllowTrafficHook" : {{String}},
    "DeploymentGroupName" : {{String}}
  }
}
```

#### YAML
<a name="aws-attribute-updatepolicy-codedeploylambdaaliasupdate-syntax.yaml"></a>

```
UpdatePolicy:
  CodeDeployLambdaAliasUpdate:
    AfterAllowTrafficHook: {{String}}
    ApplicationName: {{String}}
    BeforeAllowTrafficHook: {{String}}
    DeploymentGroupName: {{String}}
```

### Properties
<a name="aws-attribute-updatepolicy-codedeploylambdaaliasupdate-properties"></a>

`AfterAllowTrafficHook`  <a name="cfn-attributes-updatepolicy-codedeploylambdaaliasupdate-afterallowtraffichook"></a>
Il nome della funzione Lambda da eseguire dopo il completamento dell'instradamento del traffico.  
*Required*: No  
▬*Tipo:* stringa

`ApplicationName`  <a name="cfn-attributes-updatepolicy-codedeploylambdaaliasupdate-applicationname"></a>
Il nome dell' CodeDeploy applicazione.  
*Obbligatorio:* sì  
▬*Tipo:* stringa

`BeforeAllowTrafficHook`  <a name="cfn-attributes-updatepolicy-codedeploylambdaaliasupdate-beforeallowtraffichook"></a>
Il nome della funzione Lambda da eseguire prima dell'inizio dell'instradamento del traffico.  
*Required*: No  
▬*Tipo:* stringa

`DeploymentGroupName`  <a name="cfn-attributes-updatepolicy-codedeploylambdaaliasupdate-deploymentgroupname"></a>
Il nome del gruppo CodeDeploy di distribuzione. È dove viene impostata la policy di trasferimento del traffico.  
*Obbligatorio:* sì  
▬*Tipo:* stringa

Per un esempio che specifica l'attributo `UpdatePolicy` per una risorsa `AWS::Lambda::Alias`, consulta [Policy di aggiornamento dell'alias Lambda](#aws-resource-lambda-alias-example).

## Esempi
<a name="aws-attribute-updatepolicy-examples"></a>

I seguenti esempi mostrano come aggiungere una policy di aggiornamento a un gruppo con dimensionamento automatico e come garantire la disponibilità durante l'aggiornamento dei metadati.

### Aggiunta di una `UpdatePolicy` a un gruppo con scalabilità automatica
<a name="aws-attribute-updatepolicy-example-1"></a>

Il seguente esempio mostra come aggiungere una policy di aggiornamento. Durante un aggiornamento, il gruppo con dimensionamento automatico aggiorna le istanze in batch di due e mantiene in servizio almeno un'istanza. Poiché il flag `WaitOnResourceSignals` è impostato, il gruppo con dimensionamento automatico attende nuove istanze che vengono aggiunte al gruppo. Le nuove istanze devono inviare il segnale al gruppo con dimensionamento automatico prima che aggiorni il batch di istanze successivo.

#### JSON
<a name="attribute-updatepolicy-example-1.json"></a>

```
"ASG" : {
  "Type":"AWS::AutoScaling::AutoScalingGroup",
  "Properties":{
    "VPCZoneIdentifier":[ "{{subnetIdAz1}}", "{{subnetIdAz2}}", "{{subnetIdAz3}}" ],
    "LaunchTemplate":{
      "LaunchTemplateId":{
        "Ref":"{{logicalName}}"
      },
      "Version":{
        "Fn::GetAtt":[
          "{{logicalName}}",
          "LatestVersionNumber"
        ]
      }
    },
    "MaxSize":"4",
    "MinSize":"1"
  },
  "UpdatePolicy":{
    "AutoScalingScheduledAction":{
      "IgnoreUnmodifiedGroupSizeProperties":"true"
    },
    "AutoScalingRollingUpdate":{
      "MinInstancesInService":"1",
      "MaxBatchSize":"2",
      "WaitOnResourceSignals":"true",
      "PauseTime":"PT10M",
      "SuspendProcesses":[
        "HealthCheck",
        "ReplaceUnhealthy",
        "AZRebalance",
        "AlarmNotification",
        "ScheduledActions",
        "InstanceRefresh"
      ]
    }
  }
}
```

#### YAML
<a name="attribute-updatepolicy-example-1.yaml"></a>

```
ASG:
  Type: AWS::AutoScaling::AutoScalingGroup
  Properties:
    VPCZoneIdentifier:
      - {{subnetIdAz1}}
      - {{subnetIdAz2}}
      - {{subnetIdAz3}}
    LaunchTemplate:
      LaunchTemplateId: !Ref {{logicalName}}
      Version: !GetAtt {{logicalName}}.LatestVersionNumber
    MaxSize: '4'
    MinSize: '1'
  UpdatePolicy:
    AutoScalingScheduledAction:
      IgnoreUnmodifiedGroupSizeProperties: 'true'
    AutoScalingRollingUpdate:
      MinInstancesInService: '1'
      MaxBatchSize: '2'
      WaitOnResourceSignals: 'true'
      PauseTime: PT10M
      SuspendProcesses:
        - HealthCheck
        - ReplaceUnhealthy
        - AZRebalance
        - AlarmNotification
        - ScheduledActions
        - InstanceRefresh
```

### AutoScalingReplacingUpdate politica
<a name="attribute-updatepolicy-AutoScalingReplacingUpdate"></a>

Nell'esempio seguente viene dichiarata una policy che impone la sostituzione di un gruppo con dimensionamento automatico associato durante un aggiornamento. Perché l'aggiornamento riesca, una percentuale di istanze (specificata dal parametro `MinSuccessfulPercentParameter` ) deve segnalare l'esito positivo entro il periodo `Timeout`.

#### JSON
<a name="attribute-updatepolicy-example-2.json"></a>

```
"UpdatePolicy" : {
  "AutoScalingReplacingUpdate" : {
    "WillReplace" : true
  }
},
"CreationPolicy" : {
  "ResourceSignal" : {
    "Count" : { "Ref" : "ResourceSignalsOnCreate"},
    "Timeout" : "PT10M"
  },
  "AutoScalingCreationPolicy" : {
    "MinSuccessfulInstancesPercent" : { "Ref" : "MinSuccessfulPercentParameter" }
  }
}
```

#### YAML
<a name="attribute-updatepolicy-example-2.yaml"></a>

```
UpdatePolicy:
  AutoScalingReplacingUpdate:
    WillReplace: true
CreationPolicy:
  ResourceSignal:
    Count: !Ref 'ResourceSignalsOnCreate'
    Timeout: PT10M
  AutoScalingCreationPolicy:
    MinSuccessfulInstancesPercent: !Ref 'MinSuccessfulPercentParameter'
```

### Disponibilità durante l'aggiornamento dei metadati per lo script helper cfn-init
<a name="aws-attribute-updatepolicy-cfn-init-metadata"></a>

Quando installi applicazioni software sulle tue istanze, puoi utilizzare la chiave [`AWS::CloudFormation::Init`](aws-resource-init.md) dei metadati e lo script di [cfn-init](cfn-init.md) supporto per avviare le istanze nel tuo gruppo Auto Scaling. CloudFormation installa i pacchetti, esegue i comandi ed esegue altre azioni di bootstrap descritte nei metadati.

Quando si aggiornano solo i metadati (ad esempio, quando si aggiorna un pacchetto a un'altra versione), è possibile utilizzare il daemon assistente [cfn-hup](cfn-hup.md) per rilevare e applicare gli aggiornamenti. Tuttavia, il daemon `cfn-hup` viene eseguito in modo indipendente su ciascuna istanza. Se il daemon viene eseguito contemporaneamente su tutte le istanze, l'applicazione o il servizio potrebbe non essere disponibile durante l'aggiornamento. Per garantire la disponibilità, puoi forzare un aggiornamento periodico in modo che CloudFormation aggiorni le istanze un batch alla volta.

**Importante**  
Per forzare un aggiornamento continuo CloudFormation è necessario creare una nuova istanza e quindi eliminare quella precedente. Le informazioni memorizzate nell'istanza precedente andranno perse.

Per forzare un aggiornamento continuo, modifica l'ID logico della risorsa di configurazione di avvio, quindi aggiorna lo stack e tutti i riferimenti che puntano all'ID logico originale (come il gruppo Auto Scaling associato). CloudFormation attiva un aggiornamento continuo nel gruppo Auto Scaling, sostituendo tutte le istanze.

### Modello originale
<a name="aws-attribute-updatepolicy-cfn-init-metadata-original"></a>

```
"LaunchConfig": {
  "Type" : "AWS::AutoScaling::LaunchConfiguration",
  "Metadata" : {
    "Comment" : "Install a simple PHP application",
    "AWS::CloudFormation::Init" : {
    ...
    }
  }
}
```

### ID logico aggiornato
<a name="aws-attribute-updatepolicy-cfn-init-metadata-updated"></a>

```
"LaunchConfigUpdateRubygemsPkg": {
  "Type" : "AWS::AutoScaling::LaunchConfiguration",
  "Metadata" : {
    "Comment" : "Install a simple PHP application",
    "AWS::CloudFormation::Init" : {
    ...
    }
  }
}
```

### Policy di aggiornamento dell'alias Lambda
<a name="aws-resource-lambda-alias-example"></a>

Nell'esempio seguente viene specificato l'attributo `UpdatePolicy` per una risorsa `AWS::Lambda::Alias`. Tutti i dettagli per la distribuzione sono definiti dall'applicazione e dal gruppo di distribuzione trasferiti nella policy.

#### JSON
<a name="aws-attribute-updatepolicy-codedeploylambda.json"></a>

```
"Alias": {
  "Type": "AWS::Lambda::Alias",
  "Properties": {
    "FunctionName": {
      "Ref": "LambdaFunction"
    },
    "FunctionVersion": {
      "Fn::GetAtt": [
        "FunctionVersionTwo",
        "Version"
      ]
    },
    "Name": "MyAlias"
  },
  "UpdatePolicy": {
    "CodeDeployLambdaAliasUpdate": {
      "ApplicationName": {
        "Ref": "CodeDeployApplication"
      },
      "DeploymentGroupName": {
        "Ref": "CodeDeployDeploymentGroup"
      },
      "BeforeAllowTrafficHook": {
        "Ref": "PreHookLambdaFunction"
      },
      "AfterAllowTrafficHook": {
        "Ref": "PreHookLambdaFunction"
      }
    }
  }
}
```

#### YAML
<a name="aws-attribute-updatepolicy-codedeploylambda-example.yaml"></a>

```
Alias:
  Type: AWS::Lambda::Alias
  Properties:
    FunctionName: !Ref LambdaFunction
    FunctionVersion: !GetAtt FunctionVersionTwo.Version
    Name: MyAlias
  UpdatePolicy:
    CodeDeployLambdaAliasUpdate:
      ApplicationName: !Ref CodeDeployApplication
      DeploymentGroupName: !Ref CodeDeployDeploymentGroup
      BeforeAllowTrafficHook: !Ref PreHookLambdaFunction
      AfterAllowTrafficHook: !Ref PreHookLambdaFunction
```