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à.
# Sicurezza in CloudFormation
La sicurezza del cloud AWS è la massima priorità. In qualità di AWS cliente, puoi beneficiare di data center e architetture di rete progettati per soddisfare i requisiti delle organizzazioni più sensibili alla sicurezza.
La sicurezza è una responsabilità condivisa tra te e te. AWS Il [modello di responsabilità condivisa](https://aws.amazon.com/compliance/shared-responsibility-model/) descrive questo aspetto come sicurezza *del* cloud e sicurezza *nel* cloud:
+ **Sicurezza del cloud**: AWS è responsabile della protezione dell'infrastruttura che gestisce AWS i servizi nel AWS cloud. AWS ti fornisce anche servizi che puoi utilizzare in modo sicuro. I revisori esterni testano e verificano regolarmente l'efficacia della nostra sicurezza nell'ambito dei [AWS Programmi di AWS conformità dei Programmi di conformità](https://aws.amazon.com/compliance/programs/) dei di . Per ulteriori informazioni sui programmi di conformità applicabili CloudFormation, consulta [AWS Servizi nell'ambito del programma di conformitàAWS](https://aws.amazon.com/compliance/services-in-scope/) .
+ **Sicurezza nel cloud**: la tua responsabilità è determinata dal AWS servizio che utilizzi. L’utente è anche responsabile di altri fattori, tra cui la riservatezza dei dati, i requisiti della propria azienda e le leggi e normative vigenti.
Questa documentazione ti aiuta a capire come applicare il modello di responsabilità condivisa durante l'utilizzo CloudFormation. I seguenti argomenti mostrano come configurare per CloudFormation soddisfare gli obiettivi di sicurezza e conformità. Imparerai anche a utilizzare altri AWS servizi che ti aiutano a monitorare e proteggere CloudFormation le tue risorse.
**Topics**
+ [Proteggi CloudFormation gli stack dall'eliminazione](using-cfn-protect-stacks.md)
+ [Impedire gli aggiornamenti delle risorse stack](protect-stack-resources.md)
+ [Protezione dei dati in CloudFormation](security-data-protection.md)
+ [Controlla CloudFormation l'accesso con AWS Identity and Access Management](control-access-with-iam.md)
+ [Registrazione delle chiamate CloudFormation API con AWS CloudTrail](cfn-api-logging-cloudtrail.md)
+ [Sicurezza dell'infrastruttura in CloudFormation](infrastructure-security.md)
+ [Resilienza in CloudFormation](disaster-recovery-resiliency.md)
+ [Convalida della conformità per CloudFormation](cloudformation-compliance.md)
+ [Analisi della configurazione e delle vulnerabilità in CloudFormation](vulnerability-analysis-and-management.md)
+ [Best practice di sicurezza per CloudFormation](security-best-practices.md)
+ [Accesso CloudFormation tramite un endpoint di interfaccia ()AWS PrivateLink](vpc-interface-endpoints.md)
# Proteggi CloudFormation gli stack dall'eliminazione
Puoi impedire che uno stack venga eliminato accidentalmente abilitando la protezione da cessazione sullo stack. Se un utente tenta di eliminare uno stack con protezione da cessazione abilitata, l’eliminazione ha esito negativo e lo stack, incluso lo stato, rimane invariato. Puoi abilitare la protezione da cessazione sullo stack quando lo crei. Per impostazione di default, la protezione da cessazione è disabilitata. Puoi impostare la protezione da cessazione su stack con qualsiasi stato eccetto `DELETE_IN_PROGRESS` o `DELETE_COMPLETE`.
Se abilitata o disabilitata su uno stack, la protezione da cessazione approva la stessa scelta anche per qualsiasi stack nidificato appartenente a tale stack. Non è possibile abilitare o disabilitare la protezione da terminazione direttamente su uno stack nidificato. Se un utente cerca di eliminare direttamente uno stack nidificato appartenente a uno stack con protezione da terminazione abilitata, l'operazione ha esito negativo e lo stack nidificato rimane invariato.
Tuttavia, se un utente esegue un aggiornamento dello stack che comporterebbe l'eliminazione dello stack nidificato, CloudFormation elimina quest'ultimo di conseguenza.
La protezione da cessazione è diversa dalla disabilitazione del rollback. La prima si applica solo ai tentativi di eliminazione degli stack, mentre la seconda si applica al rollback automatico nei casi in cui la creazione dello stack ha esito negativo.
**Per abilitare la protezione da cessazione durante la creazione di uno stack**
Nella pagina **Specify stack options (Specifica opzioni stack)** della procedura guidata **Create stack (Crea stack)**, in **Advanced options (Opzioni avanzate)**, espandere la sezione **Termination Protection (Protezione da cessazione)** e selezionare **Enable (Abilita)**. Per ulteriori informazioni, consulta [Configurazione delle opzioni dello stack](cfn-console-create-stack.md#configure-stack-options).
**Per abilitare o disabilitare la protezione da cessazione su uno stack esistente**
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 barra di navigazione nella parte superiore dello schermo, scegli la Regione AWS.
1. Selezionare lo stack desiderato.
**Nota**
Se accanto al nome dello stack compare la dicitura **NESTED (NIDIFICATO)**, si tratta di uno stack nidificato. È possibile modificare la protezione da cessazione soltanto sullo stack radice al quale appartiene lo stack nidificato.
1. Nel riquadro dettagli dello stack, selezionare **Stack actions (Operazioni stack)**, quindi **Edit termination protection (Modifica protezione da cessazione)**.
CloudFormation visualizza la finestra di dialogo **Modifica protezione dalla terminazione.**
1. Scegliere **Enable (Abilita)** o **Disable (Disabilita)**, quindi selezionare **Save (Salva)**.
**Per abilitare o disabilitare la protezione da cessazione su uno stack nidificato**
Se accanto al nome dello stack compare la dicitura **NESTED (NIDIFICATO)**, si tratta di uno stack nidificato. È possibile modificare la protezione da cessazione soltanto sullo stack radice al quale appartiene lo stack nidificato. Per modificare la protezione da cessazione sullo stack radice:
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 barra di navigazione nella parte superiore dello schermo, scegli la Regione AWS.
1. Selezionare lo stack nidificato desiderato.
1. Nel riquadro **Stack info (Info stack)**, nella sezione **Overview (Panoramica)**, selezionare il nome dello stack presente in elenco come **Root stack (Stack root)**.
CloudFormation visualizza i dettagli dello stack per lo stack principale.
1. Scegliere **Stack actions (Operazioni stack)**, quindi scegliere **Edit Termination Protection (Modifica protezione da cessazione)**.
CloudFormation visualizza la finestra di **dialogo Modifica protezione dalla terminazione**.
1. Scegliere **Enable (Abilita)** o **Disable (Disabilita)**, quindi selezionare **Save (Salva)**.
**Per abilitare o disabilitare la protezione da interruzione utilizzando la riga di comando**
Utilizza il comando [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/update-termination-protection.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/update-termination-protection.html).
## Controllare chi può modificare la protezione da cessazione sugli stack
Per abilitare o disabilitare la protezione da cessazione sullo stack, è necessaria l'autorizzazione per l'operazione `cloudformation:UpdateTerminationProtection`. Ad esempio, la policy di seguito consente agli utenti di abilitare o disabilitare la protezione da cessazione sugli stack.
Per ulteriori informazioni sulla specificazione delle autorizzazioni in CloudFormation, vedere. [Controlla CloudFormation l'accesso con AWS Identity and Access Management](control-access-with-iam.md)
**Example Un esempio di policy che assegna le autorizzazioni per modificare la protezione da cessazione per lo stack**
****
```
{
"Version":"2012-10-17",
"Statement":[{
"Effect":"Allow",
"Action":[
"cloudformation:UpdateTerminationProtection"
],
"Resource":"*"
}]
}
```
# 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" : "*"
}
]
}
```
# Protezione dei dati in CloudFormation
Il modello di [responsabilità AWS condivisa modello](https://aws.amazon.com/compliance/shared-responsibility-model/) di di si applica alla protezione dei dati in AWS CloudFormation. Come descritto in questo modello, AWS è responsabile della protezione dell'infrastruttura globale che gestisce tutti i Cloud AWS. L’utente è responsabile del controllo dei contenuti ospitati su questa infrastruttura. L’utente è inoltre responsabile della configurazione della protezione e delle attività di gestione per i Servizi AWS utilizzati. Per maggiori informazioni sulla privacy dei dati, consulta le [Domande frequenti sulla privacy dei dati](https://aws.amazon.com/compliance/data-privacy-faq/). Per informazioni sulla protezione dei dati in Europa, consulta il post del blog relativo al [AWS Modello di responsabilità condivisa e GDPR](https://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/) nel *AWS Blog sulla sicurezza*.
Ai fini della protezione dei dati, consigliamo di proteggere Account AWS le credenziali e configurare i singoli utenti con AWS IAM Identity Center or AWS Identity and Access Management (IAM). In tal modo, a ogni utente verranno assegnate solo le autorizzazioni necessarie per svolgere i suoi compiti. Suggeriamo, inoltre, di proteggere i dati nei seguenti modi:
+ Utilizza l’autenticazione a più fattori (MFA) con ogni account.
+ SSL/TLS Da utilizzare per comunicare con AWS le risorse. È richiesto TLS 1.2 ed è consigliato TLS 1.3.
+ Configura l'API e la registrazione delle attività degli utenti con AWS CloudTrail. Per informazioni sull'utilizzo dei CloudTrail percorsi per acquisire AWS le attività, consulta [Lavorare con i CloudTrail percorsi](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-trails.html) nella *Guida per l'AWS CloudTrail utente*.
+ Utilizza soluzioni di AWS crittografia, insieme a tutti i controlli di sicurezza predefiniti all'interno Servizi AWS.
+ Utilizza i servizi di sicurezza gestiti avanzati, come Amazon Macie, che aiutano a individuare e proteggere i dati sensibili archiviati in Amazon S3.
+ Se hai bisogno di moduli crittografici convalidati FIPS 140-3 per accedere AWS tramite un'interfaccia a riga di comando o un'API, usa un endpoint FIPS. Per ulteriori informazioni sugli endpoint FIPS disponibili, consulta il [Federal Information Processing Standard (FIPS) 140-3](https://aws.amazon.com/compliance/fips/).
Ti consigliamo di non inserire mai informazioni riservate o sensibili, ad esempio gli indirizzi e-mail dei clienti, nei tag o nei campi di testo in formato libero, ad esempio nel campo **Nome**. Ciò include quando lavori CloudFormation o Servizi AWS utilizzi la console, l'API o. AWS CLI AWS SDKs I dati inseriti nei tag o nei campi di testo in formato libero utilizzati per i nomi possono essere utilizzati per i la fatturazione o i log di diagnostica. Quando si fornisce un URL a un server esterno, suggeriamo vivamente di non includere informazioni sulle credenziali nell’URL per convalidare la richiesta al server.
## Crittografia dei dati a riposo
Seguendo il modello di responsabilità AWS condivisa, CloudFormation archivia i dati crittografati quando sono inattivi. I clienti sono responsabili dell'impostazione delle policy di crittografia e di storage dei dati archiviati nei propri account. Ad esempio, si consiglia di abilitare la crittografia dei dati inattivi per i modelli e altri dati archiviati in bucket S3 o in argomenti SNS. I clienti definiscono in modo simile le impostazioni di crittografia per tutti i sistemi di storage dei dati forniti da CloudFormation.
## Crittografia dei dati in transito
CloudFormation utilizza canali crittografati per le comunicazioni di servizio nell'ambito del modello di responsabilità condivisa.
## Riservatezza del traffico Internet
CloudFormation le comunicazioni di servizio sono crittografate in modo sicuro per impostazione predefinita tra regioni o zone di disponibilità.
# Controlla CloudFormation l'accesso con AWS Identity and Access Management
Con AWS Identity and Access Management (IAM), puoi creare utenti IAM e controllarne l'accesso a risorse specifiche del tuo Account AWS. Quando usi IAM, puoi controllare cosa possono fare gli utenti CloudFormation, ad esempio se possono visualizzare modelli di stack, creare stack o eliminare stack.
Oltre CloudFormation alle azioni specifiche, puoi gestire i AWS servizi e le risorse disponibili per ogni utente. In questo modo, puoi controllare a quali risorse gli utenti possono accedere quando le utilizzano CloudFormation. Ad esempio, puoi specificare quali utenti possono creare istanze Amazon EC2, terminare istanze di database o effettuare aggiornamenti. VPCs Le stesse autorizzazioni si applicano ogni volta che eseguono tali azioni. CloudFormation
Utilizza le informazioni contenute nelle sezioni seguenti per controllare chi può accedere. CloudFormation Esploreremo anche come autorizzare la creazione di risorse IAM in modelli, fornire alle applicazioni in esecuzione su istanze EC2 le autorizzazioni necessarie e utilizzare credenziali di sicurezza temporanee per una maggiore sicurezza nell'ambiente. AWS
## Definizione di policy basate sull'identità IAM per CloudFormation
Per consentirne l'accesso CloudFormation, devi creare e assegnare policy IAM che consentano alle tue identità IAM (come utenti o ruoli) di effettuare le azioni API di cui hanno bisogno.
Con le policy basate sull'identità IAM, puoi specificare azioni e risorse consentite o negate, nonché le condizioni in base alle quali le azioni sono consentite o negate. CloudFormationsupporta azioni, risorse e chiavi di condizione specifiche.
Se non conosci IAM, inizia a familiarizzare con gli elementi di una policy IAM JSON. Per ulteriori informazioni, consulta [IAM JSON policy element reference](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html) nella *Guida per l’utente IAM*. Per scoprire come creare le policy IAM, completa il tutorial [Create and attach your first customer managed policy](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html) nella documentazione IAM.
**Topics**
+ [Azioni politiche per CloudFormation](#using-iam-actions)
+ [Azioni specifiche della console per CloudFormation](#console-specific-actions)
+ [Risorse politiche per CloudFormation](#resource-level-permissions)
+ [Chiavi relative alle condizioni politiche per CloudFormation](#using-iam-conditions)
### Azioni politiche per CloudFormation
Nell'`Action`elemento della dichiarazione sulla politica IAM, puoi specificare qualsiasi azione API che CloudFormation offra. Devi far precedere la stringa `cloudformation:` in minuscolo al nome dell’azione. For example: `cloudformation:CreateStack`, `cloudformation:CreateChangeSet` e `cloudformation:UpdateStack`.
Per specificare più azioni in una sola istruzione, separa ciascuna di esse con una virgola, come mostrato di seguito:
```
"Action": [ "cloudformation:action1", "cloudformation:action2" ]
```
Puoi anche specificare più operazioni tramite caratteri jolly. Ad esempio, puoi specificare tutte le operazioni i cui nomi iniziano con la parola `Get` come segue:
```
"Action": "cloudformation:Get*"
```
Per visualizzare un elenco completo delle azioni associate al prefisso del servizio `cloudformation`, consulta [Actions, resources, and condition keys for CloudFormation](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awscloudformation.html) e [Actions, resources, and condition keys for AWS Cloud Control API](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awscloudcontrolapi.html) in *Service Authorization Reference*.
#### Esempi
Di seguito viene mostrato un esempio di una politica di autorizzazioni che concede le autorizzazioni per visualizzare gli stack. CloudFormation
**Example 1. Una policy di esempio che consenta di visualizzare le autorizzazioni dello stack**
****
```
{
"Version":"2012-10-17",
"Statement":[{
"Effect":"Allow",
"Action":[
"cloudformation:DescribeStacks",
"cloudformation:DescribeStackEvents",
"cloudformation:DescribeStackResource",
"cloudformation:DescribeStackResources"
],
"Resource":"*"
}]
}
```
Gli utenti che creano o eliminano gli stack necessitano di autorizzazioni aggiuntive in base ai modelli di stack utilizzati. Ad esempio, se il modello descrive una coda Amazon SQS, gli utenti devono disporre delle autorizzazioni sia per le azioni di Amazon SQS che per quelle di Amazon CloudFormation SQS, come illustrato nella seguente policy di esempio.
**Example 2. Un esempio di policy che consente di creare e visualizzare le operazioni relative allo stack e tutte le operazioni per Amazon SQS**
****
```
{
"Version":"2012-10-17",
"Statement":[{
"Effect":"Allow",
"Action":[
"sqs:*",
"cloudformation:CreateStack",
"cloudformation:DescribeStacks",
"cloudformation:DescribeStackEvents",
"cloudformation:DescribeStackResources",
"cloudformation:GetTemplate",
"cloudformation:ValidateTemplate"
],
"Resource":"*"
}]
}
```
### Azioni specifiche della console per CloudFormation
Gli utenti della CloudFormation console richiedono autorizzazioni aggiuntive oltre a quelle necessarie per la sala operatoria. AWS Command Line Interface CloudFormation APIs Queste autorizzazioni aggiuntive supportano funzionalità specifiche della console, come il caricamento di modelli su bucket Amazon S3 e gli elenchi a discesa per tipi di parametri specifici. AWS
Per tutte le azioni elencate qui di seguito, concedi le autorizzazioni a tutte le risorse e non limitarle a stack o bucket specifici.
L'azione seguente viene utilizzata solo dalla CloudFormation console e non è documentata nel riferimento all'API. L’operazione consente agli utenti di caricare i modelli nei bucket Amazon S3.
+ `cloudformation:CreateUploadBucket`
Quando gli utenti caricano i modelli, devono anche disporre delle seguenti autorizzazioni Amazon S3:
+ `s3:PutObject`
+ `s3:ListBucket`
+ `s3:GetObject`
+ `s3:CreateBucket`
Per visualizzare i valori negli elenchi a discesa dei parametri per i modelli con tipi di parametri AWS specifici, gli utenti devono disporre delle autorizzazioni per effettuare le chiamate API di descrizione corrispondenti. Ad esempio, le seguenti autorizzazioni sono necessarie quando questi tipi di parametri vengono utilizzati nel modello:
+ `ec2:DescribeKeyPairs`: obbligatorio per il tipo di parametro `AWS::EC2::KeyPair::KeyName`.
+ `ec2:DescribeSecurityGroups`: obbligatorio per il tipo di parametro `AWS::EC2::SecurityGroup::Id`.
+ `ec2:DescribeSubnets`: obbligatorio per il tipo di parametro `AWS::EC2::Subnet::Id`.
+ `ec2:DescribeVpcs`: obbligatorio per il tipo di parametro `AWS::EC2::VPC::Id`.
Per ulteriori informazioni sui tipi di parametri AWS specifici, consulta. [Specificare le risorse esistenti in fase di esecuzione con i CloudFormation tipi di parametri forniti da](cloudformation-supplied-parameter-types.md)
### Risorse politiche per CloudFormation
In una dichiarazione di policy IAM, l’elemento `Resource` specifica l’oggetto o gli oggetti coperti dall’istruzione. Infatti CloudFormation, ogni dichiarazione di policy IAM si applica alle risorse specificate utilizzando i rispettivi Amazon Resource Names (ARNs). Il formato ARN specifico dipende dalla risorsa.
Per un elenco completo dei tipi di CloudFormation risorse e dei relativi tipi ARNs, consulta [Tipi di risorse definiti da CloudFormation](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awscloudformation.html#awscloudformation-resources-for-iam-policies) nel *Service Authorization Reference*. Per informazioni sulle operazioni che puoi specificare l’ARN di ogni risorsa, consulta [Actions defined by CloudFormation](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awscloudformation.html#awscloudformation-actions-as-permissions).
Puoi specificare le operazioni per uno stack specifico, come mostrato nella seguente policy di esempio. Quando fornisci un ARN, sostituisci `placeholder text` con le informazioni specifiche della tua risorsa.
**Example 1. Un esempio di policy che nega l’eliminazione dello stack e aggiorna le operazioni per lo stack specifico**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": [
"cloudformation:DeleteStack",
"cloudformation:UpdateStack"
],
"Resource": "arn:aws:cloudformation:us-east-1:111122223333:stack/MyProductionStack/*"
}
]
}
```
La policy sopra riportata utilizza un carattere jolly alla fine del nome dello stack in modo da impedire l’eliminazione e l’aggiornamento per l’ID stack completo (ad esempio `arn:aws:cloudformation:region:account-id:stack/MyProductionStack/abc9dbf0-43c2-11e3-a6e8-50fa526be49c`) e il nome dello stack (ad esempio `MyProductionStack`).
Per consentire che le trasformazioni `AWS::Serverless` creino un set di modifiche, includi l’autorizzazione a livello di risorsa `arn:aws:cloudformation:region:aws:transform/Serverless-2016-10-31`, come indicato nella seguente policy.
**Example 2. Un esempio di policy che consente di creare un set di modifiche per la trasformazione specifica**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudformation:CreateChangeSet"
],
"Resource": "arn:aws:cloudformation:us-east-1:aws:transform/Serverless-2016-10-31"
}
]
}
```
### Chiavi relative alle condizioni politiche per CloudFormation
In una dichiarazione della policy IAM, puoi specificare facoltativamente le condizioni che controllano la validità della policy. Ad esempio, puoi definire una policy che consenta agli utenti di creare uno stack solo quando specificano un determinato URL del modello. È possibile definire condizioni CloudFormation -specifiche e AWS-wide, ad esempio`DateLessThan`, che specificano quando una policy smette di avere effetto. *Per ulteriori informazioni e un elenco di condizioni AWS-wide, consulta Condition in [IAM Policy Elements di riferimento nella IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#Condition) User Guide.*
**Nota**
Non utilizzare la condizione `aws:SourceIp` AWS-wide. CloudFormationeffettua il provisioning delle risorse utilizzando il proprio indirizzo IP, non l'indirizzo IP della richiesta di origine. Ad esempio, quando crei uno stack, CloudFormation effettua richieste dal suo indirizzo IP per avviare un'istanza Amazon EC2 o per creare un bucket Amazon S3, non dall'`CreateStack`indirizzo IP della chiamata o del comando. **create-stack**
L'elenco seguente descrive le condizioni specifiche. CloudFormation Queste condizioni si applicano solo quando gli utenti creano o aggiornano gli stack:
`cloudformation:ChangeSetName`
Un nome di set di CloudFormation modifiche che si desidera associare a una politica. Utilizza questa condizione per controllare quali set di modifiche gli utenti possono eseguire o eliminare.
`cloudformation:ImportResourceTypes`
I tipi di risorse del modello che desideri associare a una policy, ad esempio `AWS::EC2::Instance`. Utilizza questa condizione per controllare i tipi di risorse che gli utenti possono utilizzare quando importano risorse in uno stack. Questa condizione viene verificata rispetto ai tipi di risorse dichiarati dagli utenti nel `ResourcesToImport` parametro, che attualmente è supportato solo per AWS CLI le richieste API. Quando si utilizza questo parametro, è necessario specificare tutti i tipi di risorse che si desidera far controllare agli utenti durante le operazioni di importazione. Per ulteriori informazioni sul parametro `ResourcesToImport`, consulta l’azione [https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateChangeSet.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateChangeSet.html) in *AWS CloudFormation API Reference*.
Per un elenco di `ResourcesToImport` possibili, consulta [Supporto del tipo di risorse](resource-import-supported-resources.md).
Utilizza la convenzione di denominazione delle risorse in tre parti per specificare i tipi di risorse con cui gli utenti possono lavorare, da tutte le risorse di un’organizzazione fino a un singolo tipo di risorsa.
`organization::*`
Specifica tutti i tipi di risorse per una determinata organizzazione.
`organization::service_name::*`
Specifica tutti i tipi di risorse per il servizio specificato all’interno di una determinata organizzazione.
`organization::service_name::resource_type`
Specifica un determinato tipo di risorsa.
Esempio:
`AWS::*`
Specificate tutti i tipi di AWS risorse supportati.
`AWS::service_name::*`
Specifica tutte le risorse per un determinato servizio AWS .
`AWS::service_name::resource_type`
Specificate un tipo di AWS risorsa specifico, ad esempio `AWS::EC2::Instance` (tutte le istanze EC2).
`cloudformation:ResourceTypes`
I tipi di risorse del modello, ad esempio `AWS::EC2::Instance`, che vuoi associare a una policy. Utilizza questa condizione per controllare i tipi di risorse che gli utenti possono utilizzare quando creano o aggiornano uno stack. La condizione viene verificata in base ai tipi di risorse che gli utenti dichiarano nel parametro `ResourceTypes`, attualmente supportato solo per la AWS CLI e richieste API. Quando si utilizza questo parametro, gli utenti devono specificare tutti i tipi di risorse disponibili nel modello. Per ulteriori informazioni sul parametro `ResourceTypes`, consulta l’azione [https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html) in *AWS CloudFormation API Reference*.
Per un elenco dei tipi di risorse, consulta [CloudFormation Template Reference Guide](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/introduction.html).
Utilizza la convenzione di denominazione delle risorse in tre parti per specificare i tipi di risorse con cui gli utenti possono lavorare, da tutte le risorse di un’organizzazione fino a un singolo tipo di risorsa.
`organization::*`
Specifica tutti i tipi di risorse per una determinata organizzazione.
`organization::service_name::*`
Specifica tutti i tipi di risorse per il servizio specificato all’interno di una determinata organizzazione.
`organization::service_name::resource_type`
Specifica un determinato tipo di risorsa.
Esempio:
`AWS::*`
Specificate tutti i tipi di AWS risorse supportati.
`AWS::service_name::*`
Specifica tutte le risorse per un determinato servizio AWS .
`AWS::service_name::resource_type`
Specificate un tipo di AWS risorsa specifico, ad esempio `AWS::EC2::Instance` (tutte le istanze EC2).
`Alexa::ASK::*`
Specifica tutti i tipi di risorse in Alexa Skill Kit.
`Alexa::ASK::Skill`
Specifica il singolo tipo di risorsa [Alexa::ASK::Skill](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/alexa-resource-ask-skill.html).
`Custom::*`
Specifica tutte le risorse personalizzate.
Per ulteriori informazioni, consulta [Creare una logica di provisioning personalizzata con risorse personalizzate](template-custom-resources.md).
`Custom::resource_type`
Specificare un tipo specifico di risorsa personalizzata.
Per ulteriori informazioni, consulta [Creare una logica di provisioning personalizzata con risorse personalizzate](template-custom-resources.md).
`cloudformation:RoleARN`
L’Amazon Resource Name (ARN) di un ruolo del servizio IAM da associare a una policy. Utilizza questa condizione per controllare quale ruolo del servizio può essere usato dagli utenti quando lavorano con gli stack o i set di modifiche.
`cloudformation:StackPolicyUrl`
L’URL della policy di uno stack Amazon S3 da associare a una policy. Utilizza questa condizione per controllare quali policy di stack gli utenti possono associare a uno stack durante la creazione o l’aggiornamento di un’operazione dello stack. Per ulteriori informazioni sulle policy degli stack, consulta [Impedire gli aggiornamenti delle risorse stack](protect-stack-resources.md).
Per essere certi che gli utenti possano creare o aggiornare gli stack con le policy di stack caricate, imposta il bucket S3 su sola lettura per tali utenti.
`cloudformation:TemplateUrl`
L’URL del modello Amazon S3 da associare a una policy. Utilizza questa condizione per controllare quali modelli gli utenti possono usare quando creano o aggiornano gli stack.
Per essere certi che gli utenti possano creare o aggiornare gli stack con i modelli caricati, imposta il bucket S3 su sola lettura per tali utenti.
Le seguenti condizioni CloudFormation specifiche si applicano ai parametri API con lo stesso nome:
+ `cloudformation:ChangeSetName`
+ `cloudformation:RoleARN`
+ `cloudformation:StackPolicyUrl`
+ `cloudformation:TemplateUrl`
Ad esempio, si applica `cloudformation:TemplateUrl` solo al `TemplateUrl` parametro for `CreateStack``UpdateStack`, e `CreateChangeSet` APIs.
Per esempi di policy IAM che utilizzano le chiavi di condizione per controllare l’accesso, consulta [Esempi di policy basate sull'identità IAM per CloudFormation](security_iam_id-based-policy-examples.md).
## Riconoscimento delle risorse IAM nei modelli CloudFormation
Prima di poter creare uno stack, CloudFormation convalida il modello. Durante la convalida, CloudFormation verifica nel modello la presenza di risorse IAM che potrebbe creare. Le risorse IAM, ad esempio un utente con accesso completo, possono accedere e modificare tutte le risorse nell' Account AWS. Pertanto, ti consigliamo di esaminare le autorizzazioni associate a ogni risorsa IAM prima di continuare, in modo da non creare inavvertitamente le risorse con autorizzazioni di escalation. Per assicurarti di averlo fatto, devi riconoscere che il modello contiene tali risorse e fornisce CloudFormation le funzionalità specificate prima di creare lo stack.
Puoi riconoscere le funzionalità dei CloudFormation modelli utilizzando la CloudFormation console, AWS Command Line Interface (AWS CLI) o l'API:
+ Nella CloudFormation console, nella pagina **Configura le opzioni dello stack** delle procedure guidate Create Stack o Update Stack, scegli **Riconosco che questo modello può** creare risorse IAM.
+ In AWS CLI, quando usi [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/update-stack.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/update-stack.html)i comandi [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html)and, specifica il `CAPABILITY_NAMED_IAM` valore `CAPABILITY_IAM` o per l'opzione. `--capabilities` Se il modello comprende risorse IAM, è possibile specificare qualsiasi funzionalità. Se il modello comprende nomi personalizzati per le risorse IAM, occorre specificare `CAPABILITY_NAMED_IAM`.
+ Nell’API, quando utilizzi le azioni [https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html) e [https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_UpdateStack.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_UpdateStack.html), specifica `Capabilities.member.1=CAPABILITY_IAM` o `Capabilities.member.1=CAPABILITY_NAMED_IAM`. Se il modello comprende risorse IAM, è possibile specificare qualsiasi funzionalità. Se il modello comprende nomi personalizzati per le risorse IAM, occorre specificare `CAPABILITY_NAMED_IAM`.
**Importante**
Se il modello contiene risorse IAM con nomi personalizzati, non occorre creare più stack che riutilizzino lo stesso modello. Le risorse IAM devono essere univoche a livello globale nell’account. Se utilizzi lo stesso modello per creare più stack in Regioni diverse, gli stack potrebbero condividere le stesse risorse IAM anziché avere ognuno una risorsa univoca. Le risorse condivise tra stack possono avere conseguenze indesiderate irreversibili. Ad esempio, se si eliminano o si aggiornano risorse IAM condivise all’interno di uno stack, si potrebbero involontariamente modificare le risorse di altri stack.
## Gestire le credenziali per le applicazioni in esecuzione su istanze Amazon EC2
Se disponi di un’applicazione che esegue un’istanza Amazon EC2 e devi effettuare richieste alle risorse AWS , ad esempio bucket Amazon S3 o una tabella DynamoDB, l’applicazione richiede credenziali di sicurezza AWS . Tuttavia, la distribuzione e l’incorporamento delle credenziali di sicurezza a lungo termine in ogni istanza avviata è una sfida nonché un potenziale rischio per la sicurezza. Invece di utilizzare credenziali di lungo termine, ad esempio le credenziali utente IAM, è consigliabile creare un ruolo IAM associato a un’istanza Amazon EC2 all’avvio dell’istanza. Un’applicazione può quindi ottenere le credenziali di sicurezza temporanee dall’istanza Amazon EC2. Non è necessario incorporare le credenziali a lungo termine nell’istanza. Inoltre, per semplificare la gestione delle credenziali, è possibile specificare un solo ruolo per più istanze Amazon EC2. In tal modo non dovrai creare credenziali univoche per ogni istanza.
Per un frammento di modello che mostra come avviare un’istanza con un ruolo, consulta [Esempi di modello per i ruoli IAM](quickref-iam.md#scenarios-iamroles).
**Nota**
Le applicazioni che si basano sulle istanze che utilizzano credenziali di sicurezza temporanee possono chiamare qualsiasi azione CloudFormation . Tuttavia, poiché CloudFormation interagisce con molti altri AWS servizi, è necessario verificare che tutti i servizi che si desidera utilizzare supportino credenziali di sicurezza temporanee. Per un elenco di servizi che supportano le credenziali di sicurezza temporanee, consulta [AWS services that work with IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) nella *Guida per l’utente IAM*.
## Concedere un accesso temporaneo (accesso federato)
In alcuni casi, potresti voler concedere agli utenti senza AWS credenziali l'accesso temporaneo al tuo. Account AWS Invece di creare ed eliminare credenziali a lungo termine ogni volta che desideri concedere un accesso temporaneo, usa AWS Security Token Service ().AWS STS Ad esempio, puoi utilizzare i ruoli IAM. Da un ruolo IAM, è possibile creare e distribuire in modo programmatico molte credenziali di sicurezza temporanee (che includono una chiave di accesso, una chiave di accesso segreta e un token di sicurezza). Queste credenziali hanno una durata limitata, quindi non possono essere utilizzate per accedere alle tue credenziali Account AWS dopo la loro scadenza. Puoi anche creare più ruoli IAM per concedere ai singoli utenti livelli di autorizzazioni diversi. I ruoli IAM sono utili per scenari quali le identità federate e i Single Sign-On (SSO).
Un’identità federata è un’identità distinta che puoi utilizzare in più sistemi. Per gli utenti enterprise con un sistema di identità locale (ad esempio LDAP o Active Directory), è possibile gestire tutte le autenticazioni con il sistema di identità locale. Dopo l’autenticazione dell’utente, è necessario fornire le credenziali di sicurezza temporanee dell’utente o ruolo IAM corrispondente. Ad esempio, puoi creare un ruolo di amministratore e un ruolo di sviluppatore, in cui gli amministratori abbiano pieno accesso all' AWS account e gli sviluppatori abbiano le autorizzazioni per lavorare solo con gli stack. CloudFormation Dopo l’autenticazione, un amministratore è autorizzato a ottenere le credenziali di sicurezza temporanee dal ruolo amministratori. Tuttavia, gli sviluppatori, possono ottenere le credenziali di sicurezza temporanee solo dal ruolo sviluppatori.
Puoi anche concedere agli utenti federati l'accesso a. Console di gestione AWS Dopo l’autenticazione degli utenti con il sistema di identità on-premises, è possibile creare un URL temporaneo a livello di codice che offra un accesso diretto a Console di gestione AWS. Quando gli utenti utilizzano l'URL temporaneo, non avranno bisogno di accedere AWS perché sono già stati autenticati (single sign-on). Inoltre, poiché l’URL viene creato in base alle credenziali di sicurezza temporanee degli utenti, le autorizzazioni disponibili con tali credenziali definiscono le autorizzazioni degli utenti in Console di gestione AWS.
È possibile utilizzarne diversi per generare credenziali AWS STS APIs di sicurezza temporanee. Per ulteriori informazioni sull’API da utilizzare, consulta [Compare AWS STS credentials](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_sts-comparison.html) nella *Guida per l’utente IAM*.
**Importante**
Non è possibile lavorare con IAM quando si utilizzano credenziali di sicurezza temporanee generati dall’API `GetFederationToken`. Al contrario, se è necessario utilizzare IAM, usare le credenziali di sicurezza temporanee di un ruolo.
CloudFormation interagisce con molti altri AWS servizi. Quando utilizzi credenziali di sicurezza temporanee con CloudFormation, verifica che tutti i servizi che desideri utilizzare supportino credenziali di sicurezza temporanee. Per un elenco di servizi che supportano le credenziali di sicurezza temporanee, consulta [AWS services that work with IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) nella *Guida per l’utente IAM*.
Per ulteriori informazioni, consulta le risorse correlate qui di seguito nella *Guida per l’utente IAM*:
+ [Scenari comuni per le credenziali temporanee](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html#sts-introduction)
+ [Abilita l'accesso personalizzato da parte di un broker di identità alla console AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_enable-console-custom-url.html)
# Esempi di policy basate sull'identità IAM per CloudFormation
Per impostazione predefinita, gli utenti e i ruoli non dispongono dell'autorizzazione per creare o modificare risorse CloudFormation. Inoltre, non possono eseguire attività utilizzando Console di gestione AWS, AWS Command Line Interface (AWS CLI) o API. AWS Per concedere agli utenti l’autorizzazione a eseguire operazioni sulle risorse di cui hanno bisogno, un amministratore IAM può creare policy IAM. L’amministratore può quindi aggiungere le policy IAM ai ruoli e gli utenti possono assumere i ruoli. Per ulteriori informazioni, consulta [Definizione di policy basate sull'identità IAM per CloudFormation](control-access-with-iam.md#iam-id-based-policies).
Gli esempi seguenti mostrano le dichiarazioni politiche che è possibile utilizzare per consentire o negare le autorizzazioni all'uso di una o più CloudFormation azioni.
**Topics**
+ [Richiedi un URL specifico per il modello](#w2aac43c23c17b9)
+ [Nega tutte le operazioni di importazione CloudFormation](#w2aac43c23c17c11)
+ [Consenti operazioni di importazione per tipi di risorse specifici](#w2aac43c23c17c13)
+ [Nega le risorse IAM nei modelli di stack](#w2aac43c23c17c15)
+ [Consenti la creazione di stack con tipi di risorse specifici](#w2aac43c23c17c17)
+ [Controlla l’accesso in base alle operazioni delle API che modificano le risorse](#w2aac43c23c17c19)
+ [Limita le operazioni relative ai set di stack in base alla Regione e ai tipi di risorse](#resource-level-permissions-service-managed-stack-set)
+ [Consenti tutte le operazioni dei generatori di IaC](#iam-policy-example-for-iac-generator)
## Richiedi un URL specifico per il modello
La policy seguente dà agli utenti l’autorizzazione per utilizzare solo l’URL del modello `https://s3.amazonaws.com/amzn-s3-demo-bucket/test.template` per creare o aggiornare uno stack.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudformation:CreateStack",
"cloudformation:UpdateStack"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"cloudformation:TemplateUrl": [
"https://s3.amazonaws.com/amzn-s3-demo-bucket/test.template"
]
}
}
}
]
}
```
------
## Nega tutte le operazioni di importazione CloudFormation
La seguente politica concede le autorizzazioni per completare tutte le CloudFormation operazioni tranne le operazioni di importazione.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowAllStackOperations",
"Effect": "Allow",
"Action": "cloudformation:*",
"Resource": "*"
},
{
"Sid": "DenyImport",
"Effect": "Deny",
"Action": "cloudformation:*",
"Resource": "*",
"Condition": {
"ForAnyValue:StringLike": {
"cloudformation:ImportResourceTypes": [
"*"
]
}
}
}
]
}
```
------
## Consenti operazioni di importazione per tipi di risorse specifici
La policy seguente dà agli utenti l’autorizzazione per eseguire tutte le operazioni di stack, oltre alle operazioni di importazione solo su risorse specificate (in questo esempio, `AWS::S3::Bucket`).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowImport",
"Effect": "Allow",
"Action": "cloudformation:*",
"Resource": "*",
"Condition": {
"ForAllValues:StringEqualsIgnoreCase": {
"cloudformation:ImportResourceTypes": [
"AWS::S3::Bucket"
]
}
}
}
]
}
```
------
## Nega le risorse IAM nei modelli di stack
La policy seguente dà agli utenti l’autorizzazione per creare stack, ma rifiuta le richieste se il modello dello stack include risorse del servizio IAM. Inoltre, in base a questa policy gli utenti devono anche specificare il parametro `ResourceTypes`, disponibile solo per la AWS CLI e per le richieste API. Questa policy usa istruzioni di rifiuto esplicito, pertanto se altre policy concedono autorizzazioni aggiuntive, questa policy resta sempre valida (un'istruzione di rifiuto esplicito ha sempre la precedenza su un'istruzione di consenso esplicito).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect" : "Allow",
"Action" : [ "cloudformation:CreateStack" ],
"Resource" : "*"
},
{
"Effect" : "Deny",
"Action" : [ "cloudformation:CreateStack" ],
"Resource" : "*",
"Condition" : {
"ForAnyValue:StringLikeIfExists" : {
"cloudformation:ResourceTypes" : [ "AWS::IAM::*" ]
}
}
},
{
"Effect": "Deny",
"Action" : [ "cloudformation:CreateStack" ],
"Resource": "*",
"Condition": {
"Null": {
"cloudformation:ResourceTypes": "true"
}
}
}
]
}
```
------
## Consenti la creazione di stack con tipi di risorse specifici
La policy seguente è simile all’esempio precedente. La policy dà agli utenti l’autorizzazione per creare uno stack, a meno che il modello dello stack includa risorse del servizio IAM. Richiede inoltre agli utenti di specificare il `ResourceTypes` parametro, che è disponibile solo per AWS CLI le richieste API. Questa policy è più semplice, ma non utilizza istruzioni di rifiuto esplicito. Altre policy, che concedono autorizzazioni aggiuntive, potrebbe sostituire questa policy.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect" : "Allow",
"Action" : [ "cloudformation:CreateStack" ],
"Resource" : "*",
"Condition" : {
"ForAllValues:StringNotLikeIfExists" : {
"cloudformation:ResourceTypes" : [ "AWS::IAM::*" ]
},
"Null":{
"cloudformation:ResourceTypes": "false"
}
}
}
]
}
```
------
## Controlla l’accesso in base alle operazioni delle API che modificano le risorse
La policy seguente concede l’autorizzazione per filtrare l’accesso in base al nome di un’operazione API che modifica le risorse. Viene utilizzato per controllare quali utenti APIs IAM possono utilizzare per aggiungere o rimuovere tag su uno stack o un set di stack. L’operazione utilizzata per aggiungere o rimuovere tag deve essere aggiunta come valore per la chiave di condizione. La policy seguente concede le autorizzazioni `TagResource` e `UntagResource` all’operazione di modifica `CreateStack`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "CreateActionConditionPolicyForTagUntagResources",
"Effect": "Allow",
"Action": [
"cloudformation:TagResource",
"cloudformation:UntagResource"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"cloudformation:CreateAction": [
"CreateStack"
]
}
}
}]
}
```
------
## Limita le operazioni relative ai set di stack in base alla Regione e ai tipi di risorse
La policy seguente concede autorizzazioni al set di stack gestito dal servizio Un utente con questa policy può eseguire operazioni solo sui set di stack con modelli contenenti tipi di risorse Amazon S3 (`AWS::S3::*`) o il tipo di risorsa `AWS::SES::ConfigurationSet`. Se ha effettuato l'accesso all'account di gestione dell'organizzazione con ID`123456789012`, l'utente può anche eseguire operazioni solo su set di stack destinati all'unità organizzativa con ID `ou-1fsfsrsdsfrewr` e può eseguire solo operazioni sullo stack impostato con ID `stack-set-id` che ha come destinazione il with ID. Account AWS `987654321012`
Le operazioni di stack set hanno esito negativo se il modello di stack set contiene tipi di risorse diversi da quelli specificati nella policy o se gli obiettivi di distribuzione sono unità organizzative o account IDs diversi da quelli specificati nella politica per gli account di gestione e i set di stack corrispondenti.
Queste restrizioni di policy si applicano solo quando le operazioni sul set di stack sono destinate alle Regioni `us-east-1`, `us-west-2` o `eu-west-2` Regioni AWS.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudformation:*"
],
"Resource": [
"arn:aws:cloudformation:*:*:stackset/*",
"arn:aws:cloudformation:*:*:type/resource/AWS-S3-*",
"arn:aws:cloudformation:us-west-2:111122223333:type/resource/AWS-SES-ConfigurationSet",
"arn:aws:cloudformation:*:111122223333:stackset-target/*/ou-1fsfsrsdsfrewr",
"arn:aws:cloudformation:*:111122223333:stackset-target/stack-set-id/444455556666"
],
"Condition": {
"ForAllValues:StringEqualsIgnoreCase": {
"cloudformation:TargetRegion": [
"us-east-1",
"us-west-2",
"eu-west-1"
]
}
}
}
]
}
```
------
## Consenti tutte le operazioni dei generatori di IaC
La seguente politica consente l'accesso alle CloudFormation azioni relative alla scansione delle risorse del generatore IaC e alla gestione dei modelli. La prima istruzione concede le autorizzazioni per descrivere, elencare e avviare scansioni delle risorse. Consente inoltre l’accesso a permessi aggiuntivi richiesti (`cloudformation:GetResource`, `cloudformation:ListResources`, e `cloudformation:ListTypes`) che consentono al generatore di IaC di recuperare informazioni sulle risorse e sui tipi di risorse disponibili. La seconda istruzione concede le autorizzazioni complete per creare, eliminare, descrivere, elencare e aggiornare i modelli generati.
È inoltre necessario concedere le autorizzazioni di lettura per i AWS servizi di destinazione a chiunque esegua la scansione delle risorse con il generatore IaC. Per ulteriori informazioni, consulta [Autorizzazioni IAM richieste per la scansione delle risorse](generate-IaC.md#iac-generator-permissions).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Sid":"ResourceScanningOperations",
"Effect":"Allow",
"Action":[
"cloudformation:DescribeResourceScan",
"cloudformation:GetResource",
"cloudformation:ListResources",
"cloudformation:ListResourceScanRelatedResources",
"cloudformation:ListResourceScanResources",
"cloudformation:ListResourceScans",
"cloudformation:ListTypes",
"cloudformation:StartResourceScan"
],
"Resource":"*"
},
{
"Sid":"TemplateGeneration",
"Effect":"Allow",
"Action":[
"cloudformation:CreateGeneratedTemplate",
"cloudformation:DeleteGeneratedTemplate",
"cloudformation:DescribeGeneratedTemplate",
"cloudformation:GetResource",
"cloudformation:GetGeneratedTemplate",
"cloudformation:ListGeneratedTemplates",
"cloudformation:UpdateGeneratedTemplate"
],
"Resource":"*"
}
]
}
```
------
# AWS politiche gestite per AWS CloudFormation
Una politica AWS gestita è una politica autonoma creata e amministrata da AWS. AWS le politiche gestite sono progettate per fornire autorizzazioni per molti casi d'uso comuni, in modo da poter iniziare ad assegnare autorizzazioni a utenti, gruppi e ruoli.
Tieni presente che le policy AWS gestite potrebbero non concedere le autorizzazioni con il privilegio minimo per i tuoi casi d'uso specifici, poiché sono disponibili per tutti i clienti. AWS Si consiglia pertanto di ridurre ulteriormente le autorizzazioni definendo [policy gestite dal cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#customer-managed-policies) specifiche per i propri casi d'uso.
Non è possibile modificare le autorizzazioni definite nelle politiche gestite. AWS Se AWS aggiorna le autorizzazioni definite in una politica AWS gestita, l'aggiornamento ha effetto su tutte le identità principali (utenti, gruppi e ruoli) a cui è associata la politica. AWS è più probabile che aggiorni una policy AWS gestita quando viene lanciato un nuovo AWS servizio o quando nuove operazioni API diventano disponibili per i servizi esistenti.
Per ulteriori informazioni, consultare [Policy gestite da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) nella *Guida per l'utente di IAM*.
## AWS politica gestita: AWSCloud FormationFullAccess
È possibile associare la policy `AWSCloudFormationFullAccess` a utenti, gruppi e ruoli.
Questa politica concede autorizzazioni che consentono l'accesso completo ad CloudFormation azioni e risorse.
**Dettagli delle autorizzazioni**
Questa policy include le seguenti autorizzazioni:
+ `cloudformation`— Consente ai mandanti di eseguire tutte le CloudFormation azioni su tutte le risorse.
Per visualizzare le autorizzazioni per questa policy, consulta [AWSCloudFormationFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSCloudFormationFullAccess.html)la *AWS Managed Policy Reference Guide.*
## AWS politica gestita: AWSCloud FormationReadOnlyAccess
È possibile associare la policy `AWSCloudFormationReadOnlyAccess` a utenti, gruppi e ruoli.
Questa politica concede autorizzazioni che consentono l'accesso in sola lettura a CloudFormation risorse e azioni.
**Dettagli delle autorizzazioni**
Questa policy include le seguenti autorizzazioni:
+ `cloudformation`— Consente ai mandanti di eseguire CloudFormation azioni di sola lettura come descrivere gli stack, elencare le risorse e visualizzare i modelli, ma non consente la creazione, l'aggiornamento o l'eliminazione degli stack.
*Per visualizzare le autorizzazioni relative a questa politica, consulta la Managed Policy Reference Guide. [AWSCloudFormationReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSCloudFormationReadOnlyAccess.html)AWS *
## CloudFormation aggiornamenti alle politiche AWS gestite
Visualizza i dettagli sugli aggiornamenti delle politiche AWS gestite CloudFormation da quando questo servizio ha iniziato a tenere traccia di queste modifiche. Per ricevere avvisi automatici sulle modifiche a questa pagina, iscriviti al feed RSS nella pagina della cronologia dei CloudFormation documenti.
| Modifica | Descrizione | Data |
| --- | --- | --- |
| [AWSCloudFormationReadOnlyAccess](#security-iam-awsmanpol-AWSCloudFormationReadOnlyAccess): aggiornamento a una policy esistente | CloudFormation sono state aggiunte nuove autorizzazioni per consentire `cloudformation:BatchDescribe*` azioni per le operazioni di descrizione in batch. | 30 gennaio 2026 |
| [AWSCloudFormationReadOnlyAccess](#security-iam-awsmanpol-AWSCloudFormationReadOnlyAccess): aggiornamento di una policy esistente | CloudFormation ha aggiunto nuove autorizzazioni per consentire `cloudformation:Detect*` azioni per le funzionalità di rilevamento della deriva degli stack. | 13 novembre 2019 |
| [AWSCloudFormationReadOnlyAccess](#security-iam-awsmanpol-AWSCloudFormationReadOnlyAccess): aggiornamento di una policy esistente | CloudFormation ha aggiunto nuove autorizzazioni per consentire `cloudformation:EstimateTemplateCost` e azioni. `cloudformation:Get*` `cloudformation:ValidateTemplate` | 2 Novembre 2017 |
| [AWSCloudFormationFullAccess](#security-iam-awsmanpol-AWSCloudFormationFullAccess): nuova policy | CloudFormation ha aggiunto una nuova politica AWS gestita che fornisce l'accesso completo alle CloudFormation azioni e alle risorse. | 26 luglio 2019 |
| [AWSCloudFormationReadOnlyAccess](#security-iam-awsmanpol-AWSCloudFormationReadOnlyAccess): aggiornamento di una policy esistente | CloudFormation ha aggiunto nuove autorizzazioni per consentire `cloudformation:DetectStackDrift` e `cloudformation:DetectStackResourceDrift` azioni per il rilevamento della deriva dello stack. | 6 febbraio 2019 |
| [AWSCloudFormationReadOnlyAccess](#security-iam-awsmanpol-AWSCloudFormationReadOnlyAccess): nuova policy | CloudFormation ha aggiunto una nuova policy AWS gestita che fornisce l'accesso in sola lettura ad azioni e risorse. CloudFormation | 6 febbraio 2015 |
| CloudFormation ha iniziato a tenere traccia delle modifiche | CloudFormation ha iniziato a tenere traccia delle modifiche per le sue politiche AWS gestite. | 6 febbraio 2015 |
# CloudFormation ruolo di servizio
Un *ruolo di servizio* è un ruolo AWS Identity and Access Management (IAM) che consente di CloudFormation effettuare chiamate alle risorse in uno stack per tuo conto. Puoi specificare un ruolo IAM che permette a CloudFormation di creare, aggiornare o eliminare le risorse del tuo stack. Per impostazione predefinita, CloudFormation utilizza una sessione temporanea generata dalle credenziali utente per le operazioni dello stack. Se si specifica un ruolo di servizio, CloudFormation utilizza le credenziali di quel ruolo.
Utilizza un ruolo di servizio per specificare in modo esplicito le azioni che CloudFormation è possibile eseguire, che potrebbero non essere sempre le stesse azioni eseguite da te o da altri utenti. Ad esempio, potresti avere privilegi amministrativi, ma puoi limitare CloudFormation l'accesso solo alle EC2 azioni di Amazon.
Puoi creare il ruolo del servizio e le sue policy di autorizzazione con il servizio IAM. Per ulteriori informazioni sulla creazione di un ruolo di servizio, consulta [Creare un ruolo per delegare le autorizzazioni a un AWS servizio](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) nella Guida per l'utente *IAM*. Specifica CloudFormation (`cloudformation.amazonaws.com`) come servizio che può assumere il ruolo.
Per associare un ruolo del servizio con uno stack, specifica il ruolo al momento della creazione dello stack. Per informazioni dettagliate, vedi [Configurazione delle opzioni dello stack](cfn-console-create-stack.md#configure-stack-options). Puoi anche modificare il ruolo di servizio quando aggiorni lo stack nella console o elimini lo stack tramite [https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_DeleteStack.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_DeleteStack.html) nell’API. Prima di specificare un ruolo del servizio, assicurarsi di disporre dell'autorizzazione per passarlo (`iam:PassRole`). L'autorizzazione `iam:PassRole` specifica quali ruolo puoi utilizzare. Per ulteriori informazioni, consulta [Concedere a un utente le autorizzazioni per passare un ruolo a un AWS servizio](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html) nella Guida per l'utente *IAM*.
**Importante**
Quando specifichi un ruolo di servizio, utilizza CloudFormation sempre quel ruolo per tutte le operazioni eseguite su quello stack. Non è possibile rimuovere un ruolo di servizio collegato a uno stack dopo la creazione dello stack. Altri utenti che dispongono delle autorizzazioni per eseguire operazioni su questo stack potranno usare questo ruolo, indipendentemente dal fatto che dispongano o meno dell’autorizzazione `iam:PassRole`. Se il ruolo include le autorizzazioni di cui l'utente non dovrebbe disporre, puoi riassegnare involontariamente le autorizzazioni di un utente. Assicurati che il ruolo garantisca i privilegi minimi. Per ulteriori informazioni, consulta [Applicazione delle autorizzazioni del privilegio minimo](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) nella *Guida per l'utente di IAM*.
# Prevenzione del problema "confused deputy" tra servizi
Il problema confused deputy è un problema di sicurezza in cui un’entità che non dispone dell’autorizzazione per eseguire un’azione può costringere un’entità maggiormente privilegiata a eseguire l’azione. Nel frattempo AWS, l'impersonificazione tra diversi servizi può portare alla confusione del problema del vicesceriffo. La rappresentazione tra servizi può verificarsi quando un servizio (il *servizio chiamante*) effettua una chiamata a un altro servizio (il *servizio chiamato*). Il servizio chiamante può essere manipolato per utilizzare le proprie autorizzazioni e agire sulle risorse di un altro cliente, a cui normalmente non avrebbe accesso. Per evitare che ciò accada, AWS mette a disposizione strumenti che consentono di proteggere i dati relativi a tutti i servizi con responsabili del servizio a cui è stato concesso l'accesso alle risorse del vostro account.
Ti consigliamo di utilizzare le chiavi di contesto [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourcearn)e [https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html#condition-keys-sourceaccount)global condition nelle politiche delle risorse per limitare le autorizzazioni che CloudFormation forniscono un altro servizio a una risorsa specifica, ad esempio un' CloudFormation estensione. Utilizzare `aws:SourceArn` se si desidera consentire l’associazione di una sola risorsa all’accesso tra servizi. Utilizzare `aws:SourceAccount` se si desidera consentire l’associazione di qualsiasi risorsa in tale account all’uso tra servizi.
Assicurati che il valore di `aws:SourceArn` sia un ARN della risorsa archiviata. CloudFormation
Il modo più efficace per proteggersi dal problema "confused deputy" è quello di usare la chiave di contesto della condizione globale `aws:SourceArn` con l’ARN completo della risorsa. Se non si conosce l’ARN completo della risorsa o si scelgono più risorse, è necessario utilizzare la chiave di contesto della condizione globale `aws:SourceArn` con caratteri jolly (`*`) per le parti sconosciute dell’ARN. Ad esempio, `arn:aws:cloudformation:*:123456789012:*`.
Se il valore `aws:SourceArn`non contiene l’ID account devi utilizzare entrambe le chiavi di contesto delle condizioni globali per limitare le autorizzazioni.
L'esempio seguente mostra come utilizzare le chiavi di contesto `aws:SourceArn` e `aws:SourceAccount` global condition CloudFormation per evitare il confuso problema del vice.
## Esempio di policy di attendibilità che utilizza le chiavi di condizione `aws:SourceArn` e `aws:SourceAccount`
Per i servizi di registro, CloudFormation effettua chiamate a AWS Security Token Service (AWS STS) per assumere un ruolo di servizio nell'account. Questo ruolo è configurato per `ExecutionRoleArn` nell’operazione [https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_RegisterType.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_RegisterType.html) e `LogRoleArn` impostato nell’operazione [https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_LoggingConfig.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_LoggingConfig.html). Per ulteriori informazioni, consulta [Configura un ruolo di esecuzione con autorizzazioni IAM e una policy di fiducia per l’accesso alle estensioni pubbliche](registry-public.md#registry-public-enable-execution-role).
Questo esempio di politica di fiducia dei ruoli utilizza istruzioni condizionali per limitare la `AssumeRole` capacità del ruolo di servizio alle sole azioni sull' CloudFormation estensione specificata nell'account specificato. Le condizioni `aws:SourceArn` e `aws:SourceAccount` sono valutate in modo indipendente. Qualsiasi richiesta di utilizzare il ruolo di servizio deve soddisfare entrambe le condizioni.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"resources.cloudformation.amazonaws.com"
]
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "123456789012"
},
"ArnLike": {
"aws:SourceArn": "arn:aws:cloudformation:us-east-1:123456789012:type/resource/Organization-Service-Resource"
}
}
}
]
}
```
------
## Informazioni aggiuntive
Ad esempio, le politiche che utilizzano `aws:SourceArn` le chiavi di contesto della condizione `aws:SourceAccount` globale per un ruolo di servizio utilizzato da StackSets, vedere[Configurazione di chiavi globali per mitigare i problemi di "confused deputy"](stacksets-prereqs-self-managed.md#confused-deputy-mitigation).
Per ulteriori informazioni, consulta [Update a role trust policy](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_update-role-trust-policy.html) nella *Guida per l’utente IAM*.
# Richieste di inoltro delle sessioni di accesso (FAS) e valutazione delle autorizzazioni
Durante la creazione, l'aggiornamento e l'eliminazione degli CloudFormation stack, gli utenti possono facoltativamente specificare un ARN del ruolo IAM. Se non viene fornito alcun ruolo, CloudFormation utilizza il meccanismo di servizio predefinito per interagire con altri servizi. AWS In questo scenario, il chiamante deve disporre delle autorizzazioni necessarie per le risorse da gestire. In alternativa, quando un utente fornisce il proprio ruolo IAM, CloudFormation assumerà tale ruolo per eseguire le interazioni di servizio per suo conto.
Indipendentemente dal fatto che l'utente fornisca o meno un ruolo IAM, CloudFormation genera un nuovo token FAS con estensione limitata per ogni operazione sulle risorse. Di conseguenza, le [chiavi di condizione relative al FAS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_forward_access_sessions.html#access_fas_policy_conditions), incluso `aws:ViaAWSService`, vengono compilate in entrambi gli scenari.
L'uso del FAS influisce sul modo in cui le politiche IAM vengono valutate durante le operazioni. CloudFormation Quando si crea uno stack con un modello che include risorse interessate dalle chiavi di condizione relative al FAS, può verificarsi un rifiuto delle autorizzazioni.
**Policy IAM di esempio**
Considera la seguente politica IAM. `Statement2`impedirà costantemente la creazione di una `AWS::KMS::Key` risorsa in CloudFormation. La restrizione verrà applicata in modo coerente, a prescindere dal fatto che venga fornito o meno un ruolo IAM durante l’operazione di stack. Questo perché la chiave di condizione `aws:ViaAWSService` è sempre impostata su `true` per via dell’uso del FAS.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Statement1",
"Effect": "Allow",
"Action": [
"kms:CreateKey"
],
"Resource": [
"*"
]
},
{
"Sid": "Statement2",
"Effect": "Deny",
"Action": [
"kms:CreateKey"
],
"Resource": [
"*"
],
"Condition": {
"Bool": {
"aws:ViaAWSService": "true"
}
}
}
]
}
```
------
**Modello stack di esempio**
Ad esempio, quando un utente crea uno stack con il seguente modello di esempio, `aws:ViaAWSService` viene impostato su `true` e le autorizzazioni di ruolo verranno sostituite dalla policy FAS. La creazione dello stack sarà influenzata dallo `Statement2` della policy IAM, che nega l’azione `CreateKey`. Ciò si traduce in un errore di autorizzazione negata.
```
Resources:
myPrimaryKey:
Type: AWS::KMS::Key
Properties:
Description: An example multi-Region primary key
KeyPolicy:
Version: '2012-10-17'
Id: key-default-1
Statement:
- Sid: Enable IAM User Permissions
Effect: Allow
Principal:
AWS: !Join
- ''
- - 'arn:aws:iam::'
- !Ref AWS::AccountId
- ':root'
Action: kms:*
Resource: '*'
```
Per ulteriori informazioni sul FAS, consultare [Forward access sessions](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_forward_access_sessions.html) nella *Guida per l’utente di IAM*.
**Nota**
La maggior parte delle risorse segue questo comportamento. Tuttavia, se riscontri un esito positivo o negativo inaspettato durante la creazione, l’aggiornamento o l’eliminazione di una risorsa e la tua policy IAM include chiavi di condizione relative al FAS, è probabile che la risorsa in questione appartenga a un piccolo sottoinsieme di risorse che non seguono questo modello standard.
# Registrazione delle chiamate CloudFormation API con AWS CloudTrail
CloudFormation è integrato con AWS CloudTrail, un servizio che fornisce una registrazione delle azioni intraprese da un utente, ruolo o AWS servizio in CloudFormation. CloudTrail acquisisce tutte le chiamate API relative CloudFormation agli eventi, incluse le chiamate dalla CloudFormation console e le chiamate in codice a. CloudFormation APIs Se crei un trail, puoi abilitare la distribuzione continua di CloudTrail eventi a un bucket Amazon S3, inclusi gli eventi per. CloudFormation Se non configuri un percorso, puoi comunque visualizzare gli eventi più recenti nella CloudTrail console nella cronologia degli **eventi**. Utilizzando le informazioni raccolte da CloudTrail, puoi determinare a quale richiesta è stata inviata CloudFormation, l'indirizzo IP da cui è stata effettuata, chi ha effettuato la richiesta, quando è stata effettuata e dettagli aggiuntivi.
Per ulteriori informazioni CloudTrail, consulta la [Guida AWS CloudTrail per l'utente](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).
**Topics**
+ [CloudFormation informazioni in CloudTrail](#cloudformation_info_in_cloudtrail)
+ [Comprensione delle CloudFormation voci dei file di registro](#understanding_cloudformation_entries)
## CloudFormation informazioni in CloudTrail
CloudTrail è abilitato sul tuo AWS account al momento della creazione dell'account. Quando si verifica un'attività in CloudFormation, tale attività viene registrata in un CloudTrail evento insieme ad altri eventi AWS di servizio nella **cronologia degli eventi**. È possibile visualizzare, cercare e scaricare gli eventi recenti nell'account AWS . Per ulteriori informazioni, consulta [Visualizzazione degli eventi con la cronologia degli CloudTrail eventi](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html).
Per una registrazione continua degli eventi nel tuo AWS account, inclusi gli eventi di CloudFormation, crea un percorso. Un trail consente di CloudTrail inviare file di log a un bucket Amazon S3. Per impostazione predefinita, quando si crea un trail nella console, il trail sarà valido in tutte le Regioni . Il trail registra gli eventi di tutte le regioni della AWS partizione e consegna i file di log al bucket Amazon S3 specificato. Inoltre, puoi configurare altri AWS servizi per analizzare ulteriormente e agire in base ai dati sugli eventi raccolti nei log. CloudTrail Per ulteriori informazioni, consulta:
+ [Panoramica della creazione di un percorso](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html)
+ [CloudTrail servizi e integrazioni supportati](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-aws-service-specific-topics.html#cloudtrail-aws-service-specific-topics-integrations)
+ [Configurazione delle notifiche Amazon SNS per CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/configure-sns-notifications-for-cloudtrail.html)
+ [Ricezione di file di CloudTrail registro da più regioni](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/receive-cloudtrail-log-files-from-multiple-regions.html) e [ricezione di file di CloudTrail registro da](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html) più account
Tutte CloudFormation le azioni vengono registrate CloudTrail e documentate nell'[https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_Operations.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_Operations.html) Reference. Ad esempio, le chiamate alle `ListStacks` sezioni `CreateStack``DeleteStack`, e generano voci nei file di CloudTrail registro.
Ogni evento o voce di log contiene informazioni sull’utente che ha generato la richiesta. Le informazioni di identità consentono di determinare quanto segue:
+ Se la richiesta è stata effettuata con le credenziali dell'utente IAM o root.
+ Se la richiesta è stata effettuata con le credenziali di sicurezza temporanee per un ruolo o un utente federato.
+ Se la richiesta è stata effettuata da un altro AWS servizio.
Per ulteriori informazioni, consulta [Elemento CloudTrail userIdentity](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-user-identity.html).
## Comprensione delle CloudFormation voci dei file di registro
Un trail è una configurazione che consente la distribuzione di eventi come file di log in un bucket Amazon S3 specificato dall'utente. CloudTrail i file di registro contengono una o più voci di registro. Un evento rappresenta una singola richiesta proveniente da qualsiasi fonte e include informazioni sull'operazione richiesta, la data e l'ora dell'operazione, i parametri della richiesta e così via. CloudTrail i file di registro non sono una traccia stack ordinata delle chiamate API pubbliche, quindi non vengono visualizzati in un ordine specifico.
L'esempio seguente mostra una voce di CloudTrail registro che dimostra l'`CreateStack`operazione. L'operazione è stata effettuata da un utente IAM di nome Alice.
**Nota**
Solo i nomi delle chiavi dei parametri di input vengono registrati. I valori dei parametri non vengono registrati.
```
{
"eventVersion": "1.01",
"userIdentity": {
"type": "IAMUser",
"principalId": "AIDAABCDEFGHIJKLNMOPQ",
"arn": "arn:aws:iam::012345678910:user/Alice",
"accountId": "012345678910",
"accessKeyId": "AKIDEXAMPLE",
"userName": "Alice"
},
"eventTime": "2014-03-24T21:02:43Z",
"eventSource": "cloudformation.amazonaws.com",
"eventName": "CreateStack",
"awsRegion": "us-east-1",
"sourceIPAddress": "127.0.0.1",
"userAgent": "aws-cli/1.2.11 Python/2.7.4 Linux/2.6.18-164.el5",
"requestParameters": {
"templateURL": "templateURL",
"tags": [
{
"key": "test",
"value": "tag"
}
],
"stackName": "my-test-stack",
"disableRollback": true,
"parameters": [
{
"parameterKey": "password"
},
{
"parameterKey": "securitygroup"
}
]
},
"responseElements": {
"stackId": "arn:aws:cloudformation:us-east-1:012345678910:stack/my-test-stack/a38e6a60-b397-11e3-b0fc-08002755629e"
},
"requestID": "9f960720-b397-11e3-bb75-a5b75389b02d",
"eventID": "9bf6cfb8-83e1-4589-9a70-b971e727099b"
}
```
Il seguente esempio mostra che Alice ha chiamato l'operazione `UpdateStack` sullo stack `my-test-stack`:
```
{
"eventVersion": "1.01",
"userIdentity": {
"type": "IAMUser",
"principalId": "AIDAABCDEFGHIJKLNMOPQ",
"arn": "arn:aws:iam::012345678910:user/Alice",
"accountId": "012345678910",
"accessKeyId": "AKIDEXAMPLE",
"userName": "Alice"
},
"eventTime": "2014-03-24T21:04:29Z",
"eventSource": "cloudformation.amazonaws.com",
"eventName": "UpdateStack",
"awsRegion": "us-east-1",
"sourceIPAddress": "127.0.0.1",
"userAgent": "aws-cli/1.2.11 Python/2.7.4 Linux/2.6.18-164.el5",
"requestParameters": {
"templateURL": "templateURL",
"parameters": [
{
"parameterKey": "password"
},
{
"parameterKey": "securitygroup"
}
],
"stackName": "my-test-stack"
},
"responseElements": {
"stackId": "arn:aws:cloudformation:us-east-1:012345678910:stack/my-test-stack/a38e6a60-b397-11e3-b0fc-08002755629e"
},
"requestID": "def0bf5a-b397-11e3-bb75-a5b75389b02d",
"eventID": "637707ce-e4a3-4af1-8edc-16e37e851b17"
}
```
Il seguente esempio mostra che Alice ha chiamato l'operazione `ListStacks`.
```
{
"eventVersion": "1.01",
"userIdentity": {
"type": "IAMUser",
"principalId": "AIDAABCDEFGHIJKLNMOPQ",
"arn": "arn:aws:iam::012345678910:user/Alice",
"accountId": "012345678910",
"accessKeyId": "AKIDEXAMPLE",
"userName": "Alice"
},
"eventTime": "2014-03-24T21:03:16Z",
"eventSource": "cloudformation.amazonaws.com",
"eventName": "ListStacks",
"awsRegion": "us-east-1",
"sourceIPAddress": "127.0.0.1",
"userAgent": "aws-cli/1.2.11 Python/2.7.4 Linux/2.6.18-164.el5",
"requestParameters": null,
"responseElements": null,
"requestID": "b7d351d7-b397-11e3-bb75-a5b75389b02d",
"eventID": "918206d0-7281-4629-b778-b91eb0d83ce5"
}
```
Il seguente esempio mostra che Alice ha chiamato l'operazione `DescribeStacks` sullo stack `my-test-stack`.
```
{
"eventVersion": "1.01",
"userIdentity": {
"type": "IAMUser",
"principalId": "AIDAABCDEFGHIJKLNMOPQ",
"arn": "arn:aws:iam::012345678910:user/Alice",
"accountId": "012345678910",
"accessKeyId": "AKIDEXAMPLE",
"userName": "Alice"
},
"eventTime": "2014-03-24T21:06:15Z",
"eventSource": "cloudformation.amazonaws.com",
"eventName": "DescribeStacks",
"awsRegion": "us-east-1",
"sourceIPAddress": "127.0.0.1",
"userAgent": "aws-cli/1.2.11 Python/2.7.4 Linux/2.6.18-164.el5",
"requestParameters": {
"stackName": "my-test-stack"
},
"responseElements": null,
"requestID": "224f2586-b398-11e3-bb75-a5b75389b02d",
"eventID": "9e5b2fc9-1ba8-409b-9c13-587c2ea940e2"
}
```
Il seguente esempio mostra che Alice ha chiamato l'operazione `DeleteStack` sullo stack `my-test-stack`.
```
{
"eventVersion": "1.01",
"userIdentity": {
"type": "IAMUser",
"principalId": "AIDAABCDEFGHIJKLNMOPQ",
"arn": "arn:aws:iam::012345678910:user/Alice",
"accountId": "012345678910",
"accessKeyId": "AKIDEXAMPLE",
"userName": "Alice"
},
"eventTime": "2014-03-24T21:07:15Z",
"eventSource": "cloudformation.amazonaws.com",
"eventName": "DeleteStack",
"awsRegion": "us-east-1",
"sourceIPAddress": "127.0.0.1",
"userAgent": "aws-cli/1.2.11 Python/2.7.4 Linux/2.6.18-164.el5",
"requestParameters": {
"stackName": "my-test-stack"
},
"responseElements": null,
"requestID": "42dae739-b398-11e3-bb75-a5b75389b02d",
"eventID": "4965eb38-5705-4942-bb7f-20ebe79aa9aa"
}
```
# Sicurezza dell'infrastruttura in CloudFormation
In quanto servizio gestito, AWS CloudFormation è protetto dalla sicurezza di rete AWS globale. Per informazioni sui servizi AWS di sicurezza e su come AWS protegge l'infrastruttura, consulta [AWS Cloud Security](https://aws.amazon.com/security/). Per progettare il tuo AWS ambiente utilizzando le migliori pratiche per la sicurezza dell'infrastruttura, vedi [Infrastructure Protection](https://docs.aws.amazon.com/wellarchitected/latest/security-pillar/infrastructure-protection.html) in *Security Pillar AWS Well‐Architected* Framework.
Utilizzate chiamate API AWS pubblicate per accedere CloudFormation attraverso la rete. I client devono supportare quanto segue:
+ Transport Layer Security (TLS). È richiesto TLS 1.2 ed è consigliato TLS 1.3.
+ Suite di cifratura con Perfect Forward Secrecy (PFS), ad esempio Ephemeral Diffie-Hellman (DHE) o Elliptic Curve Ephemeral Diffie-Hellman (ECDHE). La maggior parte dei sistemi moderni, come Java 7 e versioni successive, supporta tali modalità.
Puoi richiamare queste operazioni API da qualsiasi posizione di rete, CloudFormation ma supportano politiche di accesso basate sulle risorse, che possono includere restrizioni basate sull'indirizzo IP di origine. Puoi anche utilizzare CloudFormation le policy per controllare l'accesso da endpoint Amazon Virtual Private Cloud (Amazon VPC) specifici o specifici. VPCs In effetti, questo isola l'accesso alla rete a una determinata CloudFormation risorsa solo dal VPC specifico all'interno AWS della rete.
# Resilienza in CloudFormation
L'infrastruttura AWS globale è costruita attorno a AWS regioni e zone di disponibilità. AWS Le regioni forniscono più zone di disponibilità fisicamente separate e isolate, collegate con reti a bassa latenza, ad alto throughput e altamente ridondanti. Con le zone di disponibilità è possibile progettare e gestire applicazioni e database che eseguono automaticamente il failover tra zone di disponibilità senza interruzioni. Le zone di disponibilità sono più disponibili, tolleranti ai guasti e scalabili rispetto alle infrastrutture a data center singolo o multiplo tradizionali.
[Per ulteriori informazioni su AWS regioni e zone di disponibilità, consulta Global Infrastructure.AWS](https://aws.amazon.com/about-aws/global-infrastructure/)
# Convalida della conformità per CloudFormation
Per sapere se un Servizio AWS programma rientra nell'ambito di specifici programmi di conformità, consulta Servizi AWS la sezione [Scope by Compliance Program Servizi AWS](https://aws.amazon.com/compliance/services-in-scope/) e scegli il programma di conformità che ti interessa. Per informazioni generali, consulta Programmi di [AWS conformità Programmi](https://aws.amazon.com/compliance/programs/) di di .
È possibile scaricare report di audit di terze parti utilizzando AWS Artifact. Per ulteriori informazioni, consulta [Scaricamento dei report in AWS Artifact](https://docs.aws.amazon.com/artifact/latest/ug/downloading-documents.html) .
La vostra responsabilità di conformità durante l'utilizzo Servizi AWS è determinata dalla sensibilità dei dati, dagli obiettivi di conformità dell'azienda e dalle leggi e dai regolamenti applicabili. Per ulteriori informazioni sulla responsabilità di conformità durante l'utilizzo Servizi AWS, consulta la [Documentazione AWS sulla sicurezza](https://docs.aws.amazon.com/security/).
# Analisi della configurazione e delle vulnerabilità in CloudFormation
La configurazione e i controlli IT sono una responsabilità condivisa tra voi AWS e voi, nostri clienti. Per ulteriori informazioni, consulta il [modello di responsabilità AWS condivisa](https://aws.amazon.com/compliance/shared-responsibility-model/).
# Best practice di sicurezza per CloudFormation
CloudFormation fornisce una serie di funzionalità di sicurezza da considerare durante lo sviluppo e l'implementazione delle proprie politiche di sicurezza. Le seguenti best practice sono linee guida generali e non rappresentano una soluzione di sicurezza completa. Poiché queste best practice potrebbero non essere appropriate o sufficienti per l’ambiente, sono da considerare come considerazioni utili anziché prescrizioni.
**Topics**
+ [Utilizza IAM per controllare gli accessi](#use-iam-to-control-access)
+ [Non incorporare le credenziali nei modelli](#creds)
+ [Utilizzato AWS CloudTrail per registrare CloudFormation le chiamate](#cloudtrail)
## Utilizza IAM per controllare gli accessi
IAM è un AWS servizio che puoi utilizzare per gestire gli utenti e le relative autorizzazioni. AWS Puoi utilizzare IAM con CloudFormation per specificare quali CloudFormation azioni gli utenti possono eseguire, come visualizzare modelli di stack, creare stack o eliminare stack. Inoltre, chiunque gestisca gli CloudFormation stack richiederà le autorizzazioni per le risorse all'interno di tali stack. Ad esempio, se gli utenti desiderano avviare, aggiornare o chiudere EC2 le istanze Amazon, devono avere l'autorizzazione a richiamare le azioni Amazon EC2 pertinenti. CloudFormation
Nella maggior parte dei casi, gli utenti richiedono l'accesso completo per gestire tutte le risorse in un modello. CloudFormation esegue chiamate per creare, modificare ed eliminare tali risorse per conto degli utenti. Per separare le autorizzazioni tra un utente e il CloudFormation servizio, utilizza un ruolo di servizio. CloudFormation utilizza la politica del ruolo di servizio per effettuare chiamate anziché la politica dell'utente. Per ulteriori informazioni, consulta [CloudFormation ruolo di servizio](using-iam-servicerole.md).
## Non incorporare le credenziali nei modelli
Invece di incorporare informazioni sensibili nei CloudFormation modelli, consigliamo di utilizzare *riferimenti dinamici* nel modello di stack.
I riferimenti dinamici offrono un modo compatto e potente per fare riferimento a valori esterni archiviati e gestiti in altri servizi, come AWS Systems Manager Parameter Store o AWS Secrets Manager. Quando si utilizza un riferimento dinamico, CloudFormation recupera il valore del riferimento specificato quando necessario durante le operazioni di stack e change set e passa il valore alla risorsa appropriata. Tuttavia, CloudFormation non memorizza mai il valore di riferimento effettivo. Per ulteriori informazioni, consulta [Ottenimento di valori archiviati in altri servizi utilizzando riferimenti dinamici](dynamic-references.md).
[AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) consente di crittografare, archiviare e utilizzare in modo sicuro le credenziali per database e altri servizi.AWS Archivio parametri di [ Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html) fornisce uno storage sicuro e gerarchico per la gestione dei dati di configurazione.
Per ulteriori informazioni sulla definizione dei parametri del modello, consulta [CloudFormation Parameterssintassi del modello](parameters-section-structure.md).
## Utilizzato AWS CloudTrail per registrare CloudFormation le chiamate
AWS CloudTrail tiene traccia di chiunque effettui chiamate CloudFormation API nel tuo Account AWS. Le chiamate API vengono registrate ogni volta che qualcuno utilizza l' CloudFormation API, la CloudFormation console, una console di back-end o i comandi. CloudFormation AWS CLI Attivare la registrazione e specificare un bucket Amazon S3 in cui archiviare i log. In questo modo, in caso di necessità, puoi controllare chi ha effettuato quale chiamata CloudFormation nel tuo account. Per ulteriori informazioni, consulta [Registrazione delle chiamate CloudFormation API con AWS CloudTrail](cfn-api-logging-cloudtrail.md).
# Accesso CloudFormation tramite un endpoint di interfaccia ()AWS PrivateLink
Puoi usarlo AWS PrivateLink per creare una connessione privata tra il tuo VPC e. CloudFormation Puoi accedere CloudFormation come se fosse nel tuo VPC, senza l'uso di un gateway Internet, un dispositivo NAT, una connessione VPN o una connessione. Direct Connect Le istanze del tuo VPC non necessitano di indirizzi IP pubblici per accedervi. CloudFormation
Stabilisci questa connessione privata creando un *endpoint di interfaccia* attivato da AWS PrivateLink. In ciascuna sottorete viene creata un'interfaccia di rete endpoint da abilitare per l'endpoint di interfaccia. Queste sono interfacce di rete gestite dal richiedente che fungono da punto di ingresso per il traffico destinato a CloudFormation.
CloudFormation supporta l'effettuazione di chiamate a tutte le sue azioni API tramite l'endpoint dell'interfaccia.
## Considerazioni sugli endpoint CloudFormation VPC
*Prima di configurare un endpoint di interfaccia, assicurati di aver soddisfatto i prerequisiti nell'argomento [Accedere a un AWS servizio utilizzando un endpoint VPC](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html) con interfaccia nella Guida.AWS PrivateLink *
I seguenti prerequisiti e considerazioni aggiuntivi si applicano alla configurazione di un endpoint di interfaccia per: CloudFormation
+ Se hai risorse all'interno del tuo VPC che devono rispondere a una richiesta di risorse personalizzata o a una condizione di attesa, assicurati che abbiano accesso ai bucket Amazon CloudFormation S3 specifici richiesti. CloudFormation [dispone di bucket S3 in ogni regione per monitorare le risposte a una richiesta di [risorse personalizzata](template-custom-resources.md) o a una condizione di attesa.](using-cfn-waitcondition.md) Se un modello include risorse personalizzate o condizioni di attesa in un VPC, la policy di endpoint VPC deve consentire agli utenti di inviare risposte ai seguenti bucket:
+ Per le risorse personalizzate, consenti il traffico verso il bucket `cloudformation-custom-resource-response-region`. Quando si utilizzano risorse personalizzate, Regione AWS i nomi non contengono trattini. Ad esempio, `uswest2`.
+ Per le condizioni di attesa, consenti il traffico verso il bucket `cloudformation-waitcondition-region`. Quando si utilizzano le condizioni di attesa, Regione AWS i nomi contengono trattini. Ad esempio, `us-west-2`.
Se la policy dell'endpoint blocca il traffico verso questi bucket, CloudFormation non riceverà risposte e l'operazione stack avrà esito negativo. Ad esempio, se disponi di una risorsa in un VPC nella Regione `us-west-2` che deve rispondere a una condizione di attesa, la risorsa deve essere in grado di inviare una risposta al bucket `cloudformation-waitcondition-us-west-2`.
Per un elenco di Regioni AWS dove CloudFormation è attualmente disponibile, consulta la pagina degli [CloudFormation endpoint e delle quote](https://docs.aws.amazon.com/general/latest/gr/cfn.html) nel. *Riferimenti generali di Amazon Web Services*
+ Gli endpoint VPC attualmente non supportano le richieste interregionali: assicurati di creare l'endpoint nella stessa regione in cui intendi effettuare le chiamate API. CloudFormation
+ Gli endpoint VPC supportano solo il DNS fornito da Amazon tramite Route 53. Se si desidera utilizzare il proprio DNS, è possibile usare l'inoltro condizionale sul DNS. Per ulteriori informazioni, consulta [DHCP options sets in Amazon VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html) nella Guida per l’utente di Amazon VPC.
+ Il gruppo di sicurezza collegato all'endpoint VPC deve consentire le connessioni in entrata sulla porta 443 dalla sottorete privata del VPC.
## Creazione di un endpoint VPC di interfaccia per CloudFormation
Puoi creare un endpoint VPC per CloudFormation utilizzare la console Amazon VPC o (). AWS Command Line Interface AWS CLI Per ulteriori informazioni, consulta la sezione [Creazione di un endpoint VPC](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#create-interface-endpoint-aws) nella *Guida di AWS PrivateLink *.
Crea un endpoint di interfaccia per CloudFormation utilizzare il seguente nome di servizio:
+ **com.amazonaws. *region*.cloudformation**: crea un endpoint per le operazioni API. CloudFormation
Se abiliti il DNS privato per l'endpoint dell'interfaccia, puoi effettuare richieste API CloudFormation utilizzando il nome DNS regionale predefinito. Ad esempio, `cloudformation.us-east-1.amazonaws.com`.
Regioni AWS Laddove sono supportati endpoint specifici per FIPS, puoi anche creare un endpoint di interfaccia per utilizzare il seguente nome di servizio: CloudFormation
+ **com.amazonaws. ***region*[.cloudformation-fips: crea un endpoint per l' CloudFormation API conforme al Federal Information Processing Standard (FIPS) 140-2.](https://aws.amazon.com/compliance/fips/)
[Per un elenco completo degli endpoint, consulta endpoint e quote nel. CloudFormation CloudFormation*Riferimenti generali di Amazon Web Services*](https://docs.aws.amazon.com/general/latest/gr/cfn.html)
## Creazione di una policy per gli endpoint VPC per CloudFormation
Una policy dell’endpoint è una risorsa IAM che è possibile allegare all’endpoint dell’interfaccia. La policy predefinita per gli endpoint consente l'accesso completo CloudFormation tramite l'interfaccia endpoint. Per controllare l'accesso consentito CloudFormation dal tuo VPC, collega una policy endpoint personalizzata all'endpoint di interfaccia.
Una policy di endpoint specifica le informazioni riportate di seguito:
+ I principali che possono eseguire azioni (Account AWS, utenti IAM e ruoli IAM).
+ Le azioni che possono essere eseguite.
+ Le risorse in cui è possibile eseguire le operazioni.
Per ulteriori informazioni, consulta [Control access to VPC endpoints using endpoint policies](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html) nella *Guida di AWS PrivateLink *.
**Esempio: policy degli endpoint VPC per le azioni CloudFormation**
Di seguito è riportato un esempio di policy sugli endpoint per. CloudFormation Se associata a un endpoint, questa politica consente l'accesso alle CloudFormation azioni elencate per tutti i principali su tutte le risorse. L'esempio seguente nega a tutti gli utenti l'autorizzazione a creare stack tramite l'endpoint VPC e consente l'accesso completo a tutte le altre azioni sul servizio. CloudFormation
```
{
"Statement": [
{
"Action": "cloudformation:*",
"Effect": "Allow",
"Principal": "*",
"Resource": "*"
},
{
"Action": "cloudformation:CreateStack",
"Effect": "Deny",
"Principal": "*",
"Resource": "*"
}
]
}
```