A Amazon não CodeCatalyst está mais aberta a novos clientes. Os clientes atuais podem continuar usando o serviço normalmente. Para obter mais informações, consulte [Como migrar do CodeCatalyst](migration.md).
As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Implantação de uma pilha CloudFormation
Esta seção descreve como implantar uma AWS CloudFormation pilha usando um CodeCatalyst fluxo de trabalho. Para fazer isso, você deve adicionar a ação **Deploy CloudFormation stack** ao seu fluxo de trabalho. A ação implanta uma CloudFormation pilha de recursos AWS com base em um modelo fornecido por você. O modelo pode ser um:
+ CloudFormation modelo — Para obter mais informações, consulte Como [trabalhar com CloudFormation modelos](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html).
+ AWS SAM modelo — Para obter mais informações, consulte a [especificação AWS Serverless Application Model (AWS SAM)](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification.html).
**nota**
Para usar um AWS SAM modelo, primeiro você deve empacotar seu AWS SAM aplicativo usando a `[sam package](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-package.html)` operação. Para ver um tutorial que mostra como fazer esse empacotamento automaticamente como parte de um CodeCatalyst fluxo de trabalho da Amazon, consulte[Tutorial: Implantar uma aplicação sem servidor](deploy-tut-lambda.md).
Se a pilha já existir, a ação executará a CloudFormation `[CreateChangeSet](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateChangeSet.html)` operação e, em seguida, a `[ExecuteChangeSet](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_ExecuteChangeSet.html)` operação. A ação espera que as alterações sejam implantadas e se marca como bem-sucedida ou com falha, dependendo dos resultados.
Use a ação **Deploy CloudFormation stack** se você já tiver um AWS SAM modelo CloudFormation ou que contenha recursos que gostaria de implantar, ou se planeja gerar um automaticamente como parte de uma [ação de criação](build-add-action.md) de fluxo de trabalho usando ferramentas como AWS SAM e. [AWS Cloud Development Kit (AWS CDK)](https://docs.aws.amazon.com/cdk/latest/guide/home.html)
Não há restrições sobre o modelo que você pode usar, seja o que for que você possa criar CloudFormation ou AWS SAM usar com a ação **Deploy CloudFormation stack**.
**dica**
Para ver um tutorial que mostra como implantar um aplicativo sem servidor usando a ação **Deploy CloudFormation stack**, consulte. [Tutorial: Implantar uma aplicação sem servidor](deploy-tut-lambda.md)
**Topics**
+ [Imagem de tempo de execução usada pela ação 'Deploy CloudFormation stack'](#deploy-action-cfn-runtime)
+ [Tutorial: Implantar uma aplicação sem servidor](deploy-tut-lambda.md)
+ [Adicionando a ação “Deploy CloudFormation stack”](deploy-action-cfn-adding.md)
+ [Configurar reversões](deploy-consumption-enable-alarms.md)
+ [Variáveis de “ CloudFormation pilha de implantação”](deploy-action-cfn-variables.md)
+ [Ação “Implantar CloudFormation pilha” YAML](deploy-action-ref-cfn.md)
## Imagem de tempo de execução usada pela ação 'Deploy CloudFormation stack'
A ação **Deploy CloudFormation stack** é executada em uma [imagem de novembro de 2022](build-images.md#build.previous-image). Para obter mais informações, consulte [Imagens ativas](build-images.md#build-curated-images).
# Tutorial: Implantar uma aplicação sem servidor
Neste tutorial, você aprende a criar, testar e implantar um aplicativo sem servidor como uma CloudFormation pilha usando um fluxo de trabalho.
A aplicação neste tutorial é uma aplicação web simples que gera uma mensagem “Hello World”. Ele consiste em uma AWS Lambda função e um Amazon API Gateway, e você o cria usando o [AWS Serverless Application Model (AWS SAM)](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html), que é uma extensão do [CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html).
**Topics**
+ [Pré-requisitos](#deploy-tut-lambda-cfn-prereqs)
+ [Etapa 1: criar um repositório de origem](#deploy-tut-lambda-cfn-source)
+ [Etapa 2: criar AWS funções](#deploy-tut-lambda-cfn-roles)
+ [Etapa 3: adicionar AWS funções a CodeCatalyst](#deploy-tut-lambda-cfn-roles-add)
+ [Etapa 4: criar um bucket do Amazon S3](#deploy-tut-lambda-cfn-s3)
+ [Etapa 5: adicionar arquivos de origem](#deploy-tut-lambda-cfn-files)
+ [Etapa 6: criar e executar um fluxo de trabalho](#deploy-tut-lambda-cfn-workflow)
+ [Etapa 7: fazer uma alteração](#deploy-tut-lambda-cfn-change)
+ [Limpeza](#deploy-tut-lambda-cfn-clean-up)
## Pré-requisitos
Antes de começar
+ Você precisa de um CodeCatalyst **espaço** com uma AWS conta conectada. Para obter mais informações, consulte [Criar um espaço](spaces-create.md).
+ Em seu espaço, você precisa de um projeto vazio chamado:
```
codecatalyst-cfn-project
```
Use a opção **Começar do zero** para criar esse projeto.
Para obter mais informações, consulte [Criando um projeto vazio na Amazon CodeCatalyst](projects-create.md#projects-create-empty).
+ Em seu projeto, você precisa de um CodeCatalyst **ambiente** chamado:
```
codecatalyst-cfn-environment
```
Configure esse ambiente da seguinte forma:
+ Escolha qualquer tipo, como **Não produção**.
+ Conecte sua AWS conta a ela.
+ Para o **Perfil do IAM padrão**, escolha qualquer perfil. Você especificará um perfil diferente posteriormente.
Para obter mais informações, consulte [Implantação em e Contas da AWS VPCs](deploy-environments.md).
## Etapa 1: criar um repositório de origem
Nesta etapa, você cria um repositório de origem no CodeCatalyst. Esse repositório é usado para armazenar os arquivos de origem do tutorial, como o arquivo da função do Lambda.
Para ter mais informações sobre repositórios de origem, consulte [Criar um repositório de origem](source-repositories-create.md).
**Como criar um repositório de origem**
1. Em CodeCatalyst, no painel de navegação, escolha **Código** e, em seguida, escolha **Repositórios de origem**.
1. Escolha **Adicionar repositório** e selecione **Criar repositório**.
1. Em **Nome do repositório**, insira:
```
codecatalyst-cfn-source-repository
```
1. Escolha **Criar**.
Agora você criou um repositório chamado `codecatalyst-cfn-source-repository`.
## Etapa 2: criar AWS funções
Nesta etapa, você cria as seguintes funções AWS do IAM:
+ **Função de implantação** — concede permissão à ação CodeCatalyst **Deploy CloudFormation stack** para acessar sua AWS conta e CloudFormation serviço onde você implantará seu aplicativo sem servidor. A ação **Deploy CloudFormation stack** faz parte do seu fluxo de trabalho.
+ **Função de criação** — concede à ação de CodeCatalyst criação permissão para acessar sua AWS conta e gravar no Amazon S3, onde seu pacote de aplicativos sem servidor será armazenado. A ação de criação faz parte do seu fluxo de trabalho.
+ **Função do Stack** — concede CloudFormation permissão para ler e modificar os recursos especificados no AWS SAM modelo que você fornecerá posteriormente. Também concede permissão para CloudWatch.
Para ter informações sobre perfis do IAM, consulte [Perfis do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) no *Guia do usuário do AWS Identity and Access Management *.
**nota**
Para economizar tempo, você pode criar um único perfil, chamado `CodeCatalystWorkflowDevelopmentRole-spaceName`, em vez dos três perfis listados anteriormente. Para obter mais informações, consulte [Criar o perfil **CodeCatalystWorkflowDevelopmentRole-*spaceName*** para a conta e o espaço](ipa-iam-roles.md#ipa-iam-roles-service-create). Entenda que o perfil `CodeCatalystWorkflowDevelopmentRole-spaceName` tem permissões bem amplas que podem representar um risco de segurança. Recomendamos que você use esse perfil apenas em tutoriais e em cenários em que a segurança seja menos preocupante. Este tutorial pressupõe que você esteja criando os três perfis listados anteriormente.
**nota**
Um [perfil de execução do Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html) também é necessário, mas você não precisa criá-lo agora porque o arquivo `sam-template.yml` o cria quando você executa o fluxo de trabalho na etapa 5.
**Para criar um perfil de implantação**
1. Crie uma política para o perfil da seguinte maneira:
1. Faça login em AWS.
1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação, selecione **Políticas**.
1. Escolha **Criar política**.
1. Escolha a guia **JSON**.
1. Exclua o código existente.
1. Cole o seguinte código:
**nota**
Na primeira vez em que o perfil for usado para executar ações de fluxo de trabalho, use o caractere curinga na declaração de política de recursos e defina o escopo da política com o nome do recurso depois que ele estiver disponível.
```
"Resource": "*"
```
1. Escolha **Próximo: tags**.
1. Selecione **Próximo: revisar**.
1. Em **Nome**, insira:
```
codecatalyst-deploy-policy
```
1. Selecione **Criar política**.
Agora você criou uma política de permissões.
1. Crie o perfil de implantação, da seguinte forma:
1. No painel de navegação, escolha **Perfis** e **Criar perfil**.
1. Selecione **Política de confiança personalizada**.
1. Exclua a política de confiança personalizada existente.
1. Adicione a política de confiança personalizada a seguir:
1. Escolha **Próximo**.
1. Em **Políticas de permissões**, procure `codecatalyst-deploy-policy` e marque a caixa de seleção.
1. Escolha **Próximo**.
1. Em **Nome do perfil**, insira:
```
codecatalyst-deploy-role
```
1. Em **Descrição do perfil**, insira:
```
CodeCatalyst deploy role
```
1. Selecione **Criar perfil**.
Agora você criou um perfil de implantação com uma política de confiança e uma política de permissões.
1. Obtenha o ARN do perfil de implantação, da seguinte forma:
1. No painel de navegação, selecione **Perfis**.
1. Na caixa de pesquisa, insira o nome do perfil que você acabou de criar (`codecatalyst-deploy-role`).
1. Escolha o perfil na lista.
A página **Resumo** do perfil é exibida.
1. Na parte superior, copie o valor do **ARN**.
Agora você criou o perfil de implantação com as permissões apropriadas e obteve o ARN.
**Como criar um perfil de criação**
1. Crie uma política para o perfil da seguinte maneira:
1. Faça login em AWS.
1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação, selecione **Políticas**.
1. Escolha **Criar política**.
1. Escolha a guia **JSON**.
1. Exclua o código existente.
1. Cole o seguinte código:
**nota**
Na primeira vez em que o perfil for usado para executar ações de fluxo de trabalho, use o caractere curinga na declaração de política de recursos e defina o escopo da política com o nome do recurso depois que ele estiver disponível.
```
"Resource": "*"
```
1. Escolha **Próximo: tags**.
1. Selecione **Próximo: revisar**.
1. Em **Nome**, insira:
```
codecatalyst-build-policy
```
1. Selecione **Criar política**.
Agora você criou uma política de permissões.
1. Crie o perfil de criação, da seguinte forma:
1. No painel de navegação, escolha **Perfis** e **Criar perfil**.
1. Selecione **Política de confiança personalizada**.
1. Exclua a política de confiança personalizada existente.
1. Adicione a política de confiança personalizada a seguir:
1. Escolha **Próximo**.
1. Em **Políticas de permissões**, procure `codecatalyst-build-policy` e marque a caixa de seleção.
1. Escolha **Próximo**.
1. Em **Nome do perfil**, insira:
```
codecatalyst-build-role
```
1. Em **Descrição do perfil**, insira:
```
CodeCatalyst build role
```
1. Selecione **Criar perfil**.
Agora você criou um perfil de criação com uma política de confiança e uma política de permissões.
1. Obtenha o ARN do perfil de criação, da seguinte forma:
1. No painel de navegação, selecione **Perfis**.
1. Na caixa de pesquisa, insira o nome do perfil que você acabou de criar (`codecatalyst-build-role`).
1. Escolha o perfil na lista.
A página **Resumo** do perfil é exibida.
1. Na parte superior, copie o valor do **ARN**.
Agora você criou o perfil de criação com as permissões apropriadas e obteve o ARN.
**Para criar um perfil de pilha**
1. Faça login AWS usando a conta na qual você deseja implantar sua pilha.
1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Crie o perfil de pilha, da seguinte forma:
1. No painel de navegação, selecione **Perfis**.
1. Escolha **Criar Perfil**.
1. Selecione **Serviço da AWS **.
1. Na seção **Caso de uso**, escolha na **CloudFormation**lista suspensa.
1. Selecione o botão **CloudFormation**de rádio.
1. Selecione **Avançar** na parte inferior.
1. Usando a caixa de pesquisa, encontre as políticas de permissões a seguir e marque as respectivas caixas de seleção.
**nota**
Se você procurar uma política e ela não aparecer, selecione **Limpar filtros** e tente novamente.
+ **CloudWatchFullAccess**
+ **AWS CloudFormationFullAccess**
+ **IAMFullAcesso**
+ **AWS Lambda\$1 FullAccess**
+ **APIGatewayAdministrador da Amazon**
+ **Amazon S3 FullAccess**
+ **AmazonEC2ContainerRegistryFullAccess**
A primeira política permite o acesso para CloudWatch habilitar reversões de pilha quando ocorre um alarme.
As políticas restantes permitem AWS SAM acessar os serviços e recursos na pilha que serão implantados neste tutorial. Para ter mais informações, consulte [Permissões](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-permissions.html) no *Guia do desenvolvedor do AWS Serverless Application Model *.
1. Escolha **Próximo**.
1. Em **Nome do perfil**, insira:
```
codecatalyst-stack-role
```
1. Selecione **Criar perfil**.
1. Obtenha o ARN do perfil de pilha, da seguinte forma:
1. No painel de navegação, selecione **Perfis**.
1. Na caixa de pesquisa, insira o nome do perfil que você acabou de criar (`codecatalyst-stack-role`).
1. Escolha o perfil na lista.
1. Na seção **Resumo**, copie o valor de **ARN**. Você precisará disso mais tarde.
Agora você criou o perfil de pilha com as permissões apropriadas e obteve o ARN.
## Etapa 3: adicionar AWS funções a CodeCatalyst
Nesta etapa, você adiciona a função de criação (`codecatalyst-build-role`) e a função de implantação (`codecatalyst-deploy-role`) à conexão da CodeCatalyst conta em seu espaço.
**nota**
Não é necessário adicionar o perfil de pilha (`codecatalyst-stack-role`) à conexão. Isso ocorre porque a função de pilha é usada por *CloudFormation*(não CodeCatalyst), *depois* que uma conexão já foi estabelecida entre CodeCatalyst e AWS usando a função de implantação. Como a função de pilha não é usada por CodeCatalyst para obter acesso AWS, ela não precisa ser associada a uma conexão de conta.
**Para adicionar perfis de criação e implantação à conexão da sua conta**
1. Dentro CodeCatalyst, navegue até seu espaço.
1. Selecione **Contas da AWS **. Uma lista de conexões de conta é exibida.
1. Escolha a conexão de conta que representa a AWS conta em que você criou suas funções de criação e implantação.
1. Escolha **Gerenciar funções no console de AWS gerenciamento**.
A página **Adicionar função do IAM ao CodeCatalyst espaço da Amazon** é exibida. Talvez seja necessário fazer login para acessá-la.
1. Selecione **Adicionar um perfil existente que você criou no IAM**.
Uma lista suspensa aparece. A lista exibe todos os perfis do IAM com uma política de confiança que inclui as entidades principais de serviço `codecatalyst-runner.amazonaws.com` e `codecatalyst.amazonaws.com`.
1. Na lista suspensa, selecione `codecatalyst-build-role` e **Adicionar perfil**.
1. Escolha **Adicionar perfil do IAM**, selecione **Adicionar um perfil existente que você criou no IAM** e, na lista suspensa, escolha `codecatalyst-deploy-role`. Escolha **Add role (adicionar função)**.
Agora você adicionou os perfis de criação e implantação ao seu espaço.
1. Copie o valor do **nome de CodeCatalyst exibição da Amazon**. Esse valor será necessário posteriormente, ao criar seu fluxo de trabalho.
## Etapa 4: criar um bucket do Amazon S3
Nesta etapa, você cria um bucket do Amazon S3 no qual armazena o arquivo .zip do pacote de implantação da aplicação sem servidor.
**Como criar um bucket do Amazon S3**
1. Abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. No painel principal, selecione **Criar bucket**.
1. Em **Nome do bucket**, insira:
```
codecatalyst-cfn-s3-bucket
```
1. Na **região da AWS **, escolha uma região. Este tutorial pressupõe que você tenha escolhido o **Oeste dos EUA (Oregon) us-west-2**. Para ter informações sobre regiões com suporte do Amazon S3, consulte [Endpoints e cotas do Amazon Simple Storage Service](https://docs.aws.amazon.com/general/latest/gr/s3.html) na *Referência geral da AWS*.
1. Selecione **Criar bucket** na parte inferior da página.
Agora você criou um bucket chamado **codecatalyst-cfn-s3-bucket** na região Oeste dos EUA (Oregon), us-west-2.
## Etapa 5: adicionar arquivos de origem
Nesta etapa, você adiciona vários arquivos de origem do aplicativo ao seu repositório CodeCatalyst de origem. A pasta `hello-world` contém os arquivos da aplicação que você implantará. A pasta `tests` contém testes de unidade. A estrutura de pastas é esta:
```
.
|— hello-world
| |— tests
| |— unit
| |— test-handler.js
| |— app.js
|— .npmignore
|— package.json
|— sam-template.yml
|— setup-sam.sh
```
### Arquivo .npmignore
O arquivo `.npmignore` indica quais arquivos e pastas o npm deve excluir do pacote da aplicação. Neste tutorial, o npm exclui a pasta `tests` porque ela não faz parte da aplicação.
**Como adicionar o arquivo .npmignore**
1. Abra o CodeCatalyst console em [https://codecatalyst.aws/](https://codecatalyst.aws/).
1. Selecione o projeto, `codecatalyst-cfn-project`
1. No painel de navegação, selecione **Código** e, depois, selecione **Repositórios de origem**.
1. Na lista de repositórios de origem, escolha o seu repositório, `codecatalyst-cfn-source-repository`.
1. Em **Arquivos**, selecione **Criar arquivo**.
1. Em **Nome do arquivo**, insira:
```
.npmignore
```
1. Na caixa de texto, insira o código a seguir:
```
tests/*
```
1. Selecione **Confirmar** e, depois, escolha **Confirmar** novamente.
Agora você criou um arquivo chamado `.npmignore` na raiz do repositório.
### Arquivo package.json
O arquivo `package.json` contém metadados importantes sobre seu projeto Node, como nome do projeto, número da versão, descrição, dependências e outros detalhes que descrevem como interagir e executar a aplicação.
O `package.json` neste tutorial inclui uma lista de dependências e um script `test`. O script de teste faz o seguinte:
+ Usando [mocha](https://mochajs.org/), o script de teste executa os testes de unidade especificados em `hello-world/tests/unit/` e grava os resultados em um arquivo `junit.xml` usando o repórter [xunit]().
+ Usando [Istambul (nyc)](https://istanbul.js.org/), o script de teste gera um relatório de cobertura de código (`clover.xml`) usando o repórter [clover](https://openclover.org/doc/manual/4.2.0/general--about-openclover.html). Para ter mais informações, consulte [Uso de repórteres alternativos](https://istanbul.js.org/docs/advanced/alternative-reporters/#clover) na documentação do Istambul.
**Como adicionar o arquivo package.json**
1. No repositório, em **Arquivos**, selecione **Criar arquivo**.
1. Em **Nome do arquivo**, insira:
```
package.json
```
1. Na caixa de texto, insira o código a seguir:
```
{
"name": "hello_world",
"version": "1.0.0",
"description": "hello world sample for NodeJS",
"main": "app.js",
"repository": "https://github.com/awslabs/aws-sam-cli/tree/develop/samcli/local/init/templates/cookiecutter-aws-sam-hello-nodejs",
"author": "SAM CLI",
"license": "MIT",
"dependencies": {
"axios": "^0.21.1",
"nyc": "^15.1.0"
},
"scripts": {
"test": "nyc --reporter=clover mocha hello-world/tests/unit/ --reporter xunit --reporter-option output=junit.xml"
},
"devDependencies": {
"aws-sdk": "^2.815.0",
"chai": "^4.2.0",
"mocha": "^8.2.1"
}
}
```
1. Selecione **Confirmar** e, depois, escolha **Confirmar** novamente.
Agora você adicionou um arquivo chamado `package.json` à raiz do repositório.
### Arquivo sam-template.yml
O arquivo `sam-template.yml` contém as instruções para implantar a função do Lambda e o gateway de API e configurá-los juntos. Ele segue a [especificação do AWS Serverless Application Model modelo](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-specification.html), que estende a especificação do CloudFormation modelo.
Você usa um AWS SAM modelo neste tutorial em vez de um CloudFormation modelo normal porque AWS SAM oferece um tipo de recurso útil [AWS: :Serverless: :Function](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-resource-function.html). Esse tipo executa muitas behind-the-scenes configurações que você normalmente precisa escrever para usar a CloudFormation sintaxe básica. Por exemplo, o `AWS::Serverless::Function` cria uma função do Lambda, uma função de execução do Lambda e mapeamentos da origem do evento que iniciam a função. Você precisa codificar tudo isso se quiser escrevê-lo usando o básico CloudFormation.
Embora este tutorial use um modelo pré-escrito, você pode gerar um como parte do seu fluxo de trabalho usando uma ação de criação. Para obter mais informações, consulte [Implantação de uma pilha CloudFormation](deploy-action-cfn.md).
**Para adicionar o arquivo sam-template.yml**
1. No repositório, em **Arquivos**, selecione **Criar arquivo**.
1. Em **Nome do arquivo**, insira:
```
sam-template.yml
```
1. Na caixa de texto, insira o código a seguir:
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: >
serverless-api
Sample SAM Template for serverless-api
# More info about Globals: https://github.com/awslabs/serverless-application-model/blob/master/docs/globals.rst
Globals:
Function:
Timeout: 3
Resources:
HelloWorldFunction:
Type: AWS::Serverless::Function # For details on this resource type, see https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction
Properties:
CodeUri: hello-world/
Handler: app.lambdaHandler
Runtime: nodejs12.x
Events:
HelloWorld:
Type: Api # For details on this event source type, see https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#api
Properties:
Path: /hello
Method: get
Outputs:
# ServerlessRestApi is an implicit API created out of the events key under Serverless::Function
# Find out about other implicit resources you can reference within AWS SAM at
# https://github.com/awslabs/serverless-application-model/blob/master/docs/internals/generated_resources.rst#api
HelloWorldApi:
Description: "API Gateway endpoint URL for the Hello World function"
Value: !Sub "https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/hello/"
HelloWorldFunction:
Description: "Hello World Lambda function ARN"
Value: !GetAtt HelloWorldFunction.Arn
HelloWorldFunctionIamRole:
Description: "Implicit Lambda execution role created for the Hello World function"
Value: !GetAtt HelloWorldFunctionRole.Arn
```
1. Selecione **Confirmar** e, depois, escolha **Confirmar** novamente.
Agora você adicionou um arquivo chamado `sam-template.yml` à pasta raiz do repositório.
### Arquivo setup-sam.sh
O `setup-sam.sh` arquivo contém as instruções para baixar e instalar o utilitário AWS SAM CLI. O fluxo de trabalho usa esse utilitário para empacotar a origem de `hello-world`.
**Para adicionar o arquivo setup-sam.sh**
1. No repositório, em **Arquivos**, selecione **Criar arquivo**.
1. Em **Nome do arquivo**, insira:
```
setup-sam.sh
```
1. Na caixa de texto, insira o código a seguir:
```
#!/usr/bin/env bash
echo "Setting up sam"
yum install unzip -y
curl -LO https://github.com/aws/aws-sam-cli/releases/latest/download/aws-sam-cli-linux-x86_64.zip
unzip -qq aws-sam-cli-linux-x86_64.zip -d sam-installation-directory
./sam-installation-directory/install; export AWS_DEFAULT_REGION=us-west-2
```
No código anterior, *us-west-2* substitua por sua AWS região.
1. Selecione **Confirmar** e, depois, escolha **Confirmar** novamente.
Agora você adicionou um arquivo chamado `setup-sam.sh` à raiz do repositório.
### Arquivo app.js
O `app.js` contém o código da função do Lambda. Neste tutorial, o código retorna o texto `hello world`.
**Para adicionar o arquivo app.js**
1. No repositório, em **Arquivos**, selecione **Criar arquivo**.
1. Em **Nome do arquivo**, insira:
```
hello-world/app.js
```
1. Na caixa de texto, insira o código a seguir:
```
// const axios = require('axios')
// const url = 'http://checkip.amazonaws.com/';
let response;
/**
*
* Event doc: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-input-format
* @param {Object} event - API Gateway Lambda Proxy Input Format
*
* Context doc: https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-context.html
* @param {Object} context
*
* Return doc: https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html
* @returns {Object} object - API Gateway Lambda Proxy Output Format
*
*/
exports.lambdaHandler = async (event, context) => {
try {
// const ret = await axios(url);
response = {
'statusCode': 200,
'body': JSON.stringify({
message: 'hello world',
// location: ret.data.trim()
})
}
} catch (err) {
console.log(err);
return err;
}
return response
};
```
1. Selecione **Confirmar** e, depois, escolha **Confirmar** novamente.
Agora você criou uma pasta chamada `hello-world` e um arquivo chamado `app.js`.
### Arquivo test-handler.js
O arquivo `test-handler.js` contém testes de unidade para a função do Lambda.
**Para adicionar o arquivo test-handler.js**
1. No repositório, em **Arquivos**, selecione **Criar arquivo**.
1. Em **Nome do arquivo**, insira:
```
hello-world/tests/unit/test-handler.js
```
1. Na caixa de texto, insira o código a seguir:
```
'use strict';
const app = require('../../app.js');
const chai = require('chai');
const expect = chai.expect;
var event, context;
describe('Tests index', function () {
it('verifies successful response', async () => {
const result = await app.lambdaHandler(event, context)
expect(result).to.be.an('object');
expect(result.statusCode).to.equal(200);
expect(result.body).to.be.an('string');
let response = JSON.parse(result.body);
expect(response).to.be.an('object');
expect(response.message).to.be.equal("hello world");
// expect(response.location).to.be.an("string");
});
});
```
1. Selecione **Confirmar** e, depois, escolha **Confirmar** novamente.
Agora você adicionou um arquivo chamado `test-handler.js` abaixo da pasta `hello-world/tests/unit`.
Agora você adicionou todos os seus arquivos de origem.
Reserve um momento para verificar seu trabalho e garantir que colocou todos os arquivos nas pastas corretas. A estrutura de pastas é esta:
```
.
|— hello-world
| |— tests
| |— unit
| |— test-handler.js
| |— app.js
|— .npmignore
|— README.md
|— package.json
|— sam-template.yml
|— setup-sam.sh
```
## Etapa 6: criar e executar um fluxo de trabalho
Nesta etapa, você cria um fluxo de trabalho que empacota o código-fonte do Lambda e o implanta. O fluxo de trabalho consiste nos seguintes blocos de compilação que são executados sequencialmente:
+ Um gatilho: esse gatilho inicia a execução automática do fluxo de trabalho quando você envia uma alteração ao seu repositório de origem. Para ter mais informações sobre gatilhos, consulte [Início da execução automática de um fluxo de trabalho usando gatilhos](workflows-add-trigger.md).
+ Uma ação de teste (`Test`) — No gatilho, essa ação instala o [gerenciador de pacotes Node (npm)](https://www.npmjs.com/) e, depois, executa o comando `npm run test`. Esse comando diz ao npm para executar o script `test` definido no arquivo `package.json`. O script `test`, por sua vez, executa os testes de unidade e gera dois relatórios: um relatório de teste (`junit.xml`) e um relatório de cobertura de código (`clover.xml`). Para obter mais informações, consulte [Arquivo package.json](#deploy-tut-lambda-cfn-files-package-json).
Em seguida, a ação de teste transforma os relatórios XML em CodeCatalyst relatórios e os exibe no CodeCatalyst console, na guia **Relatórios** da ação de teste.
Para ter mais informações sobre a ação de teste, consulte [Teste com fluxos de trabalhoTeste com fluxos de trabalho](test-workflow-actions.md).
+ Uma ação de construção (`BuildBackend`) — Ao concluir a ação de teste, a ação de compilação baixa e instala a AWS SAM CLI, empacota `hello-world` a fonte e copia o pacote em seu bucket do Amazon S3, onde o serviço Lambda espera que esteja. A ação também gera um novo arquivo de AWS SAM modelo chamado `sam-template-packaged.yml` e o coloca em um artefato de saída chamado. `buildArtifact`
Para ter mais informações sobre a ação de criação, consulte [Criação com fluxos de trabalho](build-workflow-actions.md).
+ Uma ação de implantação (`DeployCloudFormationStack`) — Ao concluir a ação de criação, a ação de implantação procura o artefato de saída gerado pela ação de construção (`buildArtifact`), encontra o AWS SAM modelo dentro dela e, em seguida, executa o modelo. O AWS SAM modelo cria uma pilha que implanta o aplicativo sem servidor.
**Como criar um fluxo de trabalho**
1. No painel de navegação, escolha **CI/CD** e **Fluxos de trabalho**.
1. Selecione **Criar fluxo de trabalho**.
1. Em **Repositório de origem**, selecione `codecatalyst-cfn-source-repository`.
1. Em **Ramificação**, selecione `main`.
1. Escolha **Criar**.
1. Exclua o código de amostra YAML.
1. Adicione o seguinte código YAML:
**nota**
No código YAML a seguir, você pode omitir as seções `Connections:` se quiser. Se você omitir essas seções, deverá garantir que o perfil especificado no campo **Perfil do IAM padrão** em seu ambiente inclua as permissões e as políticas de confiança dos dois perfis descritas em [Etapa 2: criar AWS funções](#deploy-tut-lambda-cfn-roles). Para ter mais informações sobre como configurar um ambiente com um perfil do IAM padrão, consulte [Criar um ambiente](deploy-environments-creating-environment.md).
```
Name: codecatalyst-cfn-workflow
SchemaVersion: 1.0
Triggers:
- Type: PUSH
Branches:
- main
Actions:
Test:
Identifier: aws/managed-test@v1
Inputs:
Sources:
- WorkflowSource
Outputs:
Reports:
CoverageReport:
Format: CLOVERXML
IncludePaths:
- "coverage/*"
TestReport:
Format: JUNITXML
IncludePaths:
- junit.xml
Configuration:
Steps:
- Run: npm install
- Run: npm run test
BuildBackend:
Identifier: aws/build@v1
DependsOn:
- Test
Environment:
Name: codecatalyst-cfn-environment
Connections:
- Name: codecatalyst-account-connection
Role: codecatalyst-build-role
Inputs:
Sources:
- WorkflowSource
Configuration:
Steps:
- Run: . ./setup-sam.sh
- Run: sam package --template-file sam-template.yml --s3-bucket codecatalyst-cfn-s3-bucket --output-template-file sam-template-packaged.yml --region us-west-2
Outputs:
Artifacts:
- Name: buildArtifact
Files:
- "**/*"
DeployCloudFormationStack:
Identifier: aws/cfn-deploy@v1
DependsOn:
- BuildBackend
Environment:
Name: codecatalyst-cfn-environment
Connections:
- Name: codecatalyst-account-connection
Role: codecatalyst-deploy-role
Inputs:
Artifacts:
- buildArtifact
Sources: []
Configuration:
name: codecatalyst-cfn-stack
region: us-west-2
role-arn: arn:aws:iam::111122223333:role/StackRole
template: ./sam-template-packaged.yml
capabilities: CAPABILITY_IAM,CAPABILITY_AUTO_EXPAND
```
No código anterior, substitua:
+ Ambas as instâncias de *codecatalyst-cfn-environment* com o nome do seu ambiente.
+ Ambas as instâncias *codecatalyst-account-connection* com o nome de exibição da conexão da sua conta. O nome de exibição pode ser um número. Para obter mais informações, consulte [Etapa 3: adicionar AWS funções a CodeCatalyst](#deploy-tut-lambda-cfn-roles-add).
+ *codecatalyst-build-role* pelo nome do perfil de criação criado em [Etapa 2: criar AWS funções](#deploy-tut-lambda-cfn-roles).
+ *codecatalyst-cfn-s3-bucket*com o nome do bucket do Amazon S3 em que você criou. [Etapa 4: criar um bucket do Amazon S3](#deploy-tut-lambda-cfn-s3)
+ Ambas as instâncias são *us-west-2* com a região em que seu bucket do Amazon S3 reside (primeira instância) e onde sua pilha será implantada (segunda instância). Essas regiões podem ser diferentes. Este tutorial pressupõe que as duas regiões estejam definidas como `us-west-2`. Para obter detalhes sobre regiões suportadas pelo Amazon S3 CloudFormation, consulte [Pontos de extremidade e cotas de serviço](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) no. *Referência geral da AWS*
+ *codecatalyst-deploy-role* pelo nome do perfil de implantação criado em [Etapa 2: criar AWS funções](#deploy-tut-lambda-cfn-roles).
+ *codecatalyst-cfn-environment*com o nome do ambiente em que você criou[Pré-requisitos](#deploy-tut-lambda-cfn-prereqs).
+ *arn:aws:iam::111122223333:role/StackRole*com o Amazon Resource Name (ARN) da função de pilha que você criou. [Etapa 2: criar AWS funções](#deploy-tut-lambda-cfn-roles)
**nota**
Se você decidiu não criar, implantar e empilhar funções *codecatalyst-build-role**codecatalyst-deploy-role*, substitua e *arn:aws:iam::111122223333:role/StackRole* pelo nome ou ARN da `CodeCatalystWorkflowDevelopmentRole-spaceName` função. Para obter mais informações sobre essa função, consulte [Etapa 2: criar AWS funções](#deploy-tut-lambda-cfn-roles).
Para ter informações sobre as propriedades no código mostrado anteriormente, consulte a [Ação “Implantar CloudFormation pilha” YAML](deploy-action-ref-cfn.md).
1. (Opcional) Selecione **Validar** para garantir que o código YAML seja válido antes de confirmar.
1. Selecione **Confirmar**.
1. Na caixa de diálogo **Confirmar fluxo de trabalho**, insira o seguinte:
1. Em **Nome do arquivo do fluxo de trabalho**, mantenha o padrão, `codecatalyst-cfn-workflow`.
1. Em **Confirmar mensagem**, insira:
```
add initial workflow file
```
1. Em **Repositório**, selecione **codecatalyst-cfn-source-repository**.
1. Em **Nome da ramificação**, selecione **principal**.
1. Selecione **Confirmar**.
Agora você criou um fluxo de trabalho. A execução de um fluxo de trabalho é iniciada automaticamente devido ao gatilho definido na parte superior do fluxo de trabalho. Especificamente, quando você confirmou (e enviou) o arquivo `codecatalyst-cfn-workflow.yaml` ao repositório de origem, o gatilho iniciou a execução do fluxo de trabalho.
**Para visualizar a execução do fluxo de trabalho em andamento**
1. No painel de navegação, escolha **CI/CD** e **Fluxos de trabalho**.
1. Escolha o fluxo de trabalho que você acabou de criar: `codecatalyst-cfn-workflow`.
1. Escolha a guia **Execuções**.
1. Na coluna **ID da execução**, escolha o ID da execução.
1. Selecione **Teste** para ver o andamento dos testes.
1. Escolha **BuildBackend**ver o progresso da compilação.
1. Escolha **DeployCloudFormationStack**ver o progresso da implantação.
Para ter mais informações sobre como visualizar os detalhes da execução, consulte o [Visualização do status e detalhes de execução do fluxo de trabalho](workflows-view-run.md).
1. Quando a **DeployCloudFormationStack**ação terminar, faça o seguinte:
+ Se a execução do fluxo de trabalho for bem-sucedida, vá para o próximo procedimento.
+ Se a execução do fluxo de trabalho falhar no **teste** ou na **BuildBackend**ação, escolha **Logs** para solucionar o problema.
+ Se a execução do fluxo de trabalho falhar na **DeployCloudFormationStack**ação, escolha a ação de implantação e, em seguida, escolha a guia **Resumo**. Role até a seção de **CloudFormation eventos** para ver a mensagem de erro detalhada. Se ocorrer uma reversão, exclua a `codecatalyst-cfn-stack` pilha por meio do CloudFormation console AWS antes de executar novamente o fluxo de trabalho.
**Como verificar a implantação**
1. Depois de uma implantação bem-sucedida, selecione **Variáveis (7)** na barra de menu horizontal próxima à parte superior. (Não selecione **Variáveis** no painel à direita.)
1. Em seguida **HelloWorldApi**, cole o `https://` URL em um navegador.
Uma mensagem JSON **hello world** da função do Lambda é exibida, indicando que o fluxo de trabalho implantou e configurou a função do Lambda e o gateway de API.
**dica**
Você pode CodeCatalyst exibir esse URL no diagrama do fluxo de trabalho com algumas configurações pequenas. Para obter mais informações, consulte [Exibir o URL da aplicação no diagrama do fluxo de trabalho](deploy-app-url.md).
**Para verificar os resultados do teste de unidade e a cobertura do código**
1. No diagrama do fluxo de trabalho, selecione **Teste** e, depois, escolha **Relatórios**.
1. Escolha **TestReport**visualizar os resultados do teste de unidade ou opte por **CoverageReport**visualizar os detalhes da cobertura de código dos arquivos que estão sendo testados, neste caso `app.js` `test-handler.js` e.
**Para verificar os recursos implantados**
1. Faça login no Console de gerenciamento da AWS e abra o console do API Gateway em [https://console.aws.amazon.com/apigateway/](https://console.aws.amazon.com/apigateway/).
1. Observe a **codecatalyst-cfn-stack**API que o AWS SAM modelo criou. O nome da API vem do valor `Configuration/name` no arquivo de definição do fluxo de trabalho (`codecatalyst-cfn-workflow.yaml`).
1. Abra o AWS Lambda console em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. Selecione **Funções** no painel de navegação.
1. Selecione a função do Lambda, `codecatalyst-cfn-stack-HelloWorldFunction-string`.
1. Você pode ver como o gateway de API é um gatilho para a função. Essa integração foi configurada automaticamente pelo tipo AWS SAM `AWS::Serverless::Function` de recurso.
## Etapa 7: fazer uma alteração
Nesta etapa, você faz uma alteração no código-fonte do Lambda e o confirma. Essa confirmação inicia a execução de um novo fluxo de trabalho. Essa execução implanta a nova função do Lambda em um esquema azul esverdeado que usa a configuração padrão de mudança de tráfego especificada no console do Lambda.
**Para fazer uma alteração na origem do Lambda**
1. Em CodeCatalyst, navegue até seu projeto.
1. No painel de navegação, selecione **Código** e, depois, selecione **Repositórios de origem**.
1. Escolha seu repositório de origem `codecatalyst-cfn-source-repository`.
1. Altere o arquivo da aplicação:
1. Escolha a pasta `hello-world`.
1. Escolha o arquivo `app.js`.
1. Escolha **Editar**.
1. Na linha 23, altere `hello world` para **Tutorial complete\$1**.
1. Selecione **Confirmar** e, depois, escolha **Confirmar** novamente.
A confirmação faz com que uma execução do fluxo de trabalho seja iniciada. Essa execução falhará porque você não atualizou os testes de unidade para refletir a alteração do nome.
1. Atualize os testes de unidade:
1. Selecione `hello-world\tests\unit\test-handler.js`.
1. Escolha **Editar**.
1. Na linha 19, altere `hello world` para **Tutorial complete\$1**.
1. Selecione **Confirmar** e, depois, escolha **Confirmar** novamente.
A confirmação faz com que outra execução do fluxo de trabalho seja iniciada. Essa execução será bem-sucedida.
1. No painel de navegação, escolha **CI/CD** e **Fluxos de trabalho**.
1. Selecione `codecatalyst-cfn-workflow` e **Execuções**.
1. Escolha o ID da última execução. O status ainda deve ser em andamento.
1. Escolha **Testar **BuildBackend****, e **DeployCloudFormationStack**para ver o progresso da execução do fluxo de trabalho.
1. Quando o fluxo de trabalho terminar, selecione **Variáveis (7)** na parte superior.
1. Em seguida **HelloWorldApi**, cole o `https://` URL em um navegador.
Uma mensagem `Tutorial complete!` aparece no navegador, indicando que a nova aplicação foi implantada.
## Limpeza
Limpe os arquivos e serviços usados neste tutorial para evitar cobranças por eles.
**Para limpar no CodeCatalyst console**
1. Abra o CodeCatalyst console em [https://codecatalyst.aws/](https://codecatalyst.aws/).
1. Exclua `codecatalyst-cfn-workflow`.
1. Exclua `codecatalyst-cfn-environment`.
1. Exclua `codecatalyst-cfn-source-repository`.
1. Exclua `codecatalyst-cfn-project`.
**Para limpar no Console de gerenciamento da AWS**
1. Limpe da CloudFormation seguinte forma:
1. Abra o CloudFormation console em [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Exclua o `codecatalyst-cfn-stack`.
A exclusão da pilha remove todos os recursos do tutorial dos serviços do gateway de API e Lambda.
1. Limpe no Amazon S3, da seguinte forma:
1. Abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. Selecione a `codecatalyst-cfn-s3-bucket`.
1. Exclua os conteúdos do bucket.
1. Exclua o bucket.
1. Limpe no IAM, da seguinte forma:
1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Exclua o `codecatalyst-deploy-policy`.
1. Exclua o `codecatalyst-build-policy`.
1. Exclua o `codecatalyst-stack-policy`.
1. Exclua o `codecatalyst-deploy-role`.
1. Exclua o `codecatalyst-build-role`.
1. Exclua o `codecatalyst-stack-role`.
Neste tutorial, você aprendeu a implantar um aplicativo sem servidor como uma CloudFormation pilha usando um CodeCatalyst fluxo de trabalho e uma ação **Deploy CloudFormation ** stack.
# Adicionando a ação “Deploy CloudFormation stack”
Use as instruções a seguir para adicionar a ação **Deploy CloudFormation stack** ao seu fluxo de trabalho.
------
#### [ Visual ]
**Para adicionar a ação “Implantar CloudFormation pilha” usando o editor visual**
1. Abra o CodeCatalyst console em [https://codecatalyst.aws/](https://codecatalyst.aws/).
1. Selecione o projeto.
1. No painel de navegação, escolha **CI/CD** e **Fluxos de trabalho**.
1. Selecione o nome do fluxo de trabalho. É possível filtrar pelo nome do repositório ou da ramificação de origem em que o fluxo de trabalho está definido, ou filtrar pelo nome ou o status do fluxo de trabalho.
1. Escolha **Editar**.
1. Selecione **Visual**.
1. No canto superior esquerdo, selecione **\$1 Ações** para abrir o catálogo de ações.
1. **Na lista suspensa, escolha Amazon. CodeCatalyst**
1. Pesquise a ação **Deploy CloudFormation stack** e faça o seguinte:
+ Selecione o sinal de adição (**\$1**) para adicionar a ação ao diagrama do fluxo de trabalho e abrir seu painel de configuração.
Ou
+ Escolha **Deploy CloudFormation stack**. A caixa de diálogo de detalhes da ação é exibida. Nessa caixa de diálogo:
+ (Opcional) Selecione **Download** para [visualizar o código-fonte da ação](workflows-view-source.md#workflows-view-source.title).
+ Selecione **Adicionar ao fluxo de trabalho** para adicionar a ação ao diagrama do fluxo de trabalho e abrir seu painel de configuração.
1. Nas guias **Entradas** e **Configuração**, preencha os campos de acordo com suas necessidades. Para ver uma descrição de cada campo, consulte [Ação “Implantar CloudFormation pilha” YAML](deploy-action-ref-cfn.md). Essa referência fornece informações detalhadas sobre cada campo (e o valor da propriedade YAML correspondente) conforme elas aparecem nos editores YAML e visual.
1. (Opcional) Selecione **Validar** para validar o código YAML do fluxo de trabalho antes de confirmar.
1. Selecione **Confirmar**, insira uma mensagem de confirmação e escolha **Confirmar** novamente.
------
#### [ YAML ]
**Para adicionar a ação “Implantar CloudFormation pilha” usando o editor YAML**
1. Abra o CodeCatalyst console em [https://codecatalyst.aws/](https://codecatalyst.aws/).
1. Selecione o projeto.
1. No painel de navegação, escolha **CI/CD** e **Fluxos de trabalho**.
1. Selecione o nome do fluxo de trabalho. É possível filtrar pelo nome do repositório ou da ramificação de origem em que o fluxo de trabalho está definido, ou filtrar pelo nome ou o status do fluxo de trabalho.
1. Escolha **Editar**.
1. Selecione **YAML**.
1. No canto superior esquerdo, selecione **\$1 Ações** para abrir o catálogo de ações.
1. **Na lista suspensa, escolha Amazon. CodeCatalyst**
1. Pesquise a ação **Deploy CloudFormation stack** e faça o seguinte:
+ Selecione o sinal de adição (**\$1**) para adicionar a ação ao diagrama do fluxo de trabalho e abrir seu painel de configuração.
Ou
+ Escolha **Deploy CloudFormation stack**. A caixa de diálogo de detalhes da ação é exibida. Nessa caixa de diálogo:
+ (Opcional) Selecione **Download** para [visualizar o código-fonte da ação](workflows-view-source.md#workflows-view-source.title).
+ Selecione **Adicionar ao fluxo de trabalho** para adicionar a ação ao diagrama do fluxo de trabalho e abrir seu painel de configuração.
1. Modifique as propriedades no código YAML de acordo com as suas necessidades. Uma explicação de cada propriedade disponível é fornecida em [Ação “Implantar CloudFormation pilha” YAML](deploy-action-ref-cfn.md).
1. (Opcional) Selecione **Validar** para validar o código YAML do fluxo de trabalho antes de confirmar.
1. Selecione **Confirmar**, insira uma mensagem de confirmação e escolha **Confirmar** novamente.
------
# Configurar reversões
Por padrão, se a ação **Implantar CloudFormation pilha** falhar, ela fará CloudFormation com que a pilha volte para o último estado estável conhecido. Você pode alterar o comportamento para que as reversões ocorram não apenas quando a ação falhar, mas também quando ocorrer um CloudWatch alarme específico da Amazon. Para obter mais informações sobre CloudWatch alarmes, consulte [Usando CloudWatch alarmes da Amazon no Guia CloudWatch ](https://docs.aws.amazon.com/) *do usuário da Amazon*.
Você também pode alterar o comportamento padrão para que CloudFormation não reverta a pilha quando a ação falhar.
Use as instruções a seguir para configurar reversões.
**nota**
Você não pode iniciar uma reversão manualmente.
------
#### [ Visual ]
**Antes de começar**
1. Certifique-se de ter um [fluxo de trabalho](workflow.md) que inclua uma ação funcional do **Deploy CloudFormation stack**. Para obter mais informações, consulte [Implantação de uma pilha CloudFormation](deploy-action-cfn.md).
1. Na função especificada no campo **opcional Função da pilha -** da ação **Implantar CloudFormation pilha**, certifique-se de incluir a **CloudWatchFullAccess**permissão. Para ter informações sobre como criar esse perfil com as permissões apropriadas, consulte [Etapa 2: criar AWS funções](deploy-tut-lambda.md#deploy-tut-lambda-cfn-roles).
**Para configurar alarmes de reversão para a ação “Implantar pilha” CloudFormation**
1. Abra o CodeCatalyst console em [https://codecatalyst.aws/](https://codecatalyst.aws/).
1. Selecione o projeto.
1. No painel de navegação, escolha **CI/CD** e **Fluxos de trabalho**.
1. Selecione o nome do fluxo de trabalho. É possível filtrar pelo nome do repositório ou da ramificação de origem em que o fluxo de trabalho está definido, ou filtrar pelo nome ou o status do fluxo de trabalho.
1. Escolha **Editar**.
1. Selecione **Visual**.
1. Escolha sua ação **Deploy CloudFormation stack**.
1. No painel de detalhes, selecione **Configuração**.
1. Na parte inferior, expanda **Avançado**.
1. Em **Monitorar alarme ARNs**, escolha **Adicionar alarme**.
1. Insira informações nos seguintes campos.
+ **ARN do alarme**
Especifique o Amazon Resource Name (ARN) de um CloudWatch alarme da Amazon para usar como gatilho de reversão. Por exemplo, .`arn:aws:cloudwatch::123456789012:alarm/MyAlarm` Você pode ter no máximo cinco gatilhos de reversão.
**nota**
Se você especificar um ARN de CloudWatch alarme, também precisará configurar permissões adicionais para permitir o acesso à ação. CloudWatch Para obter mais informações, consulte [Configurar reversões](#deploy-consumption-enable-alarms).
+ **Tempo de monitoramento**
Especifique um período de tempo, de 0 a 180 minutos, durante o qual CloudFormation monitora os alarmes especificados. O monitoramento começa *após* a implantação de todos os recursos da pilha. Se o alarme ocorrer dentro do tempo de monitoramento especificado, a implantação falhará e CloudFormation reverterá toda a operação da pilha.
Padrão: 0. CloudFormation monitora apenas os alarmes enquanto os recursos da pilha estão sendo implantados, não depois.
------
#### [ YAML ]
**Para configurar acionadores de reversão para a ação “Implantar pilha” CloudFormation**
1. Abra o CodeCatalyst console em [https://codecatalyst.aws/](https://codecatalyst.aws/).
1. Selecione o projeto.
1. No painel de navegação, escolha **CI/CD** e **Fluxos de trabalho**.
1. Escolha o nome de um fluxo de trabalho que inclua a ação **Implantar pilha do CloudFormation **. É possível filtrar pelo nome do repositório ou da ramificação de origem em que o fluxo de trabalho está definido, ou filtrar pelo nome ou o status do fluxo de trabalho.
1. Escolha **Editar**.
1. Selecione **YAML**.
1. Adicione as propriedades `monitor-alarm-arns` e `monitor-timeout-in-minutes` no código YAML para adicionar gatilhos de reversão. Para ver uma explicação de cada propriedade, consulte [Ação “Implantar CloudFormation pilha” YAML](deploy-action-ref-cfn.md).
1. Na função especificada na `role-arn` propriedade da ação **Deploy CloudFormation stack**, certifique-se de incluir a **CloudWatchFullAccess**permissão. Para ter informações sobre como criar esse perfil com as permissões apropriadas, consulte [Etapa 2: criar AWS funções](deploy-tut-lambda.md#deploy-tut-lambda-cfn-roles).
------
------
#### [ Visual ]
**Para desativar as reversões da ação “Implantar pilha” CloudFormation**
1. Abra o CodeCatalyst console em [https://codecatalyst.aws/](https://codecatalyst.aws/).
1. Selecione o projeto.
1. No painel de navegação, escolha **CI/CD** e **Fluxos de trabalho**.
1. Escolha o nome de um fluxo de trabalho que inclua a ação **Implantar pilha do CloudFormation **. É possível filtrar pelo nome do repositório ou da ramificação de origem em que o fluxo de trabalho está definido, ou filtrar pelo nome ou o status do fluxo de trabalho.
1. Escolha **Editar**.
1. Selecione **Visual**.
1. Escolha sua ação **Deploy CloudFormation stack**.
1. No painel de detalhes, selecione **Configuração**.
1. Na parte inferior, expanda **Avançado**.
1. Ative a opção **Desabilitar reversão**.
------
#### [ YAML ]
**Para desativar as reversões da ação “Implantar pilha” CloudFormation**
1. Abra o CodeCatalyst console em [https://codecatalyst.aws/](https://codecatalyst.aws/).
1. Selecione o projeto.
1. No painel de navegação, escolha **CI/CD** e **Fluxos de trabalho**.
1. Escolha o nome de um fluxo de trabalho que inclua a ação **Implantar pilha do CloudFormation **. É possível filtrar pelo nome do repositório ou da ramificação de origem em que o fluxo de trabalho está definido, ou filtrar pelo nome ou o status do fluxo de trabalho.
1. Escolha **Editar**.
1. Selecione **YAML**.
1. Adicione a propriedade `disable-rollback: 1` no código YAML para interromper as reversões. Para ver uma explicação dessa propriedade, consulte [Ação “Implantar CloudFormation pilha” YAML](deploy-action-ref-cfn.md).
------
# Variáveis de “ CloudFormation pilha de implantação”
A ação **Deploy CloudFormation stack** produz e define as seguintes variáveis em tempo de execução. Elas são conhecidas como *variáveis predefinidas*.
Para ter informações sobre como referenciar essas variáveis em um fluxo de trabalho, consulte [Usar variáveis predefinidas](workflows-using-predefined-variables.md).
| Chave | Valor |
| --- | --- |
| deployment-platform | O nome da plataforma de implantação. Codificado para `AWS:CloudFormation`. |
| region | O código da região em Região da AWS que foi implantado durante a execução do fluxo de trabalho. Exemplo: `us-west-2` |
| stack-id | O nome do recurso da Amazon (ARN) da pilha implantada. Exemplo: `arn:aws:cloudformation:us-west-2:111122223333:stack/codecatalyst-cfn-stack/6aad4380-100a-11ec-a10a-03b8a84d40df` |
# Ação “Implantar CloudFormation pilha” YAML
A seguir está a definição YAML da ação **Deploy CloudFormation stack**. Para saber como usar essa ação, consulte [Implantação de uma pilha CloudFormation](deploy-action-cfn.md).
Essa definição de ação existe como uma seção dentro de um arquivo de definição de fluxo de trabalho mais amplo. Para obter mais informações sobre esse arquivo, consulte [Definição do YAML do fluxo de trabalho](workflow-reference.md).
**nota**
A maioria das propriedades YAML a seguir tem elementos de interface de usuário correspondentes no editor visual. Para pesquisar um elemento de interface, use **Ctrl\$1F**. O elemento será listado com a propriedade YAML associada.
```
# The workflow definition starts here.
# See Propriedades de nível superior for details.
Name: MyWorkflow
SchemaVersion: 1.0
Actions:
# The action definition starts here.
DeployCloudFormationStack:
Identifier: aws/cfn-deploy@v1
DependsOn:
- build-action
Compute:
Type: EC2 | Lambda
Fleet: fleet-name
Timeout: timeout-minutes
Environment:
Name: environment-name
Connections:
- Name: account-connection-name
Role: DeployRole
Inputs:
Sources:
- source-name-1
Artifacts:
- CloudFormation-artifact
Configuration:
name: stack-name
region: us-west-2
template: template-path
role-arn: arn:aws:iam::123456789012:role/StackRole
capabilities: CAPABILITY_IAM,CAPABILITY_NAMED_IAM,CAPABILITY_AUTO_EXPAND
parameter-overrides: KeyOne=ValueOne,KeyTwo=ValueTwo | path-to-JSON-file
no-execute-changeset: 1|0
fail-on-empty-changeset: 1|0
disable-rollback: 1|0
termination-protection: 1|0
timeout-in-minutes: minutes
notification-arns: arn:aws:sns:us-east-1:123456789012:MyTopic,arn:aws:sns:us-east-1:123456789012:MyOtherTopic
monitor-alarm-arns: arn:aws:cloudwatch::123456789012:alarm/MyAlarm,arn:aws:cloudwatch::123456789012:alarm/MyOtherAlarm
monitor-timeout-in-minutes: minutes
tags: '[{"Key":"MyKey1","Value":"MyValue1"},{"Key":"MyKey2","Value":"MyValue2"}]'
```
## DeployCloudFormationStack
(Obrigatório)
Especifique o nome da ação. Todos os nomes de ação devem ser exclusivos no fluxo de trabalho. Os nomes de ação são limitados a caracteres alfanuméricos (a-z, A-Z, 0-9), hifens (-) e sublinhados (\$1). Não são permitidos espaços. Não é possível usar aspas para habilitar caracteres especiais e espaços nos nomes de ação.
Padrão: `DeployCloudFormationStack_nn`.
Interface de usuário correspondente: guia Configuração/**Nome de exibição da ação**
## Identifier
(*DeployCloudFormationStack*/**Identifier**)
(Obrigatório)
Identifica a ação. Não altere essa propriedade, a menos que você queira alterar a versão. Para obter mais informações, consulte [Especificação da versão da ação a ser usada](workflows-action-versions.md).
Padrão: `aws/cfn-deploy@v1`.
Interface de usuário correspondente: rótulo do diagrama de fluxo de trabalho/DeployCloudFormationStack\$1nn/**aws/cfn-deploy@v1**
## DependsOn
(*DeployCloudFormationStack*/**DependsOn**)
(Optional)
Especifique uma ação, um grupo de ação ou um portão que deve ser executado com êxito para que essa ação seja executada.
Para ter mais informações sobre a funcionalidade “Depende de”, consulte [Sequenciar ações](workflows-depends-on.md).
Interface de usuário correspondente: guia Entradas/**Depende de - opcional**
## Compute
(*DeployCloudFormationStack*/**Compute**)
(Optional)
O mecanismo de computação usado para executar as ações de fluxo de trabalho. É possível especificar a computação em nível de fluxo de trabalho ou em nível de ação, mas não em ambos. Quando especificada em nível de fluxo de trabalho, a configuração de computação se aplica a todas as ações definidas no fluxo de trabalho. Em nível de fluxo de trabalho, também é possível realizar várias ações na mesma instância. Para obter mais informações, consulte [Compartilhamento de computação entre ações](compute-sharing.md).
Interface de usuário correspondente: *nenhuma*
## Type
(*DeployCloudFormationStack*/Compute/**Type**)
(Obrigatório se [Compute](#deploy.action.cfn.computename) for incluído)
O tipo do mecanismo de computação. É possível usar um dos seguintes valores:
+ **EC2** (editor visual) ou `EC2` (editor YAML)
Otimizado para flexibilidade durante as execuções de ação.
+ **Lambda** (editor visual) ou `Lambda` (editor YAML)
Velocidades otimizadas de inicialização da ação.
Para obter informações sobre tipos de dados, consulte [Tipos de computação](workflows-working-compute.md#compute.types).
**UI correspondente: Configuração tab/Advanced - opcional/Tipo de computação**
## Fleet
(*DeployCloudFormationStack*/Compute/**Fleet**)
(Optional)
Especifique a máquina ou a frota que executará o fluxo de trabalho ou as ações de fluxo de trabalho. Com frotas sob demanda, quando uma ação é iniciada, o fluxo de trabalho provisiona os recursos necessários e as máquinas são destruídas quando a ação termina. Exemplos de frota sob demanda: `Linux.x86-64.Large`, `Linux.x86-64.XLarge`. Para ter mais informações sobre frotas sob demanda, consulte [Propriedades da frota sob demanda](workflows-working-compute.md#compute.on-demand).
Com frotas provisionadas, você configura um conjunto de máquinas dedicadas para realizar as ações do fluxo de trabalho. Essas máquinas permanecem ociosas, prontas para processar ações imediatamente. Para ter mais informações sobre frotas provisionadas, consulte [Propriedades da frota provisionada](workflows-working-compute.md#compute.provisioned-fleets).
Se `Fleet` for omitido, o padrão será `Linux.x86-64.Large`.
**UI correspondente: configuração tab/Advanced - opcional/frota de computação**
## Timeout
(*DeployCloudFormationStack*/**Timeout**)
(Optional)
Especifique a quantidade de tempo em minutos (editor YAML) ou horas e minutos (editor visual) que a ação pode ser executada antes de CodeCatalyst finalizar a ação. O mínimo é de cinco minutos e o máximo está descrito em [Cotas para fluxos de trabalho em CodeCatalyst](workflows-quotas.md). O tempo limite padrão é igual ao tempo limite máximo.
Interface de usuário correspondente: guia Configuração/**Tempo limite em minutos - opcional**
## Environment
(*DeployCloudFormationStack*/**Environment**)
(Obrigatório)
Especifique o CodeCatalyst ambiente a ser usado com a ação. A ação se conecta à Conta da AWS Amazon VPC opcional especificada no ambiente escolhido. A ação usa a função padrão do IAM especificada no ambiente para se conectar ao e usa a Conta da AWS função do IAM especificada na [conexão da Amazon VPC](https://docs.aws.amazon.com/codecatalyst/latest/adminguide/managing-vpcs.add.html) para se conectar à Amazon VPC.
**nota**
Se o perfil do IAM padrão não tiver as permissões exigidas pela ação, você poderá configurar a ação para usar um perfil diferente. Para obter mais informações, consulte [Alteração do perfil do IAM de uma ação](deploy-environments-switch-role.md).
Para ter mais informações sobre ambientes, consulte [Implantação em e Contas da AWS VPCs](deploy-environments.md) e [Criar um ambiente](deploy-environments-creating-environment.md).
Interface de usuário correspondente: guia Configuração/**Ambiente**
## Name
(*DeployCloudFormationStack*/Environment/**Name**)
(Obrigatório se [Environment](#deploy.action.cfn.environment) for incluído)
Especifique o nome de um ambiente existente que deseja associar à ação.
Interface de usuário correspondente: guia Configuração/**Ambiente**
## Connections
(*DeployCloudFormationStack*/Environment/**Connections**)
(Opcional nas versões mais recentes da ação; obrigatório nas versões mais antigas)
Especifique a conexão da conta a ser associada à ação. É possível especificar no máximo uma conexão de conta em `Environment`.
Se você não especificar uma conexão de conta:
+ A ação usa a Conta da AWS conexão e a função padrão do IAM especificadas no ambiente no CodeCatalyst console. Para ter informações sobre como adicionar uma conexão de conta e um perfil do IAM padrão ao ambiente, consulte [Criar um ambiente](deploy-environments-creating-environment.md).
+ O perfil do IAM padrão deve incluir as políticas e as permissões exigidas pela ação. Para determinar quais são essas políticas e permissões, consulte a descrição da propriedade **Perfil** na documentação de definição de YAML da ação.
Para ter mais informações sobre conexões de conta, consulte [Permitindo acesso a AWS recursos com conexão Contas da AWS](ipa-connect-account.md). Para ter informações sobre como adicionar uma conexão de conta a um ambiente, consulte [Criar um ambiente](deploy-environments-creating-environment.md).
Interface de usuário correspondente: uma das seguintes, dependendo da versão da ação:
+ (Versões mais recentes) A configuração tab/Environment/What está pronta? *my-environment* **/menu de três pontos/ Mudar função**
+ **(Versões mais antigas) Guia de configuração/' Environment/account/role AWS '/ conexão de conta**
## Name
(*DeployCloudFormationStack*/Environment/Connections/**Name**)
(Obrigatório se [Connections](#deploy.action.cfn.environment.connections) for incluído)
Especifique o nome da conexão da conta.
Interface de usuário correspondente: uma das seguintes, dependendo da versão da ação:
+ (Versões mais recentes) A configuração tab/Environment/What está pronta? *my-environment* **/menu de três pontos/ Mudar função**
+ **(Versões mais antigas) Guia de configuração/' Environment/account/role AWS '/ conexão de conta**
## Role
(*DeployCloudFormationStack*/Environment/Connections/**Role**)
(Obrigatório se [Connections](#deploy.action.cfn.environment.connections) for incluído)
Especifique o nome da função do IAM que a ação **Deploy CloudFormation stack** usa para acessar AWS e o CloudFormation serviço. Certifique-se de ter [adicionado a função ao seu CodeCatalyst espaço](ipa-connect-account-addroles.md) e de que a função inclua as seguintes políticas.
Se você não especificar uma função do IAM, a ação usará a função padrão do IAM listada no [ambiente](deploy-environments.md) no CodeCatalyst console. Se você usar o perfil padrão no ambiente, verifique se ele tem as políticas a seguir.
+ A política de permissões a seguir:
**Atenção**
Limite as permissões às exibidas na política a seguir. Usar um perfil com permissões mais amplas pode representar um risco de segurança.
**nota**
Na primeira vez em que o perfil for usado, use o caractere curinga a seguir na declaração de política de recursos e defina o escopo da política com o nome do recurso depois que ele estiver disponível.
```
"Resource": "*"
```
+ A política de confiança personalizada a seguir:
**nota**
Você pode usar o perfil `CodeCatalystWorkflowDevelopmentRole-spaceName` com essa ação, se desejar. Para obter mais informações sobre esse perfil, consulte [Criar o perfil **CodeCatalystWorkflowDevelopmentRole-*spaceName*** para a conta e o espaço](ipa-iam-roles.md#ipa-iam-roles-service-create). Entenda que o perfil `CodeCatalystWorkflowDevelopmentRole-spaceName` tem permissões de acesso completas, o que pode representar um risco de segurança. Recomendamos que você use esse perfil apenas em tutoriais e em cenários em que a segurança seja menos preocupante.
Interface de usuário correspondente: uma das seguintes, dependendo da versão da ação:
+ (Versões mais recentes) A configuração tab/Environment/What está pronta? *my-environment* **/menu de três pontos/ Mudar função**
+ **(Versões mais antigas) Guia de configuração/' '/ Função Environment/account/role**
## Inputs
(*DeployCloudFormationStack*/**Inputs**)
(Optional)
A seção `Inputs` define os dados que `DeployCloudFormationStack` precisa durante a execução de um fluxo de trabalho.
**nota**
São permitidas no máximo quatro entradas (uma fonte e três artefatos) por ação de **implantação da CloudFormation pilha**.
Se você precisar consultar arquivos que residem em entradas diferentes (digamos, uma origem e um artefato), a entrada de origem será a entrada primária e o artefato será a entrada secundária. As referências a arquivos em entradas secundárias usam um prefixo especial para diferirem das primárias. Para obter detalhes, consulte [Exemplo: referência de arquivos em vários artefatos](workflows-working-artifacts-ex.md#workflows-working-artifacts-ex-ref-file).
Interface de usuário correspondente: guia **Entradas**
## Sources
(*DeployCloudFormationStack*/Inputs/**Sources**)
(Obrigatório se o seu AWS SAM modelo CloudFormation ou modelo estiver armazenado em um repositório de origem)
Se seu AWS SAM modelo CloudFormation ou modelo estiver armazenado em um repositório de origem, especifique o rótulo desse repositório de origem. Atualmente, o único rótulo compatível é `WorkflowSource`.
Se o seu AWS SAM modelo CloudFormation ou modelo não estiver contido em um repositório de origem, ele deverá residir em um artefato gerado por outra ação ou em um bucket do Amazon S3.
Para obter mais informações sobre fontes, consulte [Conectar repositórios de origem aos fluxos de trabalho](workflows-sources.md).
Interface de usuário correspondente: guia Entradas/**Origens - opcional**
## Artifacts - input
(*DeployCloudFormationStack*/Inputs/**Artifacts**)
(Obrigatório se seu AWS SAM modelo CloudFormation ou modelo estiver armazenado em um [artefato de saída](workflows-working-artifacts-output.md) de uma ação anterior)
Se o AWS SAM modelo CloudFormation ou que você deseja implantar estiver contido em um artefato gerado por uma ação anterior, especifique esse artefato aqui. Se seu CloudFormation modelo não estiver contido em um artefato, ele deverá residir no seu repositório de origem ou em um bucket do Amazon S3.
Para ter mais informações sobre artefatos, inclusive exemplos, consulte [Compartilhar artefatos e arquivos entre ações](workflows-working-artifacts.md).
Interface de usuário correspondente: guia Configuração/**Artefatos - opcional**
## Configuration
(*DeployCloudFormationStack*/**Configuration**)
(Obrigatório)
Uma seção na qual você pode definir as propriedades de configuração da ação.
Interface de usuário correspondente: guia **Configuração**
## name
(*DeployCloudFormationStack*/Configuration/**name**)
(Obrigatório)
Especifique um nome para a CloudFormation pilha que a ação **Deploy CloudFormation stack** cria ou atualiza.
Interface de usuário correspondente: guia Configuração/**Nome da pilha**
## region
(*DeployCloudFormationStack*/Configuration/**region**)
(Obrigatório)
Especifique o Região da AWS local no qual a pilha será implantada. Para obter uma lista dos códigos das regiões, consulte [Endpoints regionais](https://docs.aws.amazon.com/general/latest/gr/rande.html#region-names-codes).
Interface de usuário correspondente: guia Configuração/**Região da pilha**
## template
(*DeployCloudFormationStack*/Configuration/**template**)
(Obrigatório)
Especifique o nome e o caminho para seu arquivo CloudFormation ou arquivo AWS SAM de modelo. O modelo pode estar no formato JSON ou YAML e pode residir em um repositório de origem, em um artefato de uma ação anterior ou em um bucket do Amazon S3. Se o arquivo de modelo estiver em um repositório ou artefato de origem, o caminho será relativo à origem ou à raiz do artefato. Se o modelo estiver em um bucket do Amazon S3, o caminho será o valor do **URL do objeto** do modelo.
Exemplos:
`./MyFolder/MyTemplate.json`
`MyFolder/MyTemplate.yml`
`https://MyBucket.s3.us-west-2.amazonaws.com/MyTemplate.yml`
**nota**
Talvez seja necessário adicionar um prefixo ao caminho do arquivo do modelo para indicar em qual artefato ou origem encontrá-lo. Para obter mais informações, consulte [Fazer referência a arquivos do repositório de origem](workflows-sources-reference-files.md) e [Referência de arquivos em um artefato](workflows-working-artifacts-refer-files.md).
Interface de usuário correspondente: guia Configuração/**Modelo**
## role-arn
(*DeployCloudFormationStack*/Configuration/**role-arn**)
(Obrigatório)
Especifique o Amazon Resource Name (ARN) da função da pilha. CloudFormation usa essa função para acessar e modificar recursos em sua pilha. Por exemplo: `arn:aws:iam::123456789012:role/StackRole`.
O perfil da pilha deve incluir:
+ Uma ou mais políticas de permissões. As políticas dependem dos recursos que você tem na pilha. Por exemplo, se sua pilha inclui uma AWS Lambda função, você precisa adicionar permissões que concedam acesso ao Lambda. Se você seguiu o tutorial descrito em [Tutorial: Implantar uma aplicação sem servidor](deploy-tut-lambda.md), ele inclui um procedimento intitulado [Para criar um perfil de pilha](deploy-tut-lambda.md#deploy-tut-lambda-cfn-roles-stack) que lista as permissões que o perfil de pilha precisa se você estiver implantando uma pilha típica de aplicações sem servidor.
**Atenção**
Limite as permissões às exigidas pelo CloudFormation serviço para acessar os recursos em sua pilha. Usar um perfil com permissões mais amplas pode representar um risco de segurança.
+ A seguinte política de confiança:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "cloudformation.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Se desejar, associe esse perfil à conexão da sua conta. Para saber mais sobre como associar um perfil do IAM a uma conexão de conta, consulte [Adicionar perfis do IAM às conexões da conta](ipa-connect-account-addroles.md). Se você não associar o perfil da pilha à conexão da conta, ele não aparecerá na lista suspensa **Perfil da pilha** no editor visual. No entanto, o ARN do perfil ainda poderá ser especificado no campo `role-arn` usando o editor YAML.
**nota**
Você pode usar o perfil `CodeCatalystWorkflowDevelopmentRole-spaceName` com essa ação, se desejar. Para obter mais informações sobre esse perfil, consulte [Criar o perfil **CodeCatalystWorkflowDevelopmentRole-*spaceName*** para a conta e o espaço](ipa-iam-roles.md#ipa-iam-roles-service-create). Entenda que o perfil `CodeCatalystWorkflowDevelopmentRole-spaceName` tem permissões de acesso completas, o que pode representar um risco de segurança. Recomendamos que você use esse perfil apenas em tutoriais e em cenários em que a segurança seja menos preocupante.
Interface de usuário correspondente: guia Configuração/**Perfil da pilha - opcional**
## capabilities
(*DeployCloudFormationStack*/Configuration/**capabilities**)
(Obrigatório)
Especifique uma lista dos recursos do IAM necessários para permitir CloudFormation a criação de determinadas pilhas. Na maioria dos casos, você pode sair de `capabilities` com o valor padrão de `CAPABILITY_IAM,CAPABILITY_NAMED_IAM,CAPABILITY_AUTO_EXPAND`.
Se você vir `##[error] requires capabilities: [capability-name]` nos logs da ação **Implantar pilha do CloudFormation **, consulte [Como faço para corrigir erros de recursos do IAM?](troubleshooting-workflows.md#troubleshooting-workflows-capabilities) para ter informações sobre como corrigir o problema.
Para obter mais informações sobre os recursos do IAM, consulte Como [reconhecer recursos do IAM em CloudFormation modelos](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-iam-template.html#using-iam-capabilities) no *Guia do usuário do IAM*.
Interface de usuário correspondente: guia Configuração/Avançada/**Recursos**
## parameter-overrides
(*DeployCloudFormationStack*/Configuration/**parameter-overrides**)
(Optional)
Especifique parâmetros no seu CloudFormation ou no AWS SAM modelo que não tenham valores padrão ou para os quais você deseja especificar valores não padrão. Para obter mais informações sobre parâmetros, consulte [Parâmetros](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/parameters-section-structure.html) no *Guia AWS CloudFormation do usuário*.
A propriedade `parameter-overrides` aceita:
+ Um arquivo JSON contendo os parâmetros e valores.
+ Uma lista separada por vírgulas de parâmetros e valores.
**Para especificar um arquivo JSON**
1. Verifique se o arquivo JSON usa uma das seguintes sintaxes:
```
{
"Parameters": {
"Param1": "Value1",
"Param2": "Value2",
...
}
}
```
Ou...
```
[
{
"ParameterKey": "Param1",
"ParameterValue": "Value1"
},
...
]
```
(Existem outras sintaxes, mas elas não são suportadas CodeCatalyst no momento em que este artigo foi escrito.) *Para obter mais informações sobre a especificação de CloudFormation parâmetros em um arquivo JSON, consulte [Sintaxe JSON compatível](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/cloudformation/deploy/index.html#supported-json-syntax) na Referência de Comandos.AWS CLI *
1. Especifique o caminho para o arquivo JSON usando um dos seguinte formatos:
+ Se o arquivo JSON residir em um artefato de saída de uma ação anterior, use:
`file:///artifacts/current-action-name/output-artifact-name/path-to-json-file`
Consulte o **Exemplo 1** para saber detalhes.
+ Se o arquivo JSON residir no seu repositório de origem, use:
`file:///sources/WorkflowSource/path-to-json-file`
Consulte o **Exemplo 2** para saber detalhes.
**Exemplo 1**: o arquivo JSON reside em um artefato de saída
```
##My workflow YAML
...
Actions:
MyBuildAction:
Identifier: aws/build@v1
Outputs:
Artifacts:
- Name: ParamArtifact
Files:
- params.json
Configuration:
...
MyDeployCFNStackAction:
Identifier: aws/cfn-deploy@v1
Configuration:
parameter-overrides: file:///artifacts/MyDeployCFNStackAction/ParamArtifact/params.json
```
**Exemplo 2**: o arquivo JSON reside no repositório de origem, em uma pasta chamada `my/folder`
```
##My workflow YAML
...
Actions:
MyDeployCloudFormationStack:
Identifier: aws/cfn-deploy@v1
Inputs:
Sources:
- WorkflowSource
Configuration:
parameter-overrides: file:///sources/WorkflowSource/my/folder/params.json
```
**Como usar uma lista de parâmetros separada por vírgula**
+ Adicione pares de nome-valor do parâmetro na propriedade `parameter-overrides` usando o seguinte formato:
`param-1=value-1,param-2=value-2`
Por exemplo, assumindo o seguinte CloudFormation modelo:
```
##My CloudFormation template
Description: My CloudFormation template
Parameters:
InstanceType:
Description: Defines the Amazon EC2 compute for the production server.
Type: String
Default: t2.micro
AllowedValues:
- t2.micro
- t2.small
- t3.medium
Resources:
...
```
... você pode definir a propriedade `parameter-overrides` da seguinte forma:
```
##My workflow YAML
...
Actions:
...
DeployCloudFormationStack:
Identifier: aws/cfn-deploy@v1
Configuration:
parameter-overrides: InstanceType=t3.medium,UseVPC=true
```
**nota**
Você pode especificar um nome de parâmetro sem um valor correspondente usando `undefined` como valor. Por exemplo:
`parameter-overrides: MyParameter=undefined`
O efeito é que, durante uma atualização da pilha, CloudFormation usa o valor do parâmetro existente para o nome do parâmetro fornecido.
Interface de usuário correspondente:
+ Guia Configuração/Avançado/**Substituições de parâmetros**
+ tab/Advanced/ParameterSubstituições de configuração/ **Especifique substituições usando** um arquivo
+ tab/Advanced/ParameterSubstituições de configuração/ **Especifique substituições usando um conjunto de valores**
## no-execute-changeset
(*DeployCloudFormationStack*/Configuration/**no-execute-changeset**)
(Optional)
Especifique se você CodeCatalyst deseja criar o conjunto de CloudFormation alterações e depois parar antes de executá-lo. Isso lhe dá a oportunidade de revisar o conjunto de alterações no CloudFormation console. Se você determinar que o conjunto de alterações parece bom, desative essa opção e execute novamente o fluxo de trabalho para que ele CodeCatalyst possa criar e executar o conjunto de alterações sem parar. O padrão é criar e executar o conjunto de alterações sem parar. Para obter mais informações, consulte o parâmetro CloudFormation [deploy](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deploy/index.html) na *Referência de AWS CLI Comandos*. Para ter mais informações sobre a visualização de conjuntos de alterações, consulte [Visualização de um conjunto de alterações](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-changesets-view.html) no *Guia do usuário do AWS CloudFormation *.
Interface de usuário correspondente: guia Configuração/Avançado/**Sem executar o conjunto de alterações**
## fail-on-empty-changeset
(*DeployCloudFormationStack*/Configuration/**fail-on-empty-changeset**)
(Optional)
Especifique se você deseja CodeCatalyst falhar na ação **Deploy CloudFormation stack** se o conjunto de CloudFormation alterações estiver vazio. (Se um conjunto de alterações estiver vazio, isso significa que não foram feitas alterações na pilha durante a implantação mais recente.) O padrão é permitir que a ação continue se o conjunto de alterações estiver vazio e retornar uma mensagem `UPDATE_COMPLETE` mesmo que a pilha não tenha sido atualizada.
Para obter mais informações sobre essa configuração, consulte o parâmetro CloudFormation [deploy](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deploy/index.html) na *Referência de AWS CLI Comandos*. Para ter mais informações sobre conjuntos de alterações, consulte [Atualizar pilhas usando conjuntos de alterações](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-changesets.html) no *Manual do usuário do AWS CloudFormation *.
Interface de usuário correspondente: guia Configuração/Avançado/**Falha no conjunto de alterações vazio**
## disable-rollback
(*DeployCloudFormationStack*/Configuration/**disable-rollback**)
(Optional)
Especifique se você CodeCatalyst deseja reverter a implantação da pilha se ela falhar. A reversão retorna a pilha ao último estado estável conhecido. O padrão é habilitar reversões. Para obter mais informações sobre essa configuração, consulte o parâmetro CloudFormation [deploy](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/deploy/index.html) na *Referência de AWS CLI Comandos*.
Para obter mais informações sobre como a ação **Deploy CloudFormation stack** lida com reversões, consulte. [Configurar reversões](deploy-consumption-enable-alarms.md)
Para ter mais informações sobre como reverter uma pilha, consulte [Opções de falha de pilha](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/stack-failure-options.html) no *Guia do usuário do AWS CloudFormation *.
Interface de usuário correspondente: guia Configuração/Avançado/**Desativar reversão**
## termination-protection
(*DeployCloudFormationStack*/Configuration/**termination-protection**)
(Optional)
Especifique se você deseja que a ** CloudFormation pilha Deploy** adicione proteção de encerramento à pilha que está implantando. 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. O padrão é desativar a proteção contra encerramento. Para ter mais informações, consulte [Proteção de uma pilha contra exclusão](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-protect-stacks.html) no *Guia do usuário do AWS CloudFormation *.
Interface de usuário correspondente: guia Configuração/Avançado/**Proteção contra encerramento**
## timeout-in-minutes
(*DeployCloudFormationStack*/Configuration/**timeout-in-minutes**)
(Optional)
Especifique a quantidade de tempo, em minutos, que CloudFormation deve ser alocada antes de expirar as operações de criação da pilha e definir o status da pilha como. `CREATE_FAILED` Se o CloudFormation não puder criar a pilha inteira dentro do tempo alocado, além de não ser criada, a pilha será revertida.
Por padrão, não há tempo limite para criação da pilha. No entanto, recursos individuais podem ter seus próprios limites de tempo com base na natureza do serviço que implementam. Por exemplo, se um recurso individual em sua pilha expirar, a criação dela também expirará, ainda que o tempo limite especificado para a criação não tenha sido atingido.
**UI correspondente: guia de configuração/avançado/tempo limite CloudFormation**
## notification-arns
(*DeployCloudFormationStack*/Configuration/**notification-arns**)
(Optional)
Especifique o ARN de um tópico do Amazon SNS para o qual você CodeCatalyst deseja enviar mensagens de notificação. Por exemplo, .`arn:aws:sns:us-east-1:111222333:MyTopic` Quando a ação **Deploy CloudFormation stack** é executada, CodeCatalyst CloudFormation coordena-se para enviar uma notificação por CloudFormation evento que ocorre durante o processo de criação ou atualização da pilha. (Os eventos são visíveis na guia **Eventos** do CloudFormation console para a pilha.) Você pode definir até cinco tópicos. Para ter mais informações, consulte [O que é a Amazon SNS?](https://docs.aws.amazon.com/sns/latest/dg/welcome.html)
**UI correspondente: guia Configuração/Avançado/Notificação ARNs**
## monitor-alarm-arns
(*DeployCloudFormationStack*/Configuration/**monitor-alarm-arns**)
(Optional)
Especifique o Amazon Resource Name (ARN) de um CloudWatch alarme da Amazon para usar como gatilho de reversão. Por exemplo, .`arn:aws:cloudwatch::123456789012:alarm/MyAlarm` Você pode ter no máximo cinco gatilhos de reversão.
**nota**
Se você especificar um ARN de CloudWatch alarme, também precisará configurar permissões adicionais para permitir o acesso à ação. CloudWatch Para obter mais informações, consulte [Configurar reversões](deploy-consumption-enable-alarms.md).
**UI correspondente: guia de configuração/avançado/alarme de monitor ARNs**
## monitor-timeout-in-minutes
(*DeployCloudFormationStack*/Configuration/**monitor-timeout-in-minutes**)
(Optional)
Especifique um período de tempo, de 0 a 180 minutos, durante o qual CloudFormation monitora os alarmes especificados. O monitoramento começa *após* a implantação de todos os recursos da pilha. Se o alarme ocorrer dentro do tempo de monitoramento especificado, a implantação falhará e CloudFormation reverterá toda a operação da pilha.
Padrão: 0. CloudFormation monitora apenas os alarmes enquanto os recursos da pilha estão sendo implantados, não depois.
Interface de usuário correspondente: guia Configuração/Avançado/**Tempo de monitoramento**
## tags
(*DeployCloudFormationStack*/Configuration/**tags**)
(Optional)
Especifique as tags para anexar à sua CloudFormation pilha. As tags são pares de chave/valor arbitrários que você pode usar para identificar sua pilha em relação à finalidade, como alocação de custos. Para obter mais informações sobre o que as tags são e como elas podem ser usadas, consulte [Marcar recursos](https://docs.aws.amazon.com/) no *Guia do usuário do Amazon EC2*. Para obter mais informações sobre como marcar CloudFormation, consulte [Configuração das opções de CloudFormation pilha](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-add-tags.html) no Guia do *AWS CloudFormation usuário*.
Uma chave pode ter caracteres alfanuméricos ou espaços e pode ter até 127 caracteres. Um valor pode ter caracteres alfanuméricos ou espaços e pode ter até 255 caracteres.
É possível adicionar até 50 tags exclusivas para cada pilha.
Interface de usuário correspondente: guia Configuração/Avançado/**Tags**