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à.
# Impedire gli aggiornamenti delle risorse stack
Quando si crea uno stack, sono consentite tutte le operazioni di aggiornamento su tutte le risorse. Per impostazione predefinita, chiunque abbia le autorizzazioni per aggiornare lo stack può aggiornare tutte le risorse nello stack. Durante un aggiornamento, alcune risorse potrebbero richiedere un'interruzione o essere completamente sostituite, con conseguente creazione di un nuovo storage fisico o completamente nuovo. IDs È possibile impedire che le risorse stack vengano involontariamente aggiornate o eliminate durante un aggiornamento dello stack utilizzando le policy stack. Una policy stack è un documento JSON che definisce le azioni di aggiornamento che possono essere eseguite su risorse definite.
Dopo aver impostato una policy stack, tutte le risorse nello stack vengono protette per impostazione predefinita. Per permettere gli aggiornamenti di risorse specifiche, è necessario specificare una dichiarazione `Allow` esplicita per tali risorse nella policy stack. È possibile definire una sola policy stack per stack, ma è possibile proteggere più risorse all’interno di una singola policy. Una policy stack si applica a tutti gli utenti CloudFormation che tentano di aggiornare lo stack. Non è possibile associare policy stack diverse a utenti diversi.
Una policy stack si applica solo durante gli aggiornamenti dello stack. Non fornisce i controlli di accesso, come per esempio una policy AWS Identity and Access Management (IAM). Utilizzare una policy stack solo come meccanismo a prova di errore per evitare gli aggiornamenti accidentali di specifiche risorse stack. Per controllare l'accesso a AWS risorse o azioni, usa IAM.
**Topics**
+ [Esempio di policy stack](#stack-policy-intro-example)
+ [Definizione di una policy stack](#stack-policy-reference)
+ [Impostazione di una policy stack](#protect-stack-resources-protecting)
+ [Aggiornamento delle risorse protette](#protect-stack-resources-updating)
+ [Modifica di una policy stack](#protect-stack-resources-modifying)
+ [Ulteriori esempi di policy stack](#stack-policy-samples)
## Esempio di policy stack
L’esempio di stack policy seguente impedisce gli aggiornamenti della risorsa `ProductionDatabase`:
```
{
"Statement" : [
{
"Effect" : "Allow",
"Action" : "Update:*",
"Principal": "*",
"Resource" : "*"
},
{
"Effect" : "Deny",
"Action" : "Update:*",
"Principal": "*",
"Resource" : "LogicalResourceId/ProductionDatabase"
}
]
}
```
Quando si imposta una policy stack, tutte le risorse vengono protette per impostazione predefinita. Per permettere gli aggiornamenti di tutte le risorse, aggiungiamo una dichiarazione `Allow` che permette tutte le azioni su tutte le risorse. Anche se la dichiarazione `Allow` specifica tutte le risorse, la dichiarazione esplicita `Deny` la sostituisce per la risorsa con l’ID logico `ProductionDatabase`. Questa dichiarazione `Deny` impedisce tutte le azioni di aggiornamento, come per esempio la sostituzione o l’eliminazione, sulla risorsa `ProductionDatabase`.
L’elemento `Principal` è necessario, ma supporta solo il carattere jolly (`*`), il che significa che la dichiarazione si applica a tutti i [principali](https://docs.aws.amazon.com/glossary/latest/reference/glos-chap.html#principal).
**Nota**
Durante un aggiornamento dello stack, aggiorna CloudFormation automaticamente le risorse che dipendono da altre risorse aggiornate. Ad esempio, CloudFormation aggiorna una risorsa che fa riferimento a una risorsa aggiornata. CloudFormation non apporta modifiche fisiche, come l'ID della risorsa, alle risorse aggiornate automaticamente, ma se a tali risorse è associata una policy di stack, è necessario disporre dell'autorizzazione per aggiornarle.
## Definizione di una policy stack
Quando si crea uno stack, non è impostata nessuna policy stack, quindi sono consentite tutte le operazioni di aggiornamento su tutte le risorse. Per proteggere le risorse stack dalle operazioni di aggiornamento, definire una policy stack e quindi impostarla sullo stack. Una politica dello stack è un documento JSON che definisce le azioni di aggiornamento dello CloudFormation stack che CloudFormation gli utenti possono eseguire e le risorse a cui tali azioni si applicano. Si imposta la policy stack al momento della creazione di uno stack, specificando un file di testo che contiene la policy stack o digitandola. Quando si imposta una policy stack sullo stack, qualsiasi aggiornamento non esplicitamente consentito viene negato per impostazione predefinita.
Una policy stack si definisce in cinque elementi: `Effect`, `Action`, `Principal`, `Resource` e `Condition`. Il seguente pseudo codice mostra la sintassi di policy stack.
```
{
"Statement" : [
{
"Effect" : "Deny_or_Allow",
"Action" : "update_actions",
"Principal" : "*",
"Resource" : "LogicalResourceId/resource_logical_ID",
"Condition" : {
"StringEquals_or_StringLike" : {
"ResourceType" : [resource_type, ...]
}
}
}
]
}
```
`Effect`
Determina se le azioni specificate vengono negate o consentite sulla/e risorsa/e specificata/e. È possibile specificare solo `Deny` o `Allow`, come per esempio:
```
"Effect" : "Deny"
```
Se una policy stack include istruzioni sovrapposte (sia consentendo sia negando gli aggiornamenti di una risorsa), una dichiarazione `Deny` sostituisce sempre una dichiarazione `Allow`. Per garantire che una risorsa venga protetta, utilizzare una dichiarazione `Deny` per tale risorsa.
Azione
Specifica le operazioni di aggiornamento che sono negate o consentite:
Update:Modify
Specifica le operazioni di aggiornamento durante le quali le risorse potrebbero non avere interruzioni o avere alcune interruzioni durante l’applicazione delle modifiche. Tutte le risorse mantengono la loro fisicità. IDs
Update:Replace
Specifica le operazioni di aggiornamento durante le quali le risorse vengono ricreate. CloudFormation crea una nuova risorsa con gli aggiornamenti specificati poi elimina la risorsa precedente. Poiché la risorsa viene ricreata, l’ID fisico della nuova risorsa potrebbe essere diverso.
Update:Delete
Specifica le operazioni di aggiornamento durante le quali le risorse vengono rimosse. Gli aggiornamenti che rimuovono completamente le risorse da un modello stack richiedono questa operazione.
Aggiorna:\$1
Specifica tutte le operazioni di aggiornamento. L’asterisco è una carta jolly che rappresenta tutte le operazioni di aggiornamento.
L’esempio seguente mostra come specificare solo le operazioni di sostituzione ed eliminazione:
```
"Action" : ["Update:Replace", "Update:Delete"]
```
Per permettere tutte le operazioni di aggiornamento tranne una, utilizzare `NotAction`. Per esempio, per permettere tutte le operazioni di aggiornamento tranne `Update:Delete`, utilizzare `NotAction`, come illustrato in questo esempio:
```
{
"Statement" : [
{
"Effect" : "Allow",
"NotAction" : "Update:Delete",
"Principal": "*",
"Resource" : "*"
}
]
}
```
Principale
L’elemento `Principal` specifica l’entità a cui si applica la policy. Tale elemento è necessario ma supporta solo il carattere jolly (`*`), il che significa che la policy si applica a tutti i [principali](https://docs.aws.amazon.com/glossary/latest/reference/glos-chap.html#principal).
Risorsa
Speciifica la logica IDs delle risorse a cui si applica la politica. Per specificare i tipi di risorse, utilizza l’elemento `Condition`.
Per specificare una singola risorsa, utilizzare il suo ID logico. Esempio:
```
"Resource" : ["LogicalResourceId/myEC2instance"]
```
È possibile utilizzare una wild card con logica IDs. Per esempio, se si utilizza un prefisso comune di ID logico per tutte le risorse correlate, è possibile specificarle tutte con un carattere jolly:
```
"Resource" : ["LogicalResourceId/CriticalResource*"]
```
È inoltre possibile utilizzare un elemento `Not` con le risorse. Per esempio, per permettere gli aggiornamenti di tutte le risorse tranne una, utilizzare un elemento `NotResource` per proteggere tale risorsa:
```
{
"Statement" : [
{
"Effect" : "Allow",
"Action" : "Update:*",
"Principal": "*",
"NotResource" : "LogicalResourceId/ProductionDatabase"
}
]
}
```
Quando si imposta una policy stack, qualsiasi aggiornamento non esplicitamente consentito viene negato. Consentendo gli aggiornamenti di tutte le risorse ad eccezione della risorsa `ProductionDatabase`, si rifiutano gli aggiornamenti alla risorsa `ProductionDatabase`.
Condizioni
Specifica il tipo di risorsa a cui si applica la policy. Per specificare la logica IDs di risorse specifiche, usa l'`Resource`elemento.
È possibile specificare un tipo di risorsa, come per esempio tutte le istanze database EC2 e RDS, come mostrato nell’esempio seguente:
```
{
"Statement" : [
{
"Effect" : "Deny",
"Principal" : "*",
"Action" : "Update:*",
"Resource" : "*",
"Condition" : {
"StringEquals" : {
"ResourceType" : ["AWS::EC2::Instance", "AWS::RDS::DBInstance"]
}
}
},
{
"Effect" : "Allow",
"Principal" : "*",
"Action" : "Update:*",
"Resource" : "*"
}
]
}
```
La dichiarazione `Allow` concede le autorizzazioni di aggiornamento a tutte le risorse e la dichiarazione `Deny` nega gli aggiornamenti di EC2 e delle istanze database RDS. La dichiarazione `Deny` sostituisce sempre le operazioni di permesso.
È possibile utilizzare un carattere jolly con i tipi di risorse. Per esempio, è possibile rifiutare le autorizzazioni di aggiornamento a tutte le risorse Amazon EC2, come per esempio istanze, gruppi di sicurezza e sottoreti, utilizzando un carattere jolly, come mostrato nell’esempio seguente:
```
"Condition" : {
"StringLike" : {
"ResourceType" : ["AWS::EC2::*"]
}
}
```
Bisogna utilizzare la condizione `StringLike` quando si utilizzano i caratteri jolly.
## Impostazione di una policy stack
È possibile utilizzare la console o AWS CLI applicare una politica di stack quando si crea uno stack. È inoltre possibile utilizzare la AWS CLI per applicare una politica di stack a uno stack esistente. Dopo aver applicato una policy di stack, non è possibile rimuoverla dallo stack, ma è possibile utilizzarla per modificarla. AWS CLI
Le policy dello stack si applicano a tutti CloudFormation gli utenti che tentano di aggiornare lo stack. Non è possibile associare policy stack diverse a utenti diversi.
Per informazioni sulla scrittura delle policy stack, consulta [Definizione di una policy stack](#stack-policy-reference).
**Per impostare una policy stack quando si crea uno stack (console)**
1. [Apri la CloudFormation console in /cloudformazione. https://console.aws.amazon.com](https://console.aws.amazon.com/cloudformation/)
1. Nella barra di navigazione nella parte superiore dello schermo, scegli in cui Regione AWS creare lo stack.
1. Nella pagina **CloudFormation Pile**, scegli **Crea** pila.
1. Nella procedura guidata Crea stack, nella pagina **Configura opzioni stack**, espandere la sezione **Avanzate**, quindi scegliere **Policy stack**.
1. Specificare la policy dello stack:
+ Per scrivere una policy direttamente nella console, scegliere **Inserisci policy stack** e quindi la policy di stack direttamente nel campo di testo.
+ Per usare una policy definita in un file separato, scegliere **Carica un file**, quindi **Scegli file** per selezionare il file contenente la policy di stack.
**Per impostare una policy stack quando creai uno stack (AWS CLI)**
+ Utilizza il 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) con l’opzione `--stack-policy-body` per digitare in una policy modificata o l’opzione `--stack-policy-url` per specificare un file contenente la policy.
**Per impostare una politica di stack su uno stack esistente (solo)AWS CLI**
+ Utilizza il comando [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/set-stack-policy.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/set-stack-policy.html) con l’opzione `--stack-policy-body` per digitare in una policy modificata o l’opzione `--stack-policy-url` per specificare un file contenente la policy.
**Nota**
Per aggiungere una policy a uno stack esistente, è necessario disporre dell'autorizzazione all'azione. CloudFormation [https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_SetStackPolicy.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_SetStackPolicy.html)
## Aggiornamento delle risorse protette
Per aggiornare le risorse protette, creare una policy temporanea che sovrascriva la policy stack e permetta gli aggiornamenti di tali risorse. Specificare la policy di sostituzione quando si aggiorna lo stack. La policy di sostituzione non modifica in modo permanente la policy stack.
Per aggiornare le risorse protette, è necessario disporre dell'autorizzazione per utilizzare l' CloudFormation [https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_SetStackPolicy.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_SetStackPolicy.html)azione. Per informazioni sull'impostazione delle autorizzazioni CloudFormation, consulta [Controlla CloudFormation l'accesso con AWS Identity and Access Management](control-access-with-iam.md).
**Nota**
Durante un aggiornamento dello stack, aggiorna CloudFormation automaticamente le risorse che dipendono da altre risorse aggiornate. Ad esempio, CloudFormation aggiorna una risorsa che fa riferimento a una risorsa aggiornata. CloudFormation non apporta modifiche fisiche, come l'ID delle risorse, alle risorse aggiornate automaticamente, ma se a tali risorse è associata una policy di stack, è necessario disporre dell'autorizzazione per aggiornarle.
**Per aggiornare una risorsa protetta (console)**
1. [Apri la console in CloudFormation /cloudformation. https://console.aws.amazon.com](https://console.aws.amazon.com/cloudformation/)
1. Selezionare lo stack che si desidera aggiornare, selezionare **Operazioni stack**, poi **Aggiorna stack**.
1. Se *non è stato* modificato il modello di stack, selezionare **Utilizza modello corrente**, quindi fare clic su **Avanti**. Se è stato modificato il modello, selezionare **Sostituisci modello corrente** e specificare la posizione del modello aggiornato nella sezione **Specificare modello**:
+ Per un modello memorizzato localmente nel computer, selezionare **Carica un file modello**. Scegliere **Scegli file** per accedere al file e selezionarlo e fare clic su **Avanti**.
+ Per un modello archiviato in un bucket Amazon S3, selezionare **URL Amazon S3**. Inserire o incollare l’URL per il modello e fare clic su **Successivo**.
Se disponi di un modello in un bucket con controllo delle versioni abilitato, puoi indicare una versione specifica di modello allegando `?versionId=version-id` all’URL. Per ulteriori informazioni, consulta [Working with objects in a versioning-enabled bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/manage-objects-versioned-bucket.html) nella *Guida per l’utente di Amazon Simple Storage Service*.
1. Se il modello contiene parametri, nella pagina **Specifica dettagli stack** immettere o modificare i valori di parametro, quindi selezionare **Avanti**.
CloudFormation popola ogni parametro con il valore attualmente impostato nello stack ad eccezione dei parametri dichiarati con l'attributo. `NoEcho` È possibile utilizzare i valori correnti per questi parametri scegliendo **Utilizza valore esistente**.
Per ulteriori informazioni sull’utilizzo di `NoEcho` per mascherare le informazioni sensibili e sull’utilizzo dei parametri dinamici per gestire i segreti, consulta la best practice [Non incorporare le credenziali nei modelli](security-best-practices.md#creds).
1. Specificare una policy di stack di sostituzione.
1. Nella pagina **Configura opzioni stack**, nella sezione **Opzioni avanzate**, selezionare **Policy stack**.
1. Selezionare **Carica un file**.
1. Fare clic su **Scegli file** e passare al file che contiene le policy di stack di sostituzione o digitare una policy.
1. Scegli **Successivo**.
Le policy di sostituzione devono specificare una dichiarazione `Allow` per le risorse protette che si desidera aggiornare. Per esempio, per aggiornare tutte le risorse protette, specificare una policy di sostituzione temporanea che permetta tutti gli aggiornamenti:
```
{
"Statement" : [
{
"Effect" : "Allow",
"Action" : "Update:*",
"Principal": "*",
"Resource" : "*"
}
]
}
```
**Nota**
CloudFormation applica la politica di esclusione solo durante questo aggiornamento. La policy di sostituzione non modifica in modo permanente la policy stack. Per modificare una policy stack, consulta [Modifica di una policy stack](#protect-stack-resources-modifying).
1. Esaminare le informazioni stack e le modifiche inviate.
Verificare di aver inviato le informazioni corrette, come i valori dei parametri o l’URL del modello corretti. Se il modello contiene risorse IAM, scegliere **Acconsento che questo modello possa creare risorse IAM** per specificare che si desidera utilizzare risorse IAM nel modello. Per ulteriori informazioni, consulta [Riconoscimento delle risorse IAM nei modelli CloudFormation](control-access-with-iam.md#using-iam-capabilities).
Nella sezione **Visualizza l'anteprima delle modifiche**, verifica che CloudFormation vengano apportate tutte le modifiche che ti aspetti. Ad esempio, verifica che CloudFormation aggiunga, rimuova e modifichi le risorse che intendevi aggiungere, rimuovere o modificare. CloudFormationgenera questa anteprima creando un set di modifiche per lo stack. Per ulteriori informazioni, consulta [Aggiorna CloudFormation gli stack utilizzando i set di modifiche](using-cfn-updating-stacks-changesets.md).
1. Se le modifiche sono quelle desiderate, fare clic su **Aggiorna**.
**Nota**
A questo punto, è possibile visualizzare il set di modifiche per rivedere gli aggiornamenti proposti più accuratamente. A tale scopo, fate clic su **Visualizza set di modifiche** anziché su **Aggiorna**. CloudFormation visualizza il set di modifiche generato in base agli aggiornamenti. Quando si è pronti per eseguire l’aggiornamento dello stack, fare clic su **Esegui**.
CloudFormation visualizza la pagina dei **dettagli dello stack** relativo allo stack. Ora lo stack è nello stato `UPDATE_IN_PROGRESS`. Dopo aver CloudFormation completato con successo l'aggiornamento dello stack, imposta lo stato dello stack su. `UPDATE_COMPLETE`
Se l'aggiornamento dello stack fallisce CloudFormation, ripristina automaticamente le modifiche e imposta lo stato dello stack su. `UPDATE_ROLLBACK_COMPLETE`
**Per aggiornare una risorsa protetta (AWS CLI)**
+ Utilizza il comando [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/update-stack.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/update-stack.html) con l’opzione `--stack-policy-during-update-body` per digitare in una policy modificata o l’opzione `--stack-policy-during-update-url` per specificare un file contenente la policy.
**Nota**
CloudFormation applica la politica di esclusione solo durante questo aggiornamento. La policy di sostituzione non modifica in modo permanente la policy stack. Per modificare una policy stack, consulta [Modifica di una policy stack](#protect-stack-resources-modifying).
## Modifica di una policy stack
Per proteggere le risorse aggiuntive o per rimuovere la protezione dalle risorse, modificare la policy stack. Per esempio, quando si aggiunge un database che si desidera proteggere allo stack, aggiungere una dichiarazione `Deny` per quel database alla policy stack. Per modificare la policy, bisogna avere l’autorizzazione a utilizzare l’operazione [https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_SetStackPolicy.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_SetStackPolicy.html).
Utilizzare il AWS CLI per modificare le politiche dello stack.
**Per modificare una policy stack (AWS CLI)**
+ Utilizza il comando [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/set-stack-policy.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/set-stack-policy.html) con l’opzione `--stack-policy-body` per digitare in una policy modificata o l’opzione `--stack-policy-url` per specificare un file contenente la policy.
Non è possibile eliminare una policy stack. Per rimuovere tutta la protezione da tutte le risorse, si modifica la policy per permettere esplicitamente tutte le operazioni su tutte le risorse. La policy seguente permette tutti gli aggiornamenti su tutte le risorse:
```
{
"Statement" : [
{
"Effect" : "Allow",
"Action" : "Update:*",
"Principal": "*",
"Resource" : "*"
}
]
}
```
## Ulteriori esempi di policy stack
Le policy di esempio seguenti mostrano come impedire gli aggiornamenti di tutte le risorse stack e di risorse specifiche e come impedire tipologie specifiche di aggiornamenti.
### Impedire gli aggiornamenti di tutte le risorse stack
Per impedire gli aggiornamenti di tutte le risorse stack, la policy seguente specifica una dichiarazione `Deny` per tutte le operazioni di aggiornamento su tutte le risorse.
```
{
"Statement" : [
{
"Effect" : "Deny",
"Action" : "Update:*",
"Principal": "*",
"Resource" : "*"
}
]
}
```
### Impedire gli aggiornamenti di una singola risorsa
La policy seguente nega tutte le operazioni di aggiornamento sul database con l’ID logico `MyDatabase`. Essa consente tutte le operazioni di aggiornamento su tutte le altre risorse stack con una dichiarazione `Allow`. La dichiarazione `Allow` non si applica alla risorsa `MyDatabase` perché la dichiarazione `Deny` sostituisce sempre le operazioni di permesso.
```
{
"Statement" : [
{
"Effect" : "Deny",
"Action" : "Update:*",
"Principal": "*",
"Resource" : "LogicalResourceId/MyDatabase"
},
{
"Effect" : "Allow",
"Action" : "Update:*",
"Principal": "*",
"Resource" : "*"
}
]
}
```
È possibile ottenere lo stesso risultato dell’esempio precedente utilizzando un rifiuto per default. Quando impostate una politica di stack, CloudFormation nega qualsiasi aggiornamento che non sia esplicitamente consentito. La policy seguente consente gli aggiornamenti di tutte le risorse ad eccezione della risorsa `ProductionDatabase`, che viene rifiutata per default.
```
{
"Statement" : [
{
"Effect" : "Allow",
"Action" : "Update:*",
"Principal": "*",
"NotResource" : "LogicalResourceId/ProductionDatabase"
}
]
}
```
**Importante**
Vi è rischio nell’utilizzo di un rifiuto per default. Se si dispone di una dichiarazione `Allow` altrove nella policy (come per esempio una dichiarazione `Allow` che utilizza un carattere jolly), è possibile concedere inconsapevolmente l’autorizzazione all’aggiornamento di risorse per le quali non lo si voleva. Poiché un rifiuto esplicito sostituisce qualsiasi operazione di permesso, è possibile fare in modo che una risorsa venga protetta utilizzando una dichiarazione `Deny`.
### Impedire gli aggiornamenti di tutte le istanze di un tipo di risorsa
La policy seguente rifiuta tutte le operazioni di aggiornamento nel tipo di risorsa RDS dell’istanza database. Essa consente tutte le operazioni di aggiornamento su tutte le altre risorse stack con una dichiarazione `Allow`. La dichiarazione `Allow` non si applica alle risorse RDS dell’istanza database poiché una dichiarazione `Deny` sostituisce sempre le operazioni di permesso.
```
{
"Statement" : [
{
"Effect" : "Deny",
"Action" : "Update:*",
"Principal": "*",
"Resource" : "*",
"Condition" : {
"StringEquals" : {
"ResourceType" : ["AWS::RDS::DBInstance"]
}
}
},
{
"Effect" : "Allow",
"Action" : "Update:*",
"Principal": "*",
"Resource" : "*"
}
]
}
```
### Impedire gli aggiornamenti di sostituzione per un’istanza
La policy seguente rifiuta gli aggiornamenti che causerebbero una sostituzione dell’istanza con l’ID logico `MyInstance`. Essa consente tutte le operazioni di aggiornamento su tutte le altre risorse stack con una dichiarazione `Allow`. La dichiarazione `Allow` non si applica alla risorsa `MyInstance` perché la dichiarazione `Deny` sostituisce sempre le operazioni di permesso.
```
{
"Statement" : [
{
"Effect" : "Deny",
"Action" : "Update:Replace",
"Principal": "*",
"Resource" : "LogicalResourceId/MyInstance"
},
{
"Effect" : "Allow",
"Action" : "Update:*",
"Principal": "*",
"Resource" : "*"
}
]
}
```
### Impedire gli aggiornamenti degli stack nidificati
La seguente politica nega tutte le azioni di aggiornamento sul tipo di risorsa CloudFormation dello stack (stack annidati). Essa consente tutte le operazioni di aggiornamento su tutte le altre risorse stack con una dichiarazione `Allow`. La dichiarazione `Allow` non si applica alle risorse stack CloudFormation poiché la dichiarazione `Deny` sostituisce sempre le operazioni di permesso.
```
{
"Statement" : [
{
"Effect" : "Deny",
"Action" : "Update:*",
"Principal": "*",
"Resource" : "*",
"Condition" : {
"StringEquals" : {
"ResourceType" : ["AWS::CloudFormation::Stack"]
}
}
},
{
"Effect" : "Allow",
"Action" : "Update:*",
"Principal": "*",
"Resource" : "*"
}
]
}
```