# Segurança no CloudFormation
A segurança na nuvem na AWS é a nossa maior prioridade. Como cliente da AWS, você se beneficiará de data centers e arquiteturas de rede criados para atender aos requisitos das empresas com as maiores exigências de segurança.
A segurança é uma responsabilidade compartilhada entre a AWS e você. O [modelo de responsabilidade compartilhada](https://aws.amazon.com/compliance/shared-responsibility-model/) descreve isso como segurança *da* nuvem e segurança *na* nuvem:
+ **Segurança da nuvem**: a AWS é responsável pela proteção da infraestrutura que executa serviços AWS na Nuvem AWS. A AWS também fornece serviços que podem ser usados com segurança. Auditores de terceiros testam e verificam regularmente a eficácia da nossa segurança como parte dos [Programas de conformidade da AWS](https://aws.amazon.com/compliance/programs/). Para saber mais sobre os programas de conformidade que se aplicam ao CloudFormation, consulte [Serviços da AWS em escopo por programa de conformidade](https://aws.amazon.com/compliance/services-in-scope/).
+ **Segurança na nuvem**: sua responsabilidade é determinada pelo serviço da AWS que você usa. Você também é responsável por outros fatores, incluindo a confidencialidade de seus dados, os requisitos da empresa e as leis e regulamentos aplicáveis.
Esta documentação ajuda a entender como aplicar o modelo de responsabilidade compartilhada ao usar o .CloudFormation Os tópicos a seguir mostram como configurar o CloudFormation para atender aos seus objetivos de segurança e conformidade. Saiba como usar outros serviços AWS que ajudam a monitorar e proteger os recursos do CloudFormation.
**Topics**
+ [Proteger pilhas do CloudFormation contra exclusão](using-cfn-protect-stacks.md)
+ [Impedir atualizações nos recursos de pilha](protect-stack-resources.md)
+ [Proteção de dados no CloudFormation](security-data-protection.md)
+ [Controle o acesso ao CloudFormation com o AWS Identity and Access Management](control-access-with-iam.md)
+ [Registrar em log chamadas de API do CloudFormation com o AWS CloudTrail](cfn-api-logging-cloudtrail.md)
+ [Segurança da infraestrutura no CloudFormation](infrastructure-security.md)
+ [Resiliência no CloudFormation](disaster-recovery-resiliency.md)
+ [Validação de conformidade do CloudFormation](cloudformation-compliance.md)
+ [Análise de vulnerabilidade e configuração no CloudFormation](vulnerability-analysis-and-management.md)
+ [Práticas recomendadas de segurança do CloudFormation](security-best-practices.md)
+ [Acessar o CloudFormation usando um endpoint de interface (AWS PrivateLink)](vpc-interface-endpoints.md)
# Proteger pilhas do CloudFormation contra exclusão
É possível impedir que uma pilha seja excluída acidentalmente ativando a proteção contra encerramento na pilha. Se um usuário tentar excluir uma pilha com proteção contra encerramento ativada, a exclusão falhará e a pilha, incluindo o status dela, permanecerá inalterada. É possível ativar a proteção de encerramento em uma pilha ao criá-la. A proteção contra encerramento em pilhas está desativada por padrão. Você pode definir a proteção contra encerramento em uma pilha com qualquer status, exceto `DELETE_IN_PROGRESS` ou `DELETE_COMPLETE`.
Quando a proteção contra terminação é habilitada ou desabilitada em uma pilha, a mesma opção se estende a todas as pilhas aninhadas pertencentes a ela. Você não pode ativar ou desativar a proteção contra encerramento diretamente em uma pilha aninhada. Se um usuário tentar excluir diretamente uma pilha aninhada pertencente a uma pilha que tem a proteção contra encerramento ativada, a operação falhará e a pilha aninhada permanecerá inalterada.
No entanto, se um usuário executar uma atualização da pilha que exclua a pilha aninhada, o CloudFormation excluirá a pilha aninhada apropriadamente.
A proteção contra terminação é diferente da desativação de reversão. A proteção contra encerramento se aplica apenas a tentativas de excluir pilhas, enquanto a desativação de reversão se aplica à reversão automática quando a criação da pilha falha.
**Para ativar a proteção contra encerramento ao criar uma pilha**
Na página **Specify stack options (Especificar opções da pilha)** do assistente **Create stack (Criar pilha)**, em **Advanced options (Opções avançadas)**, expanda a seção **Termination Protection (Proteção contra encerramento)** e selecione **Enable (Habilitar)**. Para obter mais informações, consulte [Configurar opções da pilha](cfn-console-create-stack.md#configure-stack-options).
**Habilitar ou desabilitar a proteção contra encerramento em uma pilha existente**
1. Faça login no Console de gerenciamento da AWS e abra o console CloudFormation em [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Na barra de navegação na parte superior da tela, escolha sua Região da AWS.
1. Selecione a pilha que você quiser.
**nota**
Se **NESTED** for exibido ao lado do nome da pilha, a pilha é aninhada. Só é possível alterar a proteção contra encerramento na pilha raiz à qual a pilha aninhada pertence.
1. No painel de detalhes da pilha, selecione **Stack actions (Ações da pilha)** e **Edit termination protection (Editar a proteção contra encerramento)**.
O CloudFormation exibe a caixa de diálogo **Editar a proteção contra encerramento**.
1. Escolha **Enable (Habilitar)** ou **Disable (Desabilitar)** e selecione **Save (Salvar)**.
**Habilitar ou desabilitar a proteção contra encerramento em uma pilha aninhada**
Se **NESTED** for exibido ao lado do nome da pilha, a pilha é aninhada. Só é possível alterar a proteção contra encerramento na pilha raiz à qual a pilha aninhada pertence. Para alterar a proteção contra encerramento na pilha raiz:
1. Faça login no Console de gerenciamento da AWS e abra o console CloudFormation em [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Na barra de navegação na parte superior da tela, escolha sua Região da AWS.
1. Selecione a pilha aninhada que você quiser.
1. No painel **Stack info (Informações da pilha)**, na seção **Overview (Visão geral)**, selecione o nome da pilha listada como **Root stack (Pilha raiz)**.
O CloudFormation exibe os detalhes da pilha raiz.
1. Escolha **Stack actions (Ações da pilha)** e selecione **Edit Termination Protection (Editar a proteção contra encerramento)**.
O CloudFormation exibe a caixa de diálogo **Editar a proteção contra encerramento**.
1. Escolha **Enable (Habilitar)** ou **Disable (Desabilitar)** e selecione **Save (Salvar)**.
**Para habilitar ou desabilitar a proteção contra encerramento usando a linha de comando**
Use o 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).
## Controlar quem pode alterar a proteção contra encerramento em pilhas
Para habilitar ou desabilitar a proteção contra encerramento em pilhas, um usuário requer permissão para a ação `cloudformation:UpdateTerminationProtection`. Por exemplo, a política a seguir permite que os usuários ativem ou desativem a proteção contra encerramento em pilhas.
Para obter mais informações sobre como especificar permissões no CloudFormation, consulte [Controle o acesso ao CloudFormation com o AWS Identity and Access Management](control-access-with-iam.md).
**Example Um exemplo da política que concede permissões para alterar a proteção contra encerramento de pilha**
****
```
{
"Version":"2012-10-17",
"Statement":[{
"Effect":"Allow",
"Action":[
"cloudformation:UpdateTerminationProtection"
],
"Resource":"*"
}]
}
```
# Impedir atualizações nos recursos de pilha
Quando você cria uma pilha, todas as ações de atualização são permitidas em todos os recursos. Por padrão, qualquer usuário com permissões de atualização da pilha pode atualizar todos os recursos na pilha. Durante uma atualização, alguns recursos podem exigir uma interrupção ou ser completamente substituídos, o que resulta em novos IDs físicos ou armazenamento completamente novo. Você pode impedir que a pilha de recursos seja involuntariamente atualizada ou excluída durante uma atualização da pilha usando uma política de pilha. Uma política de pilha é um documento JSON que define quais ações de atualização podem ser executadas nos recursos designados.
Depois de definir uma política de pilha, todos os recursos na pilha são protegidos por padrão. Para permitir atualizações em recursos específicos, você especifica uma instrução explícita `Allow` para esses recursos em sua política de pilha. Você pode definir apenas uma política de pilha por pilha. Porém, é possível proteger vários recursos em uma única política. Uma política de pilha se aplica a todos os usuários do CloudFormation que tentarem atualizar a pilha. Você não pode associar diferentes políticas de pilha com diferentes usuários.
Uma política de pilha é aplicada somente durante as atualizações da pilha. Ela não fornece controles de acesso como uma política do AWS Identity and Access Management (IAM). Use uma política de pilha somente como um mecanismo à prova de falhas que impede atualizações acidentais em recursos de pilha específicos. Para controlar o acesso a recursos ou ações da AWS, use o IAM.
**Topics**
+ [Exemplo de política de pilha](#stack-policy-intro-example)
+ [Definir uma política de pilha](#stack-policy-reference)
+ [Configurar uma política de pilha](#protect-stack-resources-protecting)
+ [Atualizar recursos protegidos](#protect-stack-resources-updating)
+ [Modificar uma política de pilha](#protect-stack-resources-modifying)
+ [Mais exemplos de políticas de pilha](#stack-policy-samples)
## Exemplo de política de pilha
A política de pilha de exemplo a seguir impede atualizações no recurso `ProductionDatabase`:
```
{
"Statement" : [
{
"Effect" : "Allow",
"Action" : "Update:*",
"Principal": "*",
"Resource" : "*"
},
{
"Effect" : "Deny",
"Action" : "Update:*",
"Principal": "*",
"Resource" : "LogicalResourceId/ProductionDatabase"
}
]
}
```
Quando você define uma política de pilha, todos os recursos na pilha são protegidos por padrão. Para permitir atualizações em todos os recursos, adicionamos uma instrução `Allow` que permite que todas as ações em todos os recursos. Embora a instrução `Allow` especifique todos os recursos, a instrução explícita `Deny` a substitui para o recurso com o ID lógico `ProductionDatabase`. Essa instrução `Deny` impede todas as ações de atualização, como substituição ou exclusão, no recurso `ProductionDatabase`.
O elemento `Principal` é necessário, mas suporta apenas o caractere curinga (`*`), o que significa que a instrução aplica-se a todos os [principais](https://docs.aws.amazon.com/glossary/latest/reference/glos-chap.html#principal).
**nota**
Durante uma atualização de pilha, o CloudFormation atualiza recursos que dependem de outros recursos atualizados. Por exemplo, o CloudFormation atualiza um recurso que faz referência a um recurso atualizado. O CloudFormation não faz alterações físicas, como o ID de recursos, para recursos atualizados automaticamente, mas se uma política de pilha é associada a esses recursos, você deve ter permissão para atualizá-las.
## Definir uma política de pilha
Quando você cria uma pilha, nenhuma política de pilha é definida, de modo que todas as ações de atualização são permitidas em todos os recursos. Para proteger os recursos da pilha de ações de atualização, defina uma pilha de política e, em seguida, configure-a em sua pilha. Uma política de pilha é um documento JSON que define as ações de atualização de pilha do CloudFormation que os usuários do CloudFormation podem executar e os recursos que as ações se aplicam. Você pode definir a política de pilha ao criar uma pilha, especificando um arquivo de texto que contém a sua política de pilha ou digitando-a. Quando você define uma política de pilha em sua pilha, qualquer atualização não explicitamente permitida é negada por padrão.
Você define uma política de pilha com cinco elementos: `Effect`, `Action`, `Principal`, `Resource` e `Condition`. O pseudocódigo a seguir mostra a sintaxe da política de pilha.
```
{
"Statement" : [
{
"Effect" : "Deny_or_Allow",
"Action" : "update_actions",
"Principal" : "*",
"Resource" : "LogicalResourceId/resource_logical_ID",
"Condition" : {
"StringEquals_or_StringLike" : {
"ResourceType" : [resource_type, ...]
}
}
}
]
}
```
`Effect`
Determina se as ações que você especifica são negadas ou permitidas no(s) recurso(s) especificado(s). Você pode especificar apenas `Deny` ou `Allow`, como:
```
"Effect" : "Deny"
```
Se uma política de pilha inclui instruções de sobreposição (tanto para permitir e negar atualizações em um recurso), uma instrução `Deny` sempre substituirá uma instrução `Allow`. Para garantir que um recurso está protegido, use uma instrução `Deny` para esse recurso.
Ação
Especifica as ações de atualização que são negadas ou permitidas:
Update:Modify
Especifica ações de atualização durante as quais os recursos poderão não ter interrupções ou algumas interrupções enquanto as alterações estão sendo aplicadas. Todos os recursos mantêm seus IDs físicos.
Update:Replace
Especifica ações de atualização durante as quais os recursos são recriados. O CloudFormation cria um novo recurso com as atualizações especificadas e, em seguida, exclui o recurso antigo. Como o recurso é recriado, o ID físico do novo recurso pode ser diferente.
Update:Delete
Especifica ações de atualização durante as quais os recursos são removidos. As atualizações que removem completamente os recursos de um modelo de pilha exigem esta ação.
Atualização:\$1
Especifica todas as ações de atualização. O asterisco é um caractere curinga que representa todas as ações de atualização.
O exemplo a seguir mostra como especificar apenas as ações de substituição e exclusão:
```
"Action" : ["Update:Replace", "Update:Delete"]
```
Para permitir todas as ações de atualização exceto para uma, use `NotAction`. Por exemplo, para permitir todas as ações de atualização exceto `Update:Delete`, use `NotAction`, como mostrado no exemplo a seguir:
```
{
"Statement" : [
{
"Effect" : "Allow",
"NotAction" : "Update:Delete",
"Principal": "*",
"Resource" : "*"
}
]
}
```
Entidade principal
O elemento `Principal` especifica a entidade que a política se aplica. Este elemento é necessário, mas suporta apenas o caractere curinga (`*`), o que significa que a política aplica-se a todos [principais](https://docs.aws.amazon.com/glossary/latest/reference/glos-chap.html#principal).
Recurso
Especifica os IDs lógicos dos recursos aos quais a política se aplica. Para especificar os tipos de recursos, use o elemento `Condition`.
Para especificar um único recurso, use seu ID lógico. Por exemplo:
```
"Resource" : ["LogicalResourceId/myEC2instance"]
```
Você pode usar um caractere curinga com IDs lógicos. Por exemplo, se você usar um prefixo de ID lógico comum para todos os recursos relacionados, é possível especificar todos eles com um caractere curinga:
```
"Resource" : ["LogicalResourceId/CriticalResource*"]
```
Você também pode usar um elemento `Not` com recursos. Por exemplo, para permitir as atualizações em todos os recursos, exceto um, use um elemento `NotResource` para proteger esse recurso:
```
{
"Statement" : [
{
"Effect" : "Allow",
"Action" : "Update:*",
"Principal": "*",
"NotResource" : "LogicalResourceId/ProductionDatabase"
}
]
}
```
Quando você define uma política de pilha, qualquer atualização não explicitamente permitida é negada por padrão. Ao permitir atualizações para todos os recursos, exceto para o recurso `ProductionDatabase`, você nega atualizações para o recurso `ProductionDatabase`.
Condições
Especifica o tipo de recurso que a política se aplica. Para especificar os IDs lógicos de recursos específicos, use o elemento `Resource`.
Você pode especificar um tipo de recurso, como todas as instâncias de banco de dados do RDS e EC2, conforme mostrado no exemplo a seguir:
```
{
"Statement" : [
{
"Effect" : "Deny",
"Principal" : "*",
"Action" : "Update:*",
"Resource" : "*",
"Condition" : {
"StringEquals" : {
"ResourceType" : ["AWS::EC2::Instance", "AWS::RDS::DBInstance"]
}
}
},
{
"Effect" : "Allow",
"Principal" : "*",
"Action" : "Update:*",
"Resource" : "*"
}
]
}
```
A instrução `Allow` concede permissões de atualização para todos os recursos e a instrução `Deny` nega atualizações para instâncias de banco de dados do RDS e EC2. A declaração `Deny` sempre substitui as ações de permissão.
Você pode usar um caractere curinga com tipos de recursos. Por exemplo, você pode negar permissões de atualização para todos os recursos do Amazon EC2 — como instâncias, security groups e sub-redes — usando um caractere curinga, como mostrado no exemplo a seguir:
```
"Condition" : {
"StringLike" : {
"ResourceType" : ["AWS::EC2::*"]
}
}
```
Você deve usar a condição `StringLike` quando ao usar caracteres curinga.
## Configurar uma política de pilha
Você pode usar o console ou a AWS CLI para aplicar uma política de pilha ao criar uma pilha. Você também pode usar a AWS CLI para aplicar uma política de pilha a uma pilha existente. Depois de aplicar uma política de pilha, você não pode removê-la da pilha, mas é possível usar a AWS CLI para modificá-la.
Uma política de pilha se aplica a todos os usuários do CloudFormation que tentam atualizar a pilha. Você não pode associar diferentes políticas de pilha com diferentes usuários.
Para obter mais informações sobre como gravar políticas de pilhas, consulte [Definir uma política de pilha](#stack-policy-reference).
**Para definir uma política de pilha ao criar uma pilha (console)**
1. Abra o console do CloudFormation em [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Na barra de navegação na parte superior da tela, escolha a Região da AWS na qual a pilha deve ser criada.
1. Na página **CloudFormation Stacks (Pilhas do CloudFormation)**, escolha **Criar pilha (Create stack)**.
1. No assistente Create Stack (Criar pilha), na página **Configure stack options (Configurar opções de pilha)**, expanda a seção **Advanced (Avançado)** e escolha **Stack policy (Política de pilha)**.
1. Especifique a política da pilha:
+ Para gravar uma política diretamente no console, escolha **Enter stack policy (Inserir política de pilha)** e digite a política de pilha diretamente no campo de texto.
+ Para usar uma política definida em um arquivo separado, escolha **Upload a file (Fazer upload de um arquivo)** e **Choose file (Escolher arquivo)** para selecionar o arquivo que contém a política de pilha.
**Para definir uma política de pilha ao criar uma pilha (AWS CLI)**
+ Use o 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) com a opção `--stack-policy-body` para digitar em uma política modificada ou a opção `--stack-policy-url` para especificar um arquivo que contém a política.
**Para definir uma política de pilha em uma pilha existente (AWS CLI apenas)**
+ Use o 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) com a opção `--stack-policy-body` para digitar em uma política modificada ou a opção `--stack-policy-url` para especificar um arquivo que contém a política.
**nota**
Para adicionar uma política a uma pilha existente, você deve ter permissão para a ação [https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_SetStackPolicy.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_SetStackPolicy.html) do CloudFormation.
## Atualizar recursos protegidos
Para atualizar recursos protegidos, crie uma política temporária que substitui a política de pilha e permite atualizações nesses recursos. Especifique a política de substituição quando você atualizar a pilha. A política de substituição não altera permanentemente a política de pilha.
Para atualizar recursos protegidos, você deve ter permissão para usar a ação [https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_SetStackPolicy.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_SetStackPolicy.html) do CloudFormation. Para obter mais informações sobre configuração de permissões do CloudFormation, consulte [Controle o acesso ao CloudFormation com o AWS Identity and Access Management](control-access-with-iam.md).
**nota**
Durante uma atualização de pilha, o CloudFormation atualiza recursos que dependem de outros recursos atualizados. Por exemplo, o CloudFormation atualiza um recurso que faz referência a um recurso atualizado. O CloudFormation não faz alterações físicas, como o ID de recursos, para recursos atualizados automaticamente, mas se uma política de pilha é associada a esses recursos, você deve ter permissão para atualizá-las.
**Para atualizar um recurso protegido (console)**
1. Abra o console do CloudFormation em [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Selecione a pilha que deseja atualizar, escolha **Stack actions (Ações de pilha)** e selecione **Update stack (Atualizar pilha)**.
1. Se você *não* modificou o modelo de pilha, selecione **Use current template (Usar modelo atual)** e clique em **Next (Próximo)**. Se você modificou o modelo, selecione **Replace current template (Substituir modelo atual)** e especifique a localização do modelo atualizado na seção **Specify template (Especificar modelo)**:
+ Para um modelo armazenado localmente em seu computador, selecione **Upload a template file (Fazer upload de um arquivo de modelo)**. Escolha **Escolher arquivo** para navegar até o arquivo e selecioná-lo e, em seguida, clique em **Próximo**.
+ Para um modelo armazenado em um bucket do Amazon S3, selecione **Amazon S3 URL (URL do Amazon S3)**. Insira ou cole o URL do modelo e, em seguida, clique em **Próximo**.
Se você tiver um modelo em um bucket com versionamento habilitado, poderá especificar uma versão específica do modelo anexando `?versionId=version-id` ao URL. Para obter mais informações, consulte [Trabalhar com objetos em um bucket com versionamento habilitado](https://docs.aws.amazon.com/AmazonS3/latest/userguide/manage-objects-versioned-bucket.html) no *Guia do usuário do Amazon Simple Storage Service*.
1. Se o seu modelo contém parâmetros, na página **Specify stack details (Especificar detalhes da pilha)**, insira ou modifique os valores dos parâmetros e escolha **Next (Próximo)**.
O CloudFormation preenche cada parâmetro com o valor que está atualmente definido na pilha, exceto os parâmetros declarados com o atributo `NoEcho`. É possível usar os valores atuais para esses parâmetros escolhendo **Use existing value (Usar valor existente)**.
Para obter mais informações sobre o uso de `NoEcho` para ocultar informações confidenciais e sobre o uso de parâmetros dinâmicos para gerenciar segredos, consulte a melhor prática [Não incorporar credenciais em seus modelos](security-best-practices.md#creds).
1. Especifique uma política de pilha de substituição.
1. Na página **Configure stack options (Configurar opções da pilha)**, na seção **Advanced options (Opções avançadas)**, selecione **Stack policy (Política de pilha)**.
1. Selecione **Upload a file (Fazer upload de um arquivo)**.
1. Clique em **Choose file (Escolher arquivo)** e navegue até o arquivo que contém a política de pilha de sobreposição ou digite uma política.
1. Escolha **Próximo**.
A política de substituição deve especificar uma instrução `Allow` para os recursos protegidos que você deseja atualizar. Por exemplo, para atualizar todos os recursos protegidos, especifique uma política de substituição temporária que permite todas as atualizações:
```
{
"Statement" : [
{
"Effect" : "Allow",
"Action" : "Update:*",
"Principal": "*",
"Resource" : "*"
}
]
}
```
**nota**
O CloudFormation aplica a política de substituição apenas durante a atualização. A política de substituição não altera permanentemente a política de pilha. Para modificar uma política de pilha, consulte [Modificar uma política de pilha](#protect-stack-resources-modifying).
1. Analise as informações e as alterações da pilha que você enviou.
Verifique se você enviou as informações corretas, como os valores de parâmetro ou modelo de URL correto. Se o seu modelo contém recursos do IAM, escolha **I acknowledge that this template may create IAM resources (Eu reconheço que este modelo pode criar recursos do IAM)** para especificar que você deseja usar recursos do IAM no modelo. Para obter mais informações, consulte [Confirmar recursos do IAM em modelos do CloudFormation](control-access-with-iam.md#using-iam-capabilities).
Na seção **Visualizar suas alterações**, verifique se o CloudFormation fará todas as alterações que você espera. Por exemplo, verifique que o CloudFormation adiciona, remove e modifica os recursos que você pretende adicionar, remover ou modificar. O CloudFormation gera esta pré-visualização criando um conjunto de alterações para a pilha. Para obter mais informações, consulte [Atualizar pilhas do CloudFormation usando conjuntos de alterações](using-cfn-updating-stacks-changesets.md).
1. Quando estiver satisfeito com as alterações, clique em **Update (Atualizar)**.
**nota**
Nesse ponto, você também tem a opção de visualizar o conjunto de alterações para rever as atualizações propostas mais cuidadosamente. Para fazer isso, clique em **View change set** (Visualizar conjunto de alterações) em vez de em **Update** (Atualizar). O CloudFormation mostra o conjunto de alterações gerado com base nas suas atualizações. Quando estiver pronto para executar a atualização da pilha, clique em **Execute (Executar)**.
CloudFormation exibe a página **Stack details** (Detalhes da pilha) para sua pilha. Sua pilha agora tem um status de `UPDATE_IN_PROGRESS`. Depois que o CloudFormation tiver concluído com êxito a atualização da pilha, ele definirá o status da pilha como `UPDATE_COMPLETE`.
Caso a atualização da pilha falhe, o CloudFormation reverterá automaticamente as alterações e definirá o status como `UPDATE_ROLLBACK_COMPLETE`.
**Para atualizar um recurso protegido (AWS CLI)**
+ Use o 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) com a opção `--stack-policy-during-update-body` para digitar em uma política modificada ou a opção `--stack-policy-during-update-url` para especificar um arquivo que contém a política.
**nota**
O CloudFormation aplica a política de substituição apenas durante a atualização. A política de substituição não altera permanentemente a política de pilha. Para modificar uma política de pilha, consulte [Modificar uma política de pilha](#protect-stack-resources-modifying).
## Modificar uma política de pilha
Para proteger os recursos adicionais ou para remover a proteção dos recursos, modifique a política da pilha. Por exemplo, quando você adiciona um banco de dados que você deseja proteger a sua pilha, adicione uma instrução `Deny` para o banco de dados à política de pilha. Para modificar a política, você deve ter permissão para usar a ação [https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_SetStackPolicy.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_SetStackPolicy.html).
Use a AWS CLI para modificar políticas de pilha.
**Para modificar uma política de pilha (AWS CLI)**
+ Use o 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) com a opção `--stack-policy-body` para digitar em uma política modificada ou a opção `--stack-policy-url` para especificar um arquivo que contém a política.
Você não pode excluir uma política de pilha. Para remover todas as proteções de todos os recursos, você modifica a política para explicitamente permitir todas as ações em todos os recursos. A política a seguir permite todas as atualizações em todos os recursos:
```
{
"Statement" : [
{
"Effect" : "Allow",
"Action" : "Update:*",
"Principal": "*",
"Resource" : "*"
}
]
}
```
## Mais exemplos de políticas de pilha
As seguintes políticas de exemplo mostram como impedir atualizações em todos os recursos de pilha, especificar recursos e impedir determinados tipos de atualizações.
### Impedir atualizações em todos os recursos de pilha
Para impedir atualizações em todos os recursos de pilha, a seguinte política especifica uma instrução `Deny` para todas as ações de atualização em todos os recursos.
```
{
"Statement" : [
{
"Effect" : "Deny",
"Action" : "Update:*",
"Principal": "*",
"Resource" : "*"
}
]
}
```
### Impedir atualizações em um único recurso
A seguinte política nega todas as ações de atualização no banco de dados com o ID lógico `MyDatabase`. Isso permite todas as ações de atualização em todos os outros recursos de pilha com uma instrução `Allow`. A instrução `Allow` não se aplica ao recurso `MyDatabase` porque a instrução `Deny` sempre substitui as ações de permissão.
```
{
"Statement" : [
{
"Effect" : "Deny",
"Action" : "Update:*",
"Principal": "*",
"Resource" : "LogicalResourceId/MyDatabase"
},
{
"Effect" : "Allow",
"Action" : "Update:*",
"Principal": "*",
"Resource" : "*"
}
]
}
```
Você pode alcançar o mesmo resultado do exemplo anterior usando um padrão de negação. Quando você define uma política de pilha, o CloudFormation bloqueia qualquer atualização que não é explicitamente permitida. A seguinte política permite atualizações em todos os recursos, exceto no recurso `ProductionDatabase`, que é negado por padrão.
```
{
"Statement" : [
{
"Effect" : "Allow",
"Action" : "Update:*",
"Principal": "*",
"NotResource" : "LogicalResourceId/ProductionDatabase"
}
]
}
```
**Importante**
Não há risco em usar uma negação padrão. Se você tiver uma instrução `Allow` em outro lugar na política (como uma instrução `Allow` que usa um caractere curinga), talvez você conceda inadvertidamente permissão de atualização a recursos que você não pretendia. Como uma negação explícita substitui quaisquer ações de permissão, você pode garantir que um recurso seja protegido usando uma instrução `Deny`.
### Impedir atualizações em todas as instâncias de um tipo de recurso
A seguinte política nega todas as ações de atualização no tipo de recurso de instância de banco de dados do RDS. Isso permite todas as ações de atualização em todos os outros recursos de pilha com uma instrução `Allow`. A instrução `Allow` não se aplica ao recurso de instância de banco de dados do RDS porque uma instrução `Deny` sempre substitui as ações de permissão.
```
{
"Statement" : [
{
"Effect" : "Deny",
"Action" : "Update:*",
"Principal": "*",
"Resource" : "*",
"Condition" : {
"StringEquals" : {
"ResourceType" : ["AWS::RDS::DBInstance"]
}
}
},
{
"Effect" : "Allow",
"Action" : "Update:*",
"Principal": "*",
"Resource" : "*"
}
]
}
```
### Impedir atualizações de substituição em uma instância
A seguinte política nega atualizações que poderiam causar uma substituição da instância com o ID lógico `MyInstance`. Isso permite todas as ações de atualização em todos os outros recursos de pilha com uma instrução `Allow`. A instrução `Allow` não se aplica ao recurso `MyInstance` porque a instrução `Deny` sempre substitui as ações de permissão.
```
{
"Statement" : [
{
"Effect" : "Deny",
"Action" : "Update:Replace",
"Principal": "*",
"Resource" : "LogicalResourceId/MyInstance"
},
{
"Effect" : "Allow",
"Action" : "Update:*",
"Principal": "*",
"Resource" : "*"
}
]
}
```
### Impedir atualizações em pilhas aninhadas
A seguinte política nega todas as ações de atualização no tipo de recurso de pilha do CloudFormation (pilhas aninhadas). Isso permite todas as ações de atualização em todos os outros recursos de pilha com uma instrução `Allow`. A declaração `Allow` não se aplica aos recursos da pilha do CloudFormation porque a declaração `Deny` sempre substitui as ações permitidas.
```
{
"Statement" : [
{
"Effect" : "Deny",
"Action" : "Update:*",
"Principal": "*",
"Resource" : "*",
"Condition" : {
"StringEquals" : {
"ResourceType" : ["AWS::CloudFormation::Stack"]
}
}
},
{
"Effect" : "Allow",
"Action" : "Update:*",
"Principal": "*",
"Resource" : "*"
}
]
}
```
# Proteção de dados no CloudFormation
O [modelo de responsabilidade compartilhada](https://aws.amazon.com/compliance/shared-responsibility-model/) da AWS se aplica à proteção de dados no AWS CloudFormation. Conforme descrito nesse modelo, AWS é responsável por proteger a infraestrutura global que executa todas as Nuvem AWS. Você é responsável por manter o controle sobre o conteúdo hospedado nessa infraestrutura. Você também é responsável pelas tarefas de configuração e gerenciamento de segurança dos Serviços da AWS que usa. Para obter mais informações sobre a privacidade de dados, consulte as [Data Privacy FAQ](https://aws.amazon.com/compliance/data-privacy-faq/). Para obter mais informações sobre a proteção de dados na Europa, consulte a postagem do blog [AWS Shared Responsibility Model and RGPD](https://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/) no *Blog de segurança da AWS*.
Para fins de proteção de dados, recomendamos que você proteja as credenciais da Conta da AWS e configure as contas de usuário individuais com Centro de Identidade do AWS IAM ou AWS Identity and Access Management (IAM). Dessa maneira, cada usuário receberá apenas as permissões necessárias para cumprir suas obrigações de trabalho. Recomendamos também que você proteja seus dados das seguintes formas:
+ Use uma autenticação multifator (MFA) com cada conta.
+ Use SSL/TLS para se comunicar com os recursos da AWS. Exigimos TLS 1.2 e recomendamos TLS 1.3.
+ Configure os logs de API e atividade do usuário com AWS CloudTrail. Para obter informações sobre como usar as trilhas do CloudTrail para capturar atividades da AWS, consulte [Working with CloudTrail trails](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-trails.html) no *Guia do usuário do AWS CloudTrail*.
+ Use as soluções de criptografia AWS, juntamente com todos os controles de segurança padrão em Serviços da AWS.
+ Use serviços gerenciados de segurança avançada, como o Amazon Macie, que ajuda a localizar e proteger dados sigilosos armazenados no Amazon S3.
+ Se você precisar de módulos criptográficos validados pelo FIPS 140-3 ao acessar a AWS por meio de uma interface de linha de comandos ou de uma API, use um endpoint do FIPS. Para obter mais informações sobre os endpoints FIPS disponíveis, consulte [Federal Information Processing Standard (FIPS) 140-3](https://aws.amazon.com/compliance/fips/).
É altamente recomendável que nunca sejam colocadas informações confidenciais ou sigilosas, como endereços de e-mail de clientes, em tags ou campos de formato livre, como um campo **Nome**. Isso inclui trabalhar com a CloudFormation ou outros Serviços da AWS usando o console, a API, a AWS CLI ou os AWS SDKs. Quaisquer dados inseridos em tags ou em campos de texto de formato livre usados para nomes podem ser usados para logs de faturamento ou de diagnóstico. Se você fornecer um URL para um servidor externo, recomendamos fortemente que não sejam incluídas informações de credenciais no URL para validar a solicitação a esse servidor.
## Criptografia inativa
Seguindo o modelo de responsabilidade compartilhada da AWS, o CloudFormation armazena seus dados criptografados em repouso. Os clientes são responsáveis por definir políticas de criptografia e armazenamento para dados armazenados em suas contas. Por exemplo, recomendamos habilitar a criptografia em repouso para modelos e outros dados armazenados em buckets do S3 ou tópicos do SNS. Os clientes definem de forma semelhante as configurações de criptografia para quaisquer sistemas de armazenamento de dados provisionados pelo CloudFormation.
## Criptografia em trânsito
O CloudFormation usa canais criptografados para comunicações de serviço sob o modelo de responsabilidade compartilhada.
## Privacidade do tráfego entre redes
As comunicações do serviço CloudFormation são criptografadas com segurança por padrão entre regiões ou zonas de disponibilidade.
# Controle o acesso ao CloudFormation com o AWS Identity and Access Management
Com o AWS Identity and Access Management (IAM), você pode criar usuários do IAM e controlar seu acesso a recursos específicos da sua Conta da AWS. Usando o IAM, você pode controlar o que os usuários podem fazer com o CloudFormation, por exemplo, se podem visualizar modelos de pilhas, criar pilhas ou excluir pilhas.
Além das ações específicas do CloudFormation, você pode gerenciar quais serviços e recursos da AWS estão disponíveis para cada usuário. Assim, você pode controlar quais recursos os usuários podem acessar ao usar o CloudFormation. Por exemplo, você pode especificar quais usuários podem criar instâncias Amazon EC2, encerrar instâncias de banco de dados ou atualizar VPCs. As mesmas permissões serão aplicadas sempre que eles usam o CloudFormation para executar essas ações.
Use as informações das seções a seguir para controlar quem pode acessar o CloudFormation. Também exploraremos como autorizar a criação de recursos do IAM em modelos, como dar às aplicações executadas nas instâncias do EC2 as permissões necessárias e como usar credenciais de segurança temporárias para aumentar a segurança em seu ambiente AWS.
## Definir políticas baseadas em identidade do IAM para o CloudFormation
Para dar acesso ao CloudFormation, você precisa criar e atribuir políticas do IAM que concedam às identidades do IAM (como usuários ou perfis) permissão para chamar as ações de API necessárias.
Com as políticas baseadas em identidade do IAM, é possível especificar ações ou recursos permitidos ou negados, bem como as condições sob as quais as ações são permitidas ou negadas. O CloudFormation é compatível com ações, recursos e chaves de condição específicos.
Se você é novato no IAM, comece por se familiarizar com os elementos de uma política JSON do IAM. Para obter mais informações, consulte [Referência de elemento de política JSON do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html) no *Guia do usuário do IAM*. Para aprender a criar políticas do IAM, faça o tutorial [Criar e anexar sua primeira política gerenciada pelo cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_managed-policies.html) na documentação do IAM.
**Topics**
+ [Ações de política para o CloudFormation](#using-iam-actions)
+ [Ações específicas do console para o CloudFormation](#console-specific-actions)
+ [Recursos de política do CloudFormation](#resource-level-permissions)
+ [Chaves de condição de política do CloudFormation](#using-iam-conditions)
### Ações de política para o CloudFormation
No elemento `Action` da instrução da política do IAM, você pode especificar qualquer ação de API oferecida pelo CloudFormation. O nome da ação deve começar com o prefixo `cloudformation:` em minúsculas. Por exemplo: `cloudformation:CreateStack`, `cloudformation:CreateChangeSet` e `cloudformation:UpdateStack`.
Para especificar várias ações em uma única declaração, separe-as com vírgulas, da seguinte maneira:
```
"Action": [ "cloudformation:action1", "cloudformation:action2" ]
```
Também é possível especificar várias ações usando asteriscos. Por exemplo, é possível especificar todas as ações cujos nomes comecem com a palavra `Get`, da seguinte maneira:
```
"Action": "cloudformation:Get*"
```
Para ver uma lista completa das ações associadas ao prefixo de serviço `cloudformation`, consulte [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 API Cloud Control](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awscloudcontrolapi.html) na *Service Authorization Reference*.
#### Exemplos
O exemplo a seguir mostra uma política de permissões que concede permissões para visualizar pilhas do CloudFormation.
**Example 1: um exemplo de política que concede permissões para visualizar pilhas**
****
```
{
"Version":"2012-10-17",
"Statement":[{
"Effect":"Allow",
"Action":[
"cloudformation:DescribeStacks",
"cloudformation:DescribeStackEvents",
"cloudformation:DescribeStackResource",
"cloudformation:DescribeStackResources"
],
"Resource":"*"
}]
}
```
Os usuários que criam ou excluem pilhas precisam ter permissões adicionais de acordo com seus modelos de pilha. Por exemplo, se o modelo descrever uma fila do Amazon SQS, os usuários deverão ter permissões para as ações do CloudFormation e do Amazon SQS, conforme mostrado no exemplo de política a seguir.
**Example 2: um exemplo de política que permite as ações de criar e visualizar pilhas, e todas as ações do Amazon SQS**
****
```
{
"Version":"2012-10-17",
"Statement":[{
"Effect":"Allow",
"Action":[
"sqs:*",
"cloudformation:CreateStack",
"cloudformation:DescribeStacks",
"cloudformation:DescribeStackEvents",
"cloudformation:DescribeStackResources",
"cloudformation:GetTemplate",
"cloudformation:ValidateTemplate"
],
"Resource":"*"
}]
}
```
### Ações específicas do console para o CloudFormation
Os usuários que usam o console do CloudFormation precisam ter permissões adicionais, além das necessárias para usar as APIs da AWS Command Line Interface ou do CloudFormation. Essas permissões adicionais são compatíveis com atributos específicos do console, como uploads de modelos em buckets do Amazon S3 e listas suspensas para tipos de parâmetros específicos da AWS.
Para todas as ações listadas abaixo, conceda permissões a todos os recursos, sem limitá-las a pilhas ou buckets específicos.
A ação a seguir é usada apenas pelo console do CloudFormation e não é documentada na referência de APIs. A ação permite que os usuários façam upload de modelos para buckets do Amazon S3.
+ `cloudformation:CreateUploadBucket`
Para carregar modelos, os usuários também precisam ter as seguintes permissões do Amazon S3:
+ `s3:PutObject`
+ `s3:ListBucket`
+ `s3:GetObject`
+ `s3:CreateBucket`
Para ver os valores nas listas suspensas de parâmetros para modelos com tipos de parâmetros específicos da AWS, os usuários precisam ter permissões para fazer as chamadas de API describe correspondentes. Por exemplo, as seguintes permissões são necessárias quando esses tipos de parâmetros são usados no modelo:
+ `ec2:DescribeKeyPairs`: requerida para o tipo de parâmetro `AWS::EC2::KeyPair::KeyName`.
+ `ec2:DescribeSecurityGroups`: requerida para o tipo de parâmetro `AWS::EC2::SecurityGroup::Id`.
+ `ec2:DescribeSubnets`: requerida para o tipo de parâmetro `AWS::EC2::Subnet::Id`.
+ `ec2:DescribeVpcs`: requerida para o tipo de parâmetro `AWS::EC2::VPC::Id`.
Para obter mais informações sobre os tipos de parâmetros específicos da AWS, consulte [Especificar recursos existentes no runtime com tipos de parâmetros fornecidos pelo CloudFormation](cloudformation-supplied-parameter-types.md).
### Recursos de política do CloudFormation
Em uma instrução de política do IAM, o elemento `Resource` especifica o objeto ou os objetos abrangidos pela instrução. No CloudFormation, cada instrução de política do IAM se aplica aos recursos que você especifica usando os nomes dos recursos da Amazon (ARNs). O formato do ARN específico depende do recurso.
Para obter uma lista dos tipos de recursos do CloudFormation e seus ARNs, consulte [Resource types defined by CloudFormation](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awscloudformation.html#awscloudformation-resources-for-iam-policies) na *Service Authorization Reference*. Para saber com quais ações você pode especificar o ARN de cada atributo, consulte [Actions defined by CloudFormation](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awscloudformation.html#awscloudformation-actions-as-permissions).
Você pode especificar ações para uma pilha específica, como mostra o exemplo de política a seguir. Quando fornecer um ARN, substitua o `placeholder text` pelas informações específicas do recurso.
**Example 1: um exemplo de política que nega as ações de excluir e atualizar pilha para a pilha especificada**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": [
"cloudformation:DeleteStack",
"cloudformation:UpdateStack"
],
"Resource": "arn:aws:cloudformation:us-east-1:111122223333:stack/MyProductionStack/*"
}
]
}
```
A política acima usa um caractere curinga no fim do nome da pilha para que as ações de excluir e atualizar pilha sejam negadas tanto com o ID da pilha completo (como `arn:aws:cloudformation:region:account-id:stack/MyProductionStack/abc9dbf0-43c2-11e3-a6e8-50fa526be49c`) e tanto com o nome da pilha (como `MyProductionStack`).
Para permitir que transformações `AWS::Serverless` criem um conjunto de alterações, a política deve incluir a permissão ao nível do recurso `arn:aws:cloudformation:region:aws:transform/Serverless-2016-10-31`, como mostrado na política a seguir.
**Example 2: um exemplo de política que permite a ação de criar um conjunto de alterações para a transformação especificada**
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudformation:CreateChangeSet"
],
"Resource": "arn:aws:cloudformation:us-east-1:aws:transform/Serverless-2016-10-31"
}
]
}
```
### Chaves de condição de política do CloudFormation
Em uma instrução de política do IAM, você tem a opção de especificar as condições que controlam quando uma política entra em vigor. Por exemplo, você pode definir uma política que permita que os usuários do criem uma pilha apenas quando especificarem uma determinada URL modelo. Você pode definir condições específicas do CloudFormation e condições gerais da AWS, como `DateLessThan`, que determinam quando uma política deixa de vigorar. Para obter mais informações e uma lista de condições gerais da AWS, consulte Condição na [Referência a elementos de políticas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements.html#Condition), no *Guia do usuário do IAM*.
**nota**
Não use a condição `aws:SourceIp` em toda a AWS. O CloudFormation provisiona recursos usando seu próprio endereço IP, e não o endereço IP da solicitação de origem. Por exemplo, quando você cria uma pilha, o CloudFormation faz solicitações do seu endereço IP para executar uma instância do Amazon EC2 ou para criar um bucket do Amazon S3, e não do endereço IP da chamada `CreateStack` ou do comando **create-stack**.
A lista a seguir descreve as condições específicas do CloudFormation. Essas condições são aplicadas apenas quando os usuários criam ou atualizam pilhas:
`cloudformation:ChangeSetName`
O nome de um conjunto de alterações do CloudFormation que você deseja associar a uma política. Use essa condição para controlar quais conjuntos de alterações os usuários do podem executar ou excluir.
`cloudformation:ImportResourceTypes`
Os tipos de recursos do modelo que você deseja associar a uma política, como `AWS::EC2::Instance`. Use essa condição para controlar com quais tipos de recursos os usuários do podem trabalhar quando importarem recursos para uma pilha. Essa condição é verificada em relação aos tipos de recursos que os usuários declaram no parâmetro `ResourcesToImport`, que atualmente tem suporte apenas para solicitações da AWS CLI e da API. Ao usar esse parâmetro, especifique todos os tipos de recursos que deseja que os usuários controlem durante as operações de importação. Para obter mais informações sobre o parâmetro `ResourcesToImport`, consulte a ação [https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateChangeSet.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateChangeSet.html) na *Referência de APIs do AWS CloudFormation*.
Para obter uma lista de `ResourcesToImport` possíveis, consulte [Suporte a tipos de recursos](resource-import-supported-resources.md).
Use a convenção de nomenclatura de recursos de três partes para especificar com quais tipos de recursos os usuários podem trabalhar, de todos os recursos de uma organização até um tipo de recurso individual.
`organization::*`
Especifique todos os tipos de recursos de uma determinada organização.
`organization::service_name::*`
Especifique todos os tipos de recurso do serviço especificado dentro de uma determinada organização.
`organization::service_name::resource_type`
Especifique um tipo de recurso específico.
Por exemplo:
`AWS::*`
Especifique todos os tipos de recursos da AWS compatíveis.
`AWS::service_name::*`
Especifique todos os recursos com suporte a um produto da AWS específico.
`AWS::service_name::resource_type`
Especifique um tipo de recurso da AWS específico, como `AWS::EC2::Instance` (todas as instâncias do EC2).
`cloudformation:ResourceTypes`
Os tipos de recursos modelo, como `AWS::EC2::Instance`, que você deseja associar a uma política. Use essa condição para controlar com quais tipos de recursos os usuários do podem trabalhar ao criar ou atualizar uma pilha. Essa condição é verificada em relação aos tipos de recursos que os usuários declaram no parâmetro `ResourceTypes`, que atualmente tem suporte apenas para solicitações da AWS CLI e da API. Ao usar esse parâmetro, os usuários devem especificar todos os tipos de recursos que estão em seu modelo. Para obter mais informações sobre o parâmetro `ResourceTypes`, consulte a ação [https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html) na *Referência de APIs do AWS CloudFormation*.
Para obter uma lista dos tipos de recursos, consulte o [Guia de referência de modelos do CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/introduction.html).
Use a convenção de nomenclatura de recursos de três partes para especificar com quais tipos de recursos os usuários podem trabalhar, de todos os recursos de uma organização até um tipo de recurso individual.
`organization::*`
Especifique todos os tipos de recursos de uma determinada organização.
`organization::service_name::*`
Especifique todos os tipos de recurso do serviço especificado dentro de uma determinada organização.
`organization::service_name::resource_type`
Especifique um tipo de recurso específico.
Por exemplo:
`AWS::*`
Especifique todos os tipos de recursos da AWS compatíveis.
`AWS::service_name::*`
Especifique todos os recursos com suporte a um produto da AWS específico.
`AWS::service_name::resource_type`
Especifique um tipo de recurso da AWS específico, como `AWS::EC2::Instance` (todas as instâncias do EC2).
`Alexa::ASK::*`
Especifique todos os tipos de recurso no Kit de habilidades do Alexa.
`Alexa::ASK::Skill`
Especifique o tipo de recurso [Alexa::ASK::Skill](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/alexa-resource-ask-skill.html) individual.
`Custom::*`
Especifique todos os recursos personalizados.
Para obter mais informações, consulte [Crie uma lógica de provisionamento personalizada com recursos personalizados](template-custom-resources.md).
`Custom::resource_type`
Especifique um tipo de recurso personalizado específico.
Para obter mais informações, consulte [Crie uma lógica de provisionamento personalizada com recursos personalizados](template-custom-resources.md).
`cloudformation:RoleARN`
O Nome de recurso da Amazon (ARN) de uma função de serviço do IAM que você deseja associar a uma política. Use essa condição para controlar qual serviço os usuários do podem usar ao trabalhar com pilhas ou conjuntos de alterações.
`cloudformation:StackPolicyUrl`
O URL de uma política de pilha Amazon S3 que você deseja associar a uma política. Use essa condição para controlar quais políticas de pilha os usuários do podem associar a uma pilha durante uma ação de criação ou atualização de pilha. Para obter mais informações sobre políticas de pilhas, consulte [Impedir atualizações nos recursos de pilha](protect-stack-resources.md).
Para garantir que os usuários possam apenas criar ou atualizar pilhas com as políticas de pilhas que você carregou, defina o bucket do S3 como somente leitura para esses usuários.
`cloudformation:TemplateUrl`
O URL de um modelo do Amazon S3 que você deseja associar a uma política. Use essa condição para controlar quais modelos os usuários do podem usar ao criar ou atualizar pilhas.
Para garantir que os usuários possam apenas criar ou atualizar pilhas com os modelos que você carregou, defina o bucket do S3 como somente leitura para esses usuários.
As seguintes condições específicas de CloudFormation se aplicam aos parâmetros da API com o mesmo nome:
+ `cloudformation:ChangeSetName`
+ `cloudformation:RoleARN`
+ `cloudformation:StackPolicyUrl`
+ `cloudformation:TemplateUrl`
Por exemplo, `cloudformation:TemplateUrl` só se aplica ao parâmetro `TemplateUrl` para as APIs `CreateStack`, `UpdateStack` e `CreateChangeSet`.
Para obter exemplos de políticas do IAM que usam chaves de condição, consulte [Exemplos de políticas baseadas em identidade do IAM para o CloudFormation](security_iam_id-based-policy-examples.md).
## Confirmar recursos do IAM em modelos do CloudFormation
Antes que você possa criar uma pilha, o CloudFormation deve validar seu modelo. Durante a validação, o CloudFormation verifica os recursos do IAM que seu modelo pode criar. Os recursos do IAM, como um usuário com acesso completo, podem acessar e modificar qualquer recurso na sua . Conta da AWS. Portanto, sugerimos que você examine as permissões associadas a cada recurso do IAM antes de prosseguir, para não criar recursos acidentalmente com permissões escalonadas. Para garantir que fez isso, você deve confirmar que o modelo contém esses recursos, fornecendo ao CloudFormation as capacidades especificadas antes de criar a pilha.
Você pode confirmar as capacidades dos modelos do CloudFormation usando o console do CloudFormation, a AWS Command Line Interface (AWS CLI) ou a API:
+ No console do CloudFormation, na página **Configurar opções da pilha** dos assistentes de criação ou de atualização de pilhas, escolha **Eu reconheço que este modelo pode criar recursos do IAM**.
+ Na AWS CLI, ao usar os comandos [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/create-stack.html) e [https://docs.aws.amazon.com/cli/latest/reference/cloudformation/update-stack.html](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/update-stack.html), especifique o valor `CAPABILITY_IAM` ou `CAPABILITY_NAMED_IAM` para a opção `--capabilities`. Se seu modelo incluir recursos do IAM, você poderá especificar uma dessas capacidades. Se seu modelo incluir nomes personalizados para recursos do IAM, você deverá especificar `CAPABILITY_NAMED_IAM`.
+ Na API, ao usar as ações [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), especifique `Capabilities.member.1=CAPABILITY_IAM` ou `Capabilities.member.1=CAPABILITY_NAMED_IAM`. Se seu modelo incluir recursos do IAM, você poderá especificar uma dessas capacidades. Se seu modelo incluir nomes personalizados para recursos do IAM, você deverá especificar `CAPABILITY_NAMED_IAM`.
**Importante**
Se seu modelo contiver recursos do IAM nomeados personalizados, não crie várias pilhas reutilizando o mesmo modelo. Os recursos do IAM devem ser globalmente exclusivos na sua conta. Se você usar o mesmo modelo para criar várias pilhas em diferentes regiões, suas pilhas poderão compartilhar os mesmos recursos do IAM, em vez de cada uma ter um recurso exclusivo. Recursos compartilhados entre pilhas podem ter consequências acidentais das quais não é possível se recuperar. Por exemplo, se você excluir ou atualizar recursos compartilhados do IAM em uma pilha, você modificará acidentalmente os recursos de outras pilhas.
## Gerenciar credenciais para aplicações executas em instâncias do Amazon EC2
Se você tiver uma aplicação executada em uma instância do Amazon EC2 e precisar fazer solicitações a recursos da AWS, como buckets do Amazon S3 ou uma tabela do DynamoDB, essa aplicação precisará de credenciais de segurança da AWS. No entanto, a distribuição e a inserção de credenciais de segurança de longo prazo em cada instância que você executa é um desafio e um risco potencial à segurança. Em vez de usar credenciais de longo prazo, como credenciais de usuário do IAM, recomendamos que você crie uma função do IAM que seja associada a uma instância do Amazon EC2 quando a instância for iniciada. Um aplicativo pode obter credenciais de segurança temporárias na instância Amazon EC2. Você não precisa inserir credenciais de longo prazo na instância. Além disso, para facilitar o gerenciamento de credenciais, você pode especificar apenas uma única função para várias instâncias Amazon EC2. Você não precisa criar credenciais exclusivas para cada instância.
Para obter um trecho de modelo que mostra como executar uma instância com uma função, consulte [Exemplos de modelos de função do IAM](quickref-iam.md#scenarios-iamroles).
**nota**
As aplicações em instâncias que usam credenciais de segurança temporárias podem chamar qualquer ação do CloudFormation. No entanto, como o CloudFormation interage com muitos outros serviços da AWS, é necessário verificar se todos os serviços que você deseja usar oferecem suporte a credenciais de segurança temporárias. Para obter uma lista de serviços que aceitam credenciais de segurança temporárias, consulte os [serviços da AWS que funcionam com o IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) no *Guia do usuário do IAM*.
## Conceder acesso temporário (acesso federado)
Em alguns casos, você pode desejar conceder aos usuários sem credenciais da AWS acesso temporário à sua Conta da AWS. Em vez de criar e excluir credenciais de longo prazo sempre que você quiser conceder acesso temporário, use o AWS Security Token Service (AWS STS). Por exemplo, você pode usar funções do IAM. Em uma função do IAM, você pode criar programaticamente e distribuir muitas credenciais de segurança temporárias (que incluem uma chave de acesso, uma chave de acesso secreta e um token de segurança). Essas credenciais têm vida útil limitada e, portanto, não podem ser usadas para acessar sua Conta da AWS depois que expiram. Você também pode criar vários perfis do IAM para conceder diferentes níveis de permissões a usuários individuais. Perfis do IAM são úteis para cenários como identidades federadas e logon único.
Uma identidade federada é uma identidade distinta que você pode usar entre vários sistemas. Para usuários corporativos com um sistema de identidade estabelecido on-premises (como o LDAP ou o Active Directory), você pode tratar de toda a autenticação com seu sistema de identidade local. Quando um usuário é autenticado, você fornece credenciais de segurança temporárias a partir da função ou do usuário do IAM apropriado. Por exemplo, é possível criar um perfil administrators e um perfil developers em que os administradores têm acesso total à conta da AWS e os desenvolvedores têm permissões para trabalhar apenas com pilhas do CloudFormation. Depois que um administrador é autenticado, ele é autorizado a obter credenciais de segurança temporárias do perfil administrators. No entanto, os desenvolvedores podem obter credenciais de segurança temporárias apenas do perfil developers.
Você também pode conceder aos usuários federados acesso ao Console de gerenciamento da AWS. Depois que os usuários se autenticam com o sistema de identidade on-premises, você pode construir programaticamente um URL temporário que forneça acesso direto ao Console de gerenciamento da AWS. Quando os usuários usam o URL temporário, eles não precisam fazer login na AWS porque já foram autenticados (autenticação única). Além disso, como o URL é construído a partir das credenciais de segurança temporárias dos usuários, as permissões que estão disponíveis com essas credenciais determinam quais permissões os usuários têm no Console de gerenciamento da AWS.
Você pode usar várias diferentes APIs do AWS STS para gerar credenciais de segurança temporárias. Para obter mais informações sobre qual API usar, consulte [Comparar credenciais do AWS STS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_sts-comparison.html) no *Guia do usuário do IAM*.
**Importante**
Você não pode trabalhar com o IAM ao usar credenciais de segurança temporárias que foram geradas a partir da API `GetFederationToken`. Em vez disso, se você precisar trabalhar com o IAM, use credenciais de segurança temporárias de uma função.
O CloudFormation interage com muitos outros serviços da AWS. Ao usar credenciais de segurança temporárias com o CloudFormation, verifique se todos os serviços que deseja usar oferecem suporte a credenciais de segurança temporárias. Para obter uma lista de serviços que aceitam credenciais de segurança temporárias, consulte os [serviços da AWS que funcionam com o IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_aws-services-that-work-with-iam.html) no *Guia do usuário do IAM*.
Para obter mais informações, consulte os seguintes recursos relacionados no *Guia do usuário do IAM*:
+ [Cenários comuns para credenciais temporárias](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp.html#sts-introduction)
+ [Habilitar o acesso do intermediador de identidades personalizado ao console da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_enable-console-custom-url.html)
# Exemplos de políticas baseadas em identidade do IAM para o CloudFormation
Por padrão, os usuários e os perfis não têm permissão para criar nem modificar recursos do CloudFormation. Eles também não podem executar tarefas usando o Console de gerenciamento da AWS, a AWS Command Line Interface (AWS CLI) ou a API da AWS. Para conceder aos usuários permissões para executar ações nos recursos que eles precisam, um administrador do IAM pode criar políticas do IAM. O administrador pode então adicionar as políticas do IAM aos perfis e os usuários podem assumir os perfis. Para obter mais informações, consulte [Definir políticas baseadas em identidade do IAM para o CloudFormation](control-access-with-iam.md#iam-id-based-policies).
Os exemplos a seguir mostram as instruções de política que você pode usar para conceder ou negar permissões para usar uma ou mais ações do CloudFormation.
**Topics**
+ [Exigir um URL de modelo específico](#w2aac43c23c17b9)
+ [Negar todas as operações de importação do CloudFormation](#w2aac43c23c17c11)
+ [Permitir operações de importação para tipos de recursos específicos](#w2aac43c23c17c13)
+ [Negar recursos do IAM em modelos de pilha](#w2aac43c23c17c15)
+ [Permitir a criação de pilhas com tipos de recursos específicos](#w2aac43c23c17c17)
+ [Controlar o acesso com base nas ações de API de mutação de recurso](#w2aac43c23c17c19)
+ [Restringir operações de conjunto de pilhas com base na região e nos tipos de recursos](#resource-level-permissions-service-managed-stack-set)
+ [Permitir todas as operações do gerador de IaC](#iam-policy-example-for-iac-generator)
## Exigir um URL de modelo específico
O exemplo de política a seguir concede aos usuários permissões para usar apenas o URL do modelo `https://s3.amazonaws.com/amzn-s3-demo-bucket/test.template` para criar ou atualizar uma pilha.
------
#### [ 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"
]
}
}
}
]
}
```
------
## Negar todas as operações de importação do CloudFormation
O exemplo de política a seguir concede permissões para realizar todas as operações do CloudFormation, exceto as operações de importação.
------
#### [ 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": [
"*"
]
}
}
}
]
}
```
------
## Permitir operações de importação para tipos de recursos específicos
O exemplo de política a seguir concede permissões para todas as operações de pilha, e também para operações de importação apenas nos recursos especificados (neste exemplo, `AWS::S3::Bucket`).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowImport",
"Effect": "Allow",
"Action": "cloudformation:*",
"Resource": "*",
"Condition": {
"ForAllValues:StringEqualsIgnoreCase": {
"cloudformation:ImportResourceTypes": [
"AWS::S3::Bucket"
]
}
}
}
]
}
```
------
## Negar recursos do IAM em modelos de pilha
O exemplo de política a seguir permite que os usuários criem pilhas, mas negará as solicitações se o modelo da pilha incluir algum recurso do serviço IAM. A política também requer que os usuários especifiquem o parâmetro `ResourceTypes`, que está disponível apenas para solicitações de AWS CLI e de API. Essa política usa instruções de negação explícita de forma que se qualquer outra política conceder permissões adicionais, essa política sempre permanecerá em vigor (uma instrução de negação explícita sempre substitui uma instrução de permissão explícita).
------
#### [ 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"
}
}
}
]
}
```
------
## Permitir a criação de pilhas com tipos de recursos específicos
A política a seguir é semelhante ao exemplo anterior. A política concede aos usuários permissões para criar uma pilha, a menos que o modelo da pilha inclua algum recurso do serviço IAM. Ela também requer que os usuários especifiquem o parâmetro `ResourceTypes`, que está disponível apenas para solicitações de AWS CLI e de API. Essa política é mais simples, mas não usa instruções de negação explícita. Outras políticas, que concedem permissões adicionais, podem substituir essa política.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect" : "Allow",
"Action" : [ "cloudformation:CreateStack" ],
"Resource" : "*",
"Condition" : {
"ForAllValues:StringNotLikeIfExists" : {
"cloudformation:ResourceTypes" : [ "AWS::IAM::*" ]
},
"Null":{
"cloudformation:ResourceTypes": "false"
}
}
}
]
}
```
------
## Controlar o acesso com base nas ações de API de mutação de recurso
O exemplo de política a seguir concede permissões para filtrar o acesso pelo nome de uma ação de API de mutação de recurso. Isso é usado para controlar quais APIs os usuários do IAM podem usar para adicionar ou remover tags de uma pilha ou um conjunto de pilhas. A operação usada para adicionar ou remover tags deve ser adicionada como valor para a chave de condição. A política a seguir concede as permissões de `TagResource` e `UntagResource` à operação de mutação `CreateStack`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [{
"Sid": "CreateActionConditionPolicyForTagUntagResources",
"Effect": "Allow",
"Action": [
"cloudformation:TagResource",
"cloudformation:UntagResource"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"cloudformation:CreateAction": [
"CreateStack"
]
}
}
}]
}
```
------
## Restringir operações de conjunto de pilhas com base na região e nos tipos de recursos
O exemplo de política a seguir concede permissões para conjuntos de pilhas gerenciados pelo serviço. Um usuário com essa política só pode executar operações em conjuntos de pilhas com modelos que contêm tipos de recurso do Amazon S3 (`AWS::S3::*`) ou o tipo de recurso `AWS::SES::ConfigurationSet`. Se o usuário entrou na conta de gerenciamento da organização com o ID `123456789012`, ele também poderá executar operações apenas em conjuntos de pilhas que tenham como destino a UO com o ID `ou-1fsfsrsdsfrewr` e apenas no conjunto de pilhas com o ID `stack-set-id` que tenha como destino a Conta da AWS com o ID `987654321012`.
As operações do conjunto de pilha falharão se o modelo de conjunto de pilhas contiver tipos de recursos diferentes dos especificados na política ou se os destinos de implementação forem OU ou IDs de conta diferentes dos especificados na política para as contas de gerenciamento e conjuntos de pilhas correspondentes.
Essas restrições de política só se aplicam quando as operações de conjunto de pilha têm como destino as regiões `us-east-1`, `us-west-2` ou `eu-west-2` Regiões da 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"
]
}
}
}
]
}
```
------
## Permitir todas as operações do gerador de IaC
A política a seguir permite acesso às ações do CloudFormation relacionadas à varredura de recursos e ao gerenciamento de modelos do gerador de IaC. A primeira instrução concede permissões para descrever, listar e iniciar varreduras de recursos. Também permite acesso às permissões adicionais necessárias (`cloudformation:GetResource`, `cloudformation:ListResources` e `cloudformation:ListTypes`) que permitem que o gerador de IaC recupere informações sobre os recursos e os tipos de recursos disponíveis. A segunda instrução concede permissões totais para criar, excluir, descrever, listar e atualizar os modelos gerados.
Você também deve conceder permissões de leitura nos serviços da AWS de destino a qualquer pessoa que vá fazer varreduras de recursos com o gerador de IaC. Para obter mais informações, consulte [Permissões do IAM necessárias para varrer recursos](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 Políticas gerenciadas pela do AWS CloudFormation
Uma política gerenciada pela AWS é uma política autônoma criada e administrada pela AWS. As políticas gerenciadas pela AWS são criadas para fornecer permissões a vários casos de uso comuns e permitir a atribuição de permissões a usuários, grupos e perfis.
Lembre-se de que as políticas gerenciadas pela AWS podem não conceder permissões de privilégio mínimo para casos de uso específicos, por estarem disponíveis para uso por todos os clientes da AWS. Recomendamos que você reduza ainda mais as permissões definindo as [ políticas gerenciadas pelo cliente](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#customer-managed-policies) que são específicas para seus casos de uso.
Não é possível alterar as permissões definidas em políticas gerenciadas pela AWS. Caso a AWS faça atualizações nas permissões estabelecidas em uma política gerenciada pela AWS, estas mudanças impactarão todas as identidades das entidades principais (usuários, grupos e funções) vinculadas à esta política. A AWS é mais propensa a atualizar uma política gerenciada pela AWS durante o lançamento de um novo serviço da AWS ou quando novas operações de API estiverem disponíveis para serviços existentes.
Para obter mais informações, consulte [Políticas gerenciadas pela AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) no *Manual do usuário do IAM*.
## Política gerenciada pela AWS: AWSCloudFormationFullAccess
Você pode anexar `AWSCloudFormationFullAccess` aos seus usuários, grupos e funções.
Esta política concede permissões para ter acesso total aos recursos e às ações do CloudFormation.
**Detalhes das permissões**
Esta política inclui as seguintes permissões.
+ `cloudformation`: permite que as entidades principais executem todas as ações do CloudFormation em todos os recursos.
Para visualizar as permissões dessa política, consulte [AWSCloudFormationFullAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSCloudFormationFullAccess.html) no *Guia de referência de políticas gerenciadas pela AWS*.
## Política gerenciada pela AWS: AWSCloudFormationReadOnlyAccess
Você pode anexar `AWSCloudFormationReadOnlyAccess` aos seus usuários, grupos e funções.
Essa política concede permissões que oferecem acesso somente leitura aos recursos e ações do CloudFormation.
**Detalhes das permissões**
Esta política inclui as seguintes permissões.
+ `cloudformation`: permite que as entidades principais executem ações somente leitura do CloudFormation, como descrever pilhas, listar recursos e visualizar modelos, mas não permite criar, atualizar ou excluir pilhas.
Para visualizar as permissões dessa política, consulte [AWSCloudFormationReadOnlyAccess](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AWSCloudFormationReadOnlyAccess.html) no *Guia de referência de políticas gerenciadas pela AWS*.
## Atualizações do CloudFormation nas políticas gerenciadas pela AWS
Confira os detalhes sobre as atualizações em políticas gerenciadas pela AWS do CloudFormation desde que esse serviço começou a monitorar essas alterações. Para obter alertas automáticos sobre as alterações feitas nesta página, inscreva-se no feed RSS na página de histórico de documentos do CloudFormation.
| Alteração | Descrição | Data |
| --- | --- | --- |
| [AWSCloudFormationReadOnlyAccess](#security-iam-awsmanpol-AWSCloudFormationReadOnlyAccess): atualização de uma política existente | O CloudFormation adicionou novas permissões para permitir ações de `cloudformation:BatchDescribe*` para operações de descrição em lote. | 30 de janeiro de 2026 |
| [AWSCloudFormationReadOnlyAccess](#security-iam-awsmanpol-AWSCloudFormationReadOnlyAccess): atualização de uma política existente | O CloudFormation adicionou novas permissões para permitir ações de `cloudformation:Detect*` para recursos de detecção de desvio de pilha. | 13 de novembro de 2019 |
| [AWSCloudFormationReadOnlyAccess](#security-iam-awsmanpol-AWSCloudFormationReadOnlyAccess): atualização de uma política existente | O CloudFormation adicionou novas permissões para permitir ações de `cloudformation:EstimateTemplateCost`, `cloudformation:Get*`, e `cloudformation:ValidateTemplate`. | 2 de novembro de 2017 |
| [AWSCloudFormationFullAccess](#security-iam-awsmanpol-AWSCloudFormationFullAccess): nova política | O CloudFormation adicionou uma nova política gerenciada pela AWS que concede acesso total às ações e aos recursos do CloudFormation. | 26 de julho de 2019 |
| [AWSCloudFormationReadOnlyAccess](#security-iam-awsmanpol-AWSCloudFormationReadOnlyAccess): atualização de uma política existente | O CloudFormation adicionou novas permissões para permitir ações de `cloudformation:DetectStackDrift` e `cloudformation:DetectStackResourceDrift` para detecção de desvio de pilha. | 6 de fevereiro de 2019 |
| [AWSCloudFormationReadOnlyAccess](#security-iam-awsmanpol-AWSCloudFormationReadOnlyAccess): nova política | O CloudFormation adicionou uma nova política gerenciada pela AWS que concede acesso somente leitura às ações e aos recursos do CloudFormation. | 6 de fevereiro de 2015 |
| O CloudFormation começou a rastrear alterações | O CloudFormation começou a rastrear alterações em suas políticas gerenciadas pela AWS. | 6 de fevereiro de 2015 |
# Função de serviço do CloudFormation
Um *perfil de serviço* é um perfil do AWS Identity and Access Management (IAM) que permite que o CloudFormation faça chamadas a recursos em uma pilha em seu nome. Você pode especificar um perfil do IAM que permita que o CloudFormation crie, atualize ou exclua seus recursos da pilha. Por padrão, o CloudFormation usa uma sessão temporária que ele gera a partir de suas credenciais de usuário para operações de pilha. Se você especificar uma função de serviço, o CloudFormation usará as credenciais da função.
Use uma função de serviço para especificar explicitamente as ações que o CloudFormation pode realizar, que podem nem sempre ser sempre as mesmas ações que você ou outros usuários podem realizar. Por exemplo, você pode ter privilégios administrativos, mas pode limitar o acesso do CloudFormation a apenas ações do Amazon EC2.
Você cria o perfil de serviço e a respectiva política de permissão com o serviço do IAM. Para obter mais informações sobre a criação de um perfil de serviço, consulte [Criar um perfil para delegar permissões a um serviço da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) no *Guia do usuário do IAM*. Especifique o CloudFormation (`cloudformation.amazonaws.com`) como o serviço que pode assumir a função.
Para associar uma função de serviço a uma pilha, especifique a função ao criar a pilha. Para obter detalhes, consulte [Configurar opções da pilha](cfn-console-create-stack.md#configure-stack-options). Você também pode alterar o perfil de serviço ao atualizar a pilha no console ou [https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_DeleteStack.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_DeleteStack.html) a pilha via API. Antes de especificar um perfil de serviço, certifique-se de ter permissão para aprová-la (`iam:PassRole`). A permissão `iam:PassRole` especifica quais perfis você pode usar. Para obter mais informações, consulte [Conceder permissões ao usuário para passar um perfil para um serviço da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_passrole.html) no *Guia do usuário do IAM*.
**Importante**
Quando você especifica uma função de serviço, o CloudFormation sempre usa essa função para todas as operações que serão executadas nessa pilha. Não é possível remover uma função de serviço associada a uma pilha depois que ela é criada. Outros usuários com permissão para executar operações nessa pilha podem usar esse perfil, independentemente de terem a permissão `iam:PassRole` ou não. Se o perfil inclui permissões que o usuário não precisa, você pode ampliar involuntariamente as permissões de um usuário. Certifique-se de que a função concede o menor privilégio. Para obter mais informações, consulte [Aplicar permissões de privilégio mínimo](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege), no *Guia do usuário do IAM*.
# Prevenção contra o ataque do “substituto confuso” em todos os serviços
“Confused deputy” é um problema de segurança no qual uma entidade sem permissão para executar uma ação pode coagir uma entidade mais privilegiada a executá-la. Na AWS, a personificação entre serviços pode resultar no problema do ‘confused deputy’. A personificação entre serviços pode ocorrer quando um serviço (o *serviço de chamada*) chama outro serviço (o *serviço chamado*). O serviço de chamada pode ser manipulado de modo a usar suas permissões para atuar nos recursos de outro cliente de uma forma na qual ele não deveria ter permissão para acessar. Para evitar isso, a AWS fornece ferramentas que ajudam você a proteger seus dados para todos os serviços com entidades principais de serviço que receberam acesso aos recursos em sua conta.
Recomendamos o uso das chaves de contexto de condição global [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) em políticas de recursos para limitar as permissões que o CloudFormation concede a outro serviço para um recurso específico, como uma extensão do CloudFormation. Use `aws:SourceArn` se quiser que apenas um recurso seja associado ao acesso entre serviços. Use `aws:SourceAccount` se quiser permitir que qualquer recurso nessa conta seja associado ao uso entre serviços.
Certifique-se de que o valor de `aws:SourceArn` seja um ARN do recurso que o CloudFormation armazena.
A maneira mais eficaz de se proteger do problema ‘confused deputy’ é usar a chave de contexto de condição global `aws:SourceArn` com o ARN completo do recurso. Se você não souber o ARN completo do recurso ou se especificar vários recursos, use a chave de condição de contexto global `aws:SourceArn` com curingas (`*`) para as partes desconhecidas do ARN. Por exemplo, `arn:aws:cloudformation:*:123456789012:*`.
Se o valor `aws:SourceArn` não contiver o ID da conta, você deverá usar ambas as chaves de contexto de condição global para limitar as permissões.
O exemplo a seguir mostra como é possível usar as chaves de contexto de condição globais `aws:SourceArn` e `aws:SourceAccount` no CloudFormation para evitar o problema confused deputy.
## Exemplo de política de confiança que usa as chaves de condição `aws:SourceArn` e `aws:SourceAccount`
Para serviços de registro, o CloudFormation faz chamadas para o AWS Security Token Service (AWS STS) para assumir um perfil de serviço em sua conta. Este perfil é configurado para `ExecutionRoleArn` na operação [https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_RegisterType.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_RegisterType.html) e definido como `LogRoleArn` na operação [https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_LoggingConfig.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_LoggingConfig.html). Para obter mais informações, consulte [Configure um perfil de execução com permissões do IAM e uma política de confiança para acesso público à extensão](registry-public.md#registry-public-enable-execution-role).
Este exemplo de política de confiança de perfil usa instruções de condição para limitar o recurso `AssumeRole` no perfil de serviço somente para as ações na extensão do CloudFormation especificada na conta indicada. As condições `aws:SourceArn` e `aws:SourceAccount` são avaliadas de forma independente. Qualquer solicitação para usar o perfil de serviço deve atender às duas condições.
------
#### [ 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"
}
}
}
]
}
```
------
## Mais informações
Para obter exemplos de políticas que usam as chaves de contexto de condição global `aws:SourceArn` e `aws:SourceAccount` para um perfil de serviço usado pelo StackSets, consulte [Configurar chaves globais para atenuar problemas de confused deputy](stacksets-prereqs-self-managed.md#confused-deputy-mitigation).
Para obter mais informações, consulte [Atualizar uma política de confiança de perfil](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_update-role-trust-policy.html) no *Guia do usuário do IAM*.
# Solicitações de sessões de acesso direto (FAS) e avaliação de permissões
Ao criar, atualizar e excluir pilhas do CloudFormation, os usuários têm a opção de especificar um ARN de perfil do IAM. Se nenhum perfil for fornecido, o CloudFormation usará seu mecanismo de serviço padrão para interagir com outros serviços da AWS. Nesse cenário, o chamador deve ter as permissões necessárias para os recursos sendo gerenciados. Alternativamente, quando um usuário fornecer seu próprio perfil do IAM, o CloudFormation assumirá esse perfil para realizar interações de serviço em nome dele.
Quer o usuário usuário forneça ou não um perfil do IAM, o CloudFormation gerará um novo token de FAS com escopo reduzido para cada operação de recurso. Portanto, [as chaves de condição relacionadas a FAS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_forward_access_sessions.html#access_fas_policy_conditions), incluindo `aws:ViaAWSService`, são preenchidas em ambos os cenários.
O uso de FAS afeta o modo como as políticas do IAM são avaliadas durante as operações do CloudFormation. Ao criar uma pilha com um modelo que inclui recursos afetados pelas chaves de condição relacionadas a FAS, podem ocorrer negações de permissão.
**Exemplo de política do IAM**
Considere a política do IAM a seguir. O `Statement2` impedirá consistentemente a criação de um recurso `AWS::KMS::Key` no CloudFormation. A restrição será aplicada de modo consistente, seja ou não fornecido o perfil do IAM durante a operação da pilha. Isso ocorre porque a chave de condição `aws:ViaAWSService` é sempre definida como `true` devido ao uso de 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"
}
}
}
]
}
```
------
**Exemplo de modelo de pilha**
Por exemplo, quando um usuário cria uma pilha com o exemplo de modelo a seguir, `aws:ViaAWSService` é definido como `true`, e as permissões do perfil serão substituídas pela política de FAS. A criação da pilha será afetada pelo `Statement2` da política do IAM, que nega a ação `CreateKey`. Isso resulta em um erro de permissão negada.
```
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: '*'
```
Para obter mais informações sobre FAS, consulte [Sessões de acesso direto](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_forward_access_sessions.html) no *Guia do usuário do IAM*.
**nota**
A maioria dos recursos adere a esse comportamento. Porém, se você tiver um sucesso ou uma falha inesperada ao criar, atualizar ou excluir um recurso, e a política do IAM incluir chaves de condição relacionadas a FAS, provavelmente o recurso em questão pertencerá a um pequeno subconjunto de recursos que não seguem esse padrão.
# Registrar em log chamadas de API do CloudFormation com o AWS CloudTrail
O CloudFormation é integrado ao AWS CloudTrail, um serviço que fornece um registro das ações realizadas por um usuário, perfil ou serviço da AWS no CloudFormation. O CloudTrail captura todas as chamadas de API para o CloudFormation como eventos, incluindo as chamadas do console do CloudFormation e chamadas de código para APIs do CloudFormation. Se você criar uma trilha, poderá habilitar a entrega contínua de eventos do CloudTrail a um bucket do Amazon S3, incluindo eventos do CloudFormation. Se você não configurar uma trilha, ainda poderá visualizar os eventos mais recentes no console do CloudTrail em **Histórico de eventos**. Ao usar as informações coletadas pelo CloudTrail, é possível determinar a solicitação que foi feita ao CloudFormation, o endereço IP do qual a solicitação foi feita, quem a fez e quando ela foi feita, além de outros detalhes.
Para saber mais sobre o CloudTrail, consulte o [Guia do usuário do AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/).
**Topics**
+ [Informações do CloudFormation no CloudTrail](#cloudformation_info_in_cloudtrail)
+ [Noções básicas sobre entradas de arquivos de log do CloudFormation](#understanding_cloudformation_entries)
## Informações do CloudFormation no CloudTrail
O CloudTrail é habilitado em sua conta AWS ao criá-la. Quando ocorre atividade no CloudFormation, essa atividade é registrada em um evento do CloudTrail junto com outros eventos de serviços da AWS no **Event history** (Histórico de eventos). É possível visualizar, pesquisar e baixar eventos recentes em sua AWS conta. Para saber mais, consulte [Viewing events with CloudTrail event history](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html).
Para obter um registro de eventos em andamento na sua conta da AWS, incluindo eventos do CloudFormation, crie uma trilha. Uma trilha permite que o CloudTrail entregue arquivos de log a um bucket do Amazon S3. Por padrão, quando você cria uma trilha no console, ela é aplicada a todas as regiões da . A trilha registra logs de eventos de todas as Regiões na AWS divisória e entrega os arquivos do log para o bucket Amazon S3 especificado. Além disso, é possível configurar outros serviços da AWS para analisar mais ainda mais e agir com base nos dados de eventos coletados nos logs do CloudTrail. Para obter mais informações, consulte:
+ [Visão geral da criação de uma trilha](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html)
+ [Serviços e integrações compatíveis com o CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-aws-service-specific-topics.html#cloudtrail-aws-service-specific-topics-integrations)
+ [Configuração notificações do Amazon SNS para o CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/configure-sns-notifications-for-cloudtrail.html)
+ [Receber arquivos de log do CloudTrail de várias regiões](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/receive-cloudtrail-log-files-from-multiple-regions.html) e [Receber arquivos de log do CloudTrail de várias contas](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html)
Todas as ações do CloudFormation são registradas em log pelo CloudTrail e estão documentadas na [https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_Operations.html](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_Operations.html). Por exemplo, as chamadas para as seções `CreateStack`, `DeleteStack` e `ListStacks` geram entradas nos arquivos de log do CloudTrail.
Cada entrada de log ou evento contém informações sobre quem gerou a solicitação. As informações de identidade ajudam a determinar:
+ Se a solicitação foi feita com credenciais de usuário-raiz ou usuário do IAM.
+ Se a solicitação foi feita com credenciais de segurança temporárias de um perfil ou de um usuário federado.
+ Se a solicitação foi feita por outro serviço da AWS.
Para saber mais, consulte [Elemento userIdentity do CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-user-identity.html).
## Noções básicas sobre entradas de arquivos de log do CloudFormation
Uma trilha é uma configuração que permite a entrega de eventos como arquivos de log a um bucket Amazon S3 especificado. Os arquivos de log do CloudTrail contêm uma ou mais entradas de log. Um evento representa uma única solicitação de qualquer origem e inclui informações sobre a operação solicitada, a data e a hora da operação, os parâmetros de solicitação etc. Os arquivos de log do CloudTrail não são um rastreamento de pilha ordenada de chamadas de API pública, portanto, não são exibidos em uma ordem específica.
O exemplo a seguir mostra uma entrada de log do CloudTrail que demonstra a operação `CreateStack`. A operação foi feita por um usuário do IAM denominado Alice.
**nota**
Apenas os nomes de chaves de parâmetros de entrada são registrados no log. Valores de parâmetros não são registrados no log.
```
{
"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"
}
```
O exemplo a seguir mostra que Alice chamou a operação `UpdateStack` na pilha `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"
}
```
O exemplo a seguir mostra que Alice chamou a operação `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"
}
```
O exemplo a seguir mostra que Alice chamou a operação `DescribeStacks` na pilha `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"
}
```
O exemplo a seguir mostra que Alice chamou a operação `DeleteStack` na pilha `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"
}
```
# Segurança da infraestrutura no CloudFormation
Por ser um serviço gerenciado, o AWS CloudFormation é protegido pela segurança da rede global da AWS. Para obter informações sobre serviços de segurança da AWS e como a AWS protege a infraestrutura, consulte [Segurança na Nuvem AWS](https://aws.amazon.com/security/). Para projetar seu ambiente da AWS usando as práticas recomendadas de segurança da infraestrutura, consulte [Proteção de Infraestrutura](https://docs.aws.amazon.com/wellarchitected/latest/security-pillar/infrastructure-protection.html) em *Pilar de Segurança: AWS Well‐Architected Framework*.
Você usa CloudFormation chamadas de API publicadas pela para acessarAWS o por meio da rede. Os clientes devem oferecer compatibilidade com:
+ Transport Layer Security (TLS). Exigimos TLS 1.2 e recomendamos TLS 1.3.
+ Conjuntos de criptografia com perfect forward secrecy (PFS) como DHE (Ephemeral Diffie-Hellman) ou ECDHE (Ephemeral Elliptic Curve Diffie-Hellman). A maioria dos sistemas modernos, como Java 7 e versões posteriores, comporta esses modos.
Você chamar essas operações de API de qualquer local da rede, mas o CloudFormation não é suportado por políticas de acesso baseadas em recursos, que podem incluir restrições com base no endereço IP de origem. Você também pode usar políticas do CloudFormation para controlar o acesso de Amazon Virtual Private Cloud (Amazon VPC) endpoints ou de VPCs específicas. Efetivamente, isso isola o acesso à rede para um determinado recurso do CloudFormation apenas da VPC específica dentro da rede da AWS.
# Resiliência no CloudFormation
A infraestrutura global da AWS é criada com base em AWS Regiões e Zonas de Disponibilidade. AWS As regiões fornecem várias zonas de disponibilidade separadas e isoladas fisicamente, conectadas com baixa latência, throughput elevado e redes altamente redundantes. Com as zonas de disponibilidade, é possível projetar e operar aplicações e bancos de dados que automaticamente executam o failover entre as zonas sem interrupção. As zonas de disponibilidade são altamente disponíveis, tolerantes a falhas e escaláveis que uma ou várias infraestruturas de data center tradicionais.
Para obter mais informações sobre regiões e zonas de disponibilidade da AWS, consulte [Infraestrutura global da AWS](https://aws.amazon.com/about-aws/global-infrastructure/).
# Validação de conformidade do CloudFormation
Para saber se um AWS service (Serviço da AWS) está no escopo de programas de conformidade específicos, consulte [Serviços da AWS no escopo por programa de conformidade](https://aws.amazon.com/compliance/services-in-scope/) e selecione o programa de conformidade em que você está interessado. Para obter informações gerais, consulte [Programas de Conformidade da AWS](https://aws.amazon.com/compliance/programs/).
É possível baixar relatórios de auditoria de terceiros usando o AWS Artifact. Para obter mais informações, consulte [Baixar relatórios no AWS Artifact](https://docs.aws.amazon.com/artifact/latest/ug/downloading-documents.html).
Sua responsabilidade de conformidade ao usar o Serviços da AWS é determinada pela confidencialidade dos seus dados, pelos objetivos de conformidade da sua empresa e pelos regulamentos e leis aplicáveis. Para ter mais informações sobre sua responsabilidade pela conformidade ao usar Serviços da AWS, consulte a [documentação da AWS sobre segurança](https://docs.aws.amazon.com/security/).
# Análise de vulnerabilidade e configuração no CloudFormation
A configuração e os controles de TI são uma responsabilidade compartilhada entre a AWS e você, nosso cliente. Para obter mais informações, consulte o AWS [modelo de responsabilidade compartilhada da ](https://aws.amazon.com/compliance/shared-responsibility-model/).
# Práticas recomendadas de segurança do CloudFormation
O CloudFormation oferece uma série de recursos de segurança a serem considerados no desenvolvimento e na implementação das suas próprias políticas de segurança. As práticas recomendadas a seguir são diretrizes gerais e não representam uma solução completa de segurança. Como essas práticas recomendadas podem não ser adequadas ou suficientes para o seu ambiente, trate-as como considerações úteis em vez de prescrições.
**Topics**
+ [Usar o IAM para controlar o acesso](#use-iam-to-control-access)
+ [Não incorporar credenciais em seus modelos](#creds)
+ [Use o AWS CloudTrail para registrar chamadas do CloudFormation](#cloudtrail)
## Usar o IAM para controlar o acesso
O IAM é um serviço da AWS que você pode usar para gerenciar usuários e suas respectivas permissões na AWS. É possível usar o IAM com o CloudFormation para especificar quais ações do CloudFormation os usuários podem executar, como visualizar os modelos de pilha, criar pilhas ou excluir pilhas. Além disso, qualquer pessoa que gerencie as pilhas do CloudFormation precisará de permissões para os recursos dentro dessas pilhas. Por exemplo, se os usuários quiserem usar o CloudFormation para executar, atualizar ou encerrar instâncias do Amazon EC2, eles precisarão ter permissão para chamar as ações relevantes do Amazon EC2.
Na maioria dos casos, os usuários precisam de acesso total para gerenciar todos os recursos em um modelo. O CloudFormation faz chamadas para criar, modificar e excluir esses recursos em nome dele. Para permissões separadas entre um usuário e o serviço do CloudFormation, use um perfil de serviço. O CloudFormation usa a política do perfil de serviço para fazer chamadas em vez da política do usuário. Para obter mais informações, consulte [Função de serviço do CloudFormation](using-iam-servicerole.md).
## Não incorporar credenciais em seus modelos
Em vez de incorporar informações confidenciais nos modelos do CloudFormation, é recomendável usar *referências dinâmicas* no modelo de pilha.
As referências dinâmicas fornecem uma maneira compacta e avançada para você fazer referência a valores externos que são armazenados e gerenciados em outros serviços, como o Repositório de parâmetros do AWS Systems Manager ou o AWS Secrets Manager. Quando você usa uma referência dinâmica, o CloudFormation recupera o valor da referência especificada, se necessário, durante operações de pilha e conjunto de alterações e passa o valor para o recurso apropriado. No entanto, o CloudFormation nunca armazena o valor real do parâmetro. Para obter mais informações, consulte [Obter valores armazenados em outros serviços usando referências dinâmicas](dynamic-references.md).
O [AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) ajuda você a criptografar, armazenar e recuperar credenciais com segurança para bancos de dados e outros serviços. O [Repositório de parâmetros do AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html) fornece armazenamento hierárquico seguro para o gerenciamento de dados de configuração.
Para obter mais informações sobre a definição de parâmetros do modelo, consulte [Sintaxe de Parameters de modelo do CloudFormation](parameters-section-structure.md).
## Use o AWS CloudTrail para registrar chamadas do CloudFormation
O AWS CloudTrail rastreia qualquer pessoa que faça chamadas de API do CloudFormation na Conta da AWS. As chamadas de API são registradas em log sempre que alguém usa a API do CloudFormation, o console do CloudFormation, um console de back-end ou comandos da AWS CLI do CloudFormation. Ative o registro em log e especifique um bucket do Amazon S3 para armazenar os logs. Dessa forma, se você precisar, poderá auditar quem fez qual chamada do CloudFormation em sua conta. Para obter mais informações, consulte [Registrar em log chamadas de API do CloudFormation com o AWS CloudTrail](cfn-api-logging-cloudtrail.md).
# Acessar o CloudFormation usando um endpoint de interface (AWS PrivateLink)
É possível usar o AWS PrivateLink para criar uma conectividade privada entre a sua VPC e o CloudFormation. Você pode acessar o CloudFormation como se estivesse em sua VPC, sem usar um gateway da Internet, um dispositivo NAT, uma conexão VPN ou uma conexão Direct Connect. As instâncias na sua VPC não precisam de endereços IP públicos para acessar o CloudFormation.
Você estabelece essa conectividade privada criando um *endpoint de interface*, desenvolvido pelo AWS PrivateLink. Criaremos um endpoint de interface de rede em cada sub-rede que você habilitar para o endpoint de interface. Estas são interfaces de rede gerenciadas pelo solicitante que servem como ponto de entrada para o tráfego destinado ao CloudFormation.
CloudFormation suporta fazer chamadas para todas as suas ações de API por meio do endpoint da interface.
## Considerações sobre endpoints da VPC do CloudFormation
Antes de configurar um endpoint de interface, verifique se você atendeu aos pré-requisitos no tópico [Access an AWS service using an interface VPC endpoint](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html) no *AWS PrivateLink Guide*.
Os seguintes pré-requisitos e considerações adicionais se aplicam ao configurar um endpoint de interface para o CloudFormation:
+ Se você tiver recursos na VPC que devam responder a uma solicitação de recurso personalizado ou a uma condição de espera, certifique-se de que eles tenham acesso aos buckets do Amazon S3 específicos do CloudFormation. O CloudFormation tem buckets do S3 em cada região para monitorar respostas a uma solicitação de [recurso personalizado](template-custom-resources.md) ou a uma [condição de espera](using-cfn-waitcondition.md). Caso um modelo inclua recursos personalizados ou condições de espera em uma VPC, a política de endpoint da VPC deve permitir que usuários enviem respostas para os seguintes buckets:
+ Para recursos personalizados, permita o tráfego para o bucket `cloudformation-custom-resource-response-region`. Ao usar recursos personalizados, os nomes de Região da AWS não contêm traços. Por exemplo, `uswest2`.
+ Para condições de espera, permita o tráfego para o bucket `cloudformation-waitcondition-region`. Ao usar condições de espera, os nomes de Região da AWS contêm traços. Por exemplo, `us-west-2`.
Se a política de endpoint bloquear tráfego para esses buckets, o CloudFormation não receberá respostas, e a operação de pilha falhará. Por exemplo, se você tiver um recurso em uma VPC na região `us-west-2` que deva responder a uma condição de espera, o recurso deverá poder enviar uma resposta para o bucket `cloudformation-waitcondition-us-west-2`.
Para obter uma lista de todas as Regiões da AWS em que o CloudFormation está disponível atualmente, consulte a página [CloudFormation endpoints and quotas](https://docs.aws.amazon.com/general/latest/gr/cfn.html) na *Referência geral da Amazon Web Services*.
+ No momento, os VPC endpoints não são compatíveis com solicitações entre regiões: crie o endpoint na mesma região em que planeja emitir suas chamadas de API para o CloudFormation.
+ Endpoints de VPC oferecem suporte somente a DNS fornecido pela Amazon por meio do Amazon Route 53. Se quiser usar seu próprio DNS, poderá usar o encaminhamento de DNS condicional. Para obter mais informações, consulte [Conjuntos de opções DHCP no Amazon VPC](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_DHCP_Options.html) no Manual do usuário da Amazon VPC.
+ O grupo de segurança anexado ao endpoint da VPC deve permitir conexões de entrada na porta 443 na sub-rede privada da VPC.
## Criar um endpoint da VPC de interface para o CloudFormation
É possível criar um endpoint da VPC para o CloudFormation usando a console da Amazon VPC ou a AWS Command Line Interface (AWS CLI). Para obter mais informações, consulte [Create a VPC endpoint](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html#create-interface-endpoint-aws) (Criar um endpoint da VPC) no *Guia do AWS PrivateLink*.
Como criar um endpoint de interface para o CloudFormation usando o seguinte nome de serviço:
+ **com.amazonaws.*region*.cloudformation**: cria um endpoint para as operações de API do CloudFormation.
Se você habilitar o DNS privado para o endpoint da interface, poderá fazer solicitações de API a CloudFormation usando seu nome DNS regional padrão. Por exemplo, `cloudformation.us-east-1.amazonaws.com`.
Nas Regiões da AWS em que os endpoints específicos do FIPS são compatíveis, você também pode criar um endpoint de interface para o CloudFormation usando o seguinte nome de serviço:
+ **com.amazonaws.*region*.cloudformation-fips**: cria um endpoint para a API do CloudFormation que está em conformidade com [Federal Information Processing Standard (FIPS) 140-2](https://aws.amazon.com/compliance/fips/).
Para obter uma lista completa de endpoints do CloudFormation, consulte [endpoints e cotas do CloudFormation](https://docs.aws.amazon.com/general/latest/gr/cfn.html) no *Referência geral da Amazon Web Services*. .
## Criando uma política de endpoint da VPC para o CloudFormation
Uma política de endpoint é um recurso do IAM que pode ser anexado ao endpoint de interface. A política de endpoint padrão permite acesso total ao CloudFormation por meio de endpoint de interface. Para controlar o acesso permitido ao CloudFormation pela VPC, anexe uma política de endpoint personalizada ao endpoint de interface.
Uma política de endpoint especifica as seguintes informações:
+ As entidades principais que podem realizar ações (Contas da AWS, usuários do IAM e perfis do IAM).
+ As ações que podem ser executadas.
+ Os recursos nos quais as ações podem ser executadas.
Para obter mais informações, consulte [Controlar o acesso aos endpoints da VPC usando políticas de endpoint](https://docs.aws.amazon.com/vpc/latest/privatelink/vpc-endpoints-access.html) no *Guia AWS PrivateLink*.
**Exemplo: política de endpoint da VPC para ações do CloudFormation**
Veja a seguir um exemplo de uma política de endpoint para o CloudFormation. Quando anexada a um endpoint, essa política concede acesso às ações indicadas do CloudFormation para todos os principais em todos os recursos. O exemplo a seguir nega a todos os usuários a permissão para criar pilhas por meio do endpoint da VPC e permite acesso total a todas as outras ações no serviço do CloudFormation.
```
{
"Statement": [
{
"Action": "cloudformation:*",
"Effect": "Allow",
"Principal": "*",
"Resource": "*"
},
{
"Action": "cloudformation:CreateStack",
"Effect": "Deny",
"Principal": "*",
"Resource": "*"
}
]
}
```