Tutorial: Implantar uma aplicação sem servidor - Amazon CodeCatalyst
Pré-requisitosEtapa 1: criar um repositório de origemEtapa 2: criar perfis do AWSEtapa 3: adicionar perfis da AWS ao CodeCatalystEtapa 4: criar um bucket do Amazon S3Etapa 5: adicionar arquivos de origemEtapa 6: criar e executar um fluxo de trabalhoEtapa 7: fazer uma alteraçãoLimpeza

Tutorial: Implantar uma aplicação sem servidor

Neste tutorial, você aprende a criar, testar e implantar uma aplicação sem servidor como uma pilha do CloudFormation usando um fluxo de trabalho.

A aplicação neste tutorial é uma aplicação web simples que gera uma mensagem “Hello World”. Ela consiste em uma função do AWS Lambda e um Amazon API Gateway, e você a cria usando o AWS Serverless Application Model (AWS SAM), que é uma extensão do AWS CloudFormation.

Pré-requisitos

Antes de começar

  • Você precisa de um espaço do CodeCatalyst com uma conta da AWS conectada. Para ter mais informações, consulte Criar um espaço.

  • 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 ter mais informações, consulte Criação de um projeto vazio no Amazon CodeCatalyst.

  • Em seu projeto, você precisa de um ambiente do CodeCatalyst chamado:

    codecatalyst-cfn-environment

    Configure esse ambiente da seguinte forma:

    • Escolha qualquer tipo, como Não produção.

    • Conecte sua conta da AWS a ele.

    • Para o Perfil do IAM padrão, escolha qualquer perfil. Você especificará um perfil diferente posteriormente.

    Para ter mais informações, consulte Implantação em Contas da AWS e VPCs.

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.

Como criar um repositório de origem

  1. No CodeCatalyst, selecione Código e, depois, selecione Repositórios de origem.

  2. Escolha Adicionar repositório e selecione Criar repositório.

  3. Em Nome do repositório, insira:

    codecatalyst-cfn-source-repository

  4. Escolha Criar.

Agora você criou um repositório chamado codecatalyst-cfn-source-repository.

Etapa 2: criar perfis do AWS

Nesta etapa, você cria os seguintes perfis do AWS IAM:

  • Perfil de implantação: concede à ação Implantar pilha do AWS CloudFormation do CodeCatalyst permissão para acessar a conta da AWS e o serviço CloudFormation, onde você implantará a aplicação sem servidor. A ação Implantar pilha do AWS CloudFormation faz parte do seu fluxo de trabalho.

  • Perfil de criação — Concede à ação de criação do CodeCatalyst permissão para acessar sua conta da AWS e gravar no Amazon S3, onde seu pacote de aplicações sem servidor será armazenado. A ação de criação faz parte do seu fluxo de trabalho.

  • Perfil da pilha — Concede permissão ao CloudFormation para ler e modificar os recursos especificados no modelo do AWS SAM que você fornecerá posteriormente. Também concede permissão ao CloudWatch.

Para ter informações sobre perfis do IAM, consulte Perfis do IAM 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 ter mais informações, consulte Criar o perfil CodeCatalystWorkflowDevelopmentRole-spaceName para a conta e o espaço. 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 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 no AWS.

    2. Abra o console do IAM em https://console.aws.amazon.com/iam/.

    3. No painel de navegação, escolha Policies.

    4. Escolha Criar política.

    5. Escolha a guia JSON.

    6. Exclua o código existente.

    7. Cole o seguinte código:

      {
    "Version": "2012-10-17",
    "Statement": [{
    "Action": [
        "cloudformation:CreateStack",
        "cloudformation:DeleteStack",
        "cloudformation:Describe*",
        "cloudformation:UpdateStack",
        "cloudformation:CreateChangeSet",
        "cloudformation:DeleteChangeSet",
        "cloudformation:ExecuteChangeSet",
        "cloudformation:SetStackPolicy",
        "cloudformation:ValidateTemplate",
        "cloudformation:List*",
        "iam:PassRole"
    ],
    "Resource": "*",
    "Effect": "Allow"
}]
}
      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": "*"

    8. Escolha Próximo: etiquetas.

    9. Selecione Next: Review (Próximo: revisar).

    10. Em Nome, insira:

      codecatalyst-deploy-policy

    11. Escolha Criar política.

      Agora você criou uma política de permissões.

  2. Crie o perfil de implantação, da seguinte forma:

    1. No painel de navegação, escolha Perfis e Criar perfil.

    2. Selecione Política de confiança personalizada.

    3. Exclua a política de confiança personalizada existente.

    4. Adicione a política de confiança personalizada a seguir:

      {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "",
            "Effect": "Allow",
            "Principal": {
                "Service":  [
                   "codecatalyst-runner.amazonaws.com",
                   "codecatalyst.amazonaws.com"
                 ]
            },
            "Action": "sts:AssumeRole"
        }
    ]
}

    5. Escolha Próximo.

    6. Em Políticas de permissões, procure codecatalyst-deploy-policy e marque a caixa de seleção.

    7. Escolha Próximo.

    8. Em Nome do perfil, insira:

      codecatalyst-deploy-role

    9. Em Descrição do perfil, insira:

      CodeCatalyst deploy role

    10. Selecione Criar função.

    Agora você criou um perfil de implantação com uma política de confiança e uma política de permissões.

  3. Obtenha o ARN do perfil de implantação, da seguinte forma:

    1. No painel de navegação, escolha Perfis.

    2. Na caixa de pesquisa, insira o nome do perfil que você acabou de criar (codecatalyst-deploy-role).

    3. Escolha o perfil na lista.

      A página Resumo do perfil é exibida.

    4. 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 no AWS.

    2. Abra o console do IAM em https://console.aws.amazon.com/iam/.

    3. No painel de navegação, escolha Policies.

    4. Escolha Criar política.

    5. Escolha a guia JSON.

    6. Exclua o código existente.

    7. Cole o seguinte código:

      {
    "Version": "2012-10-17",
    "Statement": [{
    "Action": [
        "s3:PutObject",
        "iam:PassRole"
    ],
    "Resource": "*",
    "Effect": "Allow"
}]
}
      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": "*"

    8. Escolha Próximo: etiquetas.

    9. Selecione Next: Review (Próximo: revisar).

    10. Em Nome, insira:

      codecatalyst-build-policy

    11. Escolha Criar política.

      Agora você criou uma política de permissões.

  2. Crie o perfil de criação, da seguinte forma:

    1. No painel de navegação, escolha Perfis e Criar perfil.

    2. Selecione Política de confiança personalizada.

    3. Exclua a política de confiança personalizada existente.

    4. Adicione a política de confiança personalizada a seguir:

      {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "",
            "Effect": "Allow",
            "Principal": {
                "Service":  [
                   "codecatalyst-runner.amazonaws.com",
                   "codecatalyst.amazonaws.com"
                 ]
            },
            "Action": "sts:AssumeRole"
        }
    ]
}

    5. Escolha Próximo.

    6. Em Políticas de permissões, procure codecatalyst-build-policy e marque a caixa de seleção.

    7. Escolha Próximo.

    8. Em Nome do perfil, insira:

      codecatalyst-build-role

    9. Em Descrição do perfil, insira:

      CodeCatalyst build role

    10. Selecione Criar função.

    Agora você criou um perfil de criação com uma política de confiança e uma política de permissões.

  3. Obtenha o ARN do perfil de criação, da seguinte forma:

    1. No painel de navegação, escolha Perfis.

    2. Na caixa de pesquisa, insira o nome do perfil que você acabou de criar (codecatalyst-build-role).

    3. Escolha o perfil na lista.

      A página Resumo do perfil é exibida.

    4. 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. Entre na AWS usando a conta em que você deseja implantar a pilha.

  2. Abra o console do IAM em https://console.aws.amazon.com/iam/.

  3. Crie o perfil de pilha, da seguinte forma:

    1. No painel de navegação, escolha Roles.

    2. Escolha Criar Perfil.

    3. Selecione Serviço da AWS.

    4. Na seção Caso de uso, escolha CloudFormation na lista suspensa.

    5. Selecione o botão de opção CloudFormation.

    6. Selecione Avançar na parte inferior.

    7. 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

      • AWSCloudFormationFullAccess

      • IAMFullAccess

      • AWSLambda_FullAccess

      • AmazonAPIGatewayAdministrator

      • AmazonS3FullAccess

      • AmazonEC2ContainerRegistryFullAccess

      A primeira política concede acesso ao CloudWatch para permitir reversões de pilha quando ocorre um alarme.

      As políticas restantes permitem que o AWS SAM acesse os serviços e recursos na pilha que serão implantados neste tutorial. Para ter mais informações, consulte Permissões no Guia do desenvolvedor do AWS Serverless Application Model.

    8. Escolha Próximo.

    9. Em Nome do perfil, insira:

      codecatalyst-stack-role

    10. Selecione Criar função.

  4. Obtenha o ARN do perfil de pilha, da seguinte forma:

    1. No painel de navegação, escolha Perfis.

    2. Na caixa de pesquisa, insira o nome do perfil que você acabou de criar (codecatalyst-stack-role).

    3. Escolha o perfil na lista.

    4. 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 perfis da AWS ao CodeCatalyst

Nesta etapa, você adiciona o perfil de criação (codecatalyst-build-role) e o perfil de implantação (codecatalyst-deploy-role) à conexão da conta do CodeCatalyst em seu espaço.

nota

Não é necessário adicionar o perfil de pilha (codecatalyst-stack-role) à conexão. Isso ocorre porque o perfil de pilha é usado pelo CloudFormation (não pelo CodeCatalyst) depois que uma conexão já foi estabelecida entre o CodeCatalyst e a AWS usando o perfil de implantação. Como o perfil de pilha não é usado pelo CodeCatalyst para acessar a AWS, ele não precisa ser associado a uma conexão de conta.

Para adicionar perfis de criação e implantação à conexão da sua conta

  1. Navegue até o seu espaço no CodeCatalyst.

  2. Selecione Contas da AWS. Uma lista de conexões de conta é exibida.

  3. Escolha a conexão de conta que representa a conta da AWS em que você criou os perfis de criação e implantação.

  4. Selecione Gerenciar perfis no console de gerenciamento da AWS.

    A página Adicionar perfil do IAM ao espaço do Amazon CodeCatalyst é exibida. Talvez seja necessário fazer login para acessá-la.

  5. 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.

  6. Na lista suspensa, selecione codecatalyst-build-role e Adicionar perfil.

  7. 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.

  8. Copie o valor do Nome de exibição do Amazon CodeCatalyst. 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.

Para criar um bucket do Amazon S3

  1. Abra o console do Amazon S3 em https://console.aws.amazon.com/s3/.

  2. No painel principal, selecione Criar bucket.

  3. Em Nome do bucket, insira:

    codecatalyst-cfn-s3-bucket

  4. Em AWS Region (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 na Referência geral da AWS.

  5. 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 da aplicação ao seu repositório de origem do CodeCatalyst. 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 console do CodeCatalyst em https://codecatalyst.aws/.

  2. Selecione o projeto, codecatalyst-cfn-project

  3. No painel de navegação, selecione Código e, depois, selecione Repositórios de origem.

  4. Na lista de repositórios de origem, escolha o seu repositório, codecatalyst-cfn-source-repository.

  5. Em Arquivos, selecione Criar arquivo.

  6. Em Nome do arquivo, insira:

    .npmignore

  7. Na caixa de texto, insira o código a seguir:

    tests/*

  8. 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, 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), o script de teste gera um relatório de cobertura de código (clover.xml) usando o repórter clover. Para ter mais informações, consulte Uso de repórteres alternativos na documentação do Istambul.

Como adicionar o arquivo package.json

  1. No repositório, em Arquivos, selecione Criar arquivo.

  2. Em Nome do arquivo, insira:

    package.json

  3. 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"
  }
}

  4. 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 modelo do AWS Serverless Application Model, que estende a especificação do modelo do AWS CloudFormation.

Você usa um modelo do AWS SAM neste tutorial em vez de um modelo do AWS CloudFormation normal porque o AWS SAM oferece um tipo de recurso AWS::Serverless::Function útil. Esse tipo executa muitas configurações secundárias que você normalmente precisa escrever para usar a sintaxe básica do CloudFormation. 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 escrever usando o CloudFormation básico.

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 ter mais informações, consulte Implantação de uma pilha do AWS CloudFormation.

Para adicionar o arquivo sam-template.yml

  1. No repositório, em Arquivos, selecione Criar arquivo.

  2. Em Nome do arquivo, insira:

    sam-template.yml

  3. 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

  4. 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 arquivo setup-sam.sh contém as instruções para baixar e instalar o utilitário AWS SAM da 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.

  2. Em Nome do arquivo, insira:

    setup-sam.sh

  3. 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, substitua us-west-2 pela sua região da AWS.

  4. 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.

  2. Em Nome do arquivo, insira:

    hello-world/app.js

  3. 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
};

  4. 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.

  2. Em Nome do arquivo, insira:

    hello-world/tests/unit/test-handler.js

  3. 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");
    });
});

  4. 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.

  • Uma ação de teste (Test) — No gatilho, essa ação instala o gerenciador de pacotes Node (npm) 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 ter mais informações, consulte Arquivo package.json.

    Em seguida, a ação de teste transforma os relatórios XML em relatórios do CodeCatalyst e os exibe no console do CodeCatalyst, 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 trabalho.

  • Uma ação de criação (BuildBackend): ao concluir a ação de teste, a ação de criação baixa e instala a CLI do AWS SAM, empacota a origem de hello-world 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 modelo do AWS SAM 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.

  • 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 criação (buildArtifact), encontra o AWS SAM dentro dele e executa o modelo. O modelo do AWS SAM cria uma pilha que implanta a aplicação sem servidor.

Como criar um fluxo de trabalho

  1. No painel de navegação, escolha CI/CD e Fluxos de trabalho.

  2. Selecione Criar fluxo de trabalho.

  3. Em Repositório de origem, selecione codecatalyst-cfn-source-repository.

  4. Em Ramificação, selecione main.

  5. Escolha Criar.

  6. Exclua o código de amostra YAML.

  7. 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 perfis do AWS. Para ter mais informações sobre como configurar um ambiente com um perfil do IAM padrão, consulte Criar um ambiente.

    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:

    • As duas instâncias de codecatalyst-cfn-environment pelo nome do seu ambiente.

    • As duas instâncias da codecatalyst-account-connection pelo nome de exibição da conexão da sua conta. O nome de exibição pode ser um número. Para ter mais informações, consulte Etapa 3: adicionar perfis da AWS ao CodeCatalyst.

    • codecatalyst-build-role pelo nome do perfil de criação criado em Etapa 2: criar perfis do AWS.

    • codecatalyst-cfn-s3-bucket pelo nome do bucket do Amazon S3 que você criou em Etapa 4: criar um bucket do Amazon S3.

    • As duas instâncias de us-west-2 pela 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 ter detalhes sobre regiões compatíveis com o Amazon S3 e o AWS CloudFormation, consulte Endpoints e cotas de serviço na Referência geral da AWS.

    • codecatalyst-deploy-role pelo nome do perfil de implantação criado em Etapa 2: criar perfis do AWS.

    • codecatalyst-cfn-environment pelo nome do ambiente que você criou em Pré-requisitos.

    • arn:aws:iam::111122223333:role/StackRole pelo nome do recurso da Amazon (ARN) do perfil de pilha que você criou em Etapa 2: criar perfis do AWS.

      nota

      Se você decidiu não criar, implantar e empilhar funções, substitua codecatalyst-build-role, codecatalyst-deploy-role e arn:aws:iam::111122223333:role/StackRole pelo nome ou ARN do perfil CodeCatalystWorkflowDevelopmentRole-spaceName. Para obter mais informações sobre essa função, consulte Etapa 2: criar perfis do AWS.

    Para ter informações sobre as propriedades no código mostrado anteriormente, consulte a YAML da ação “Implantar pilha do AWS CloudFormation”.

  8. (Opcional) Selecione Validar para garantir que o código YAML seja válido antes de confirmar.

  9. Escolha Commit (Confirmar).

  10. 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.

    2. Em Confirmar mensagem, insira:

      add initial workflow file

    3. Em Repositório, selecione codecatalyst-cfn-source-repository.

    4. Em Nome da ramificação, selecione a principal.

    5. Escolha Commit (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.

  2. Escolha o fluxo de trabalho que você acabou de criar: codecatalyst-cfn-workflow.

  3. Escolha a guia Execuções.

  4. Na coluna ID da execução, escolha o ID da execução.

  5. Selecione Teste para ver o andamento dos testes.

  6. Selecione BuildBackend para ver o andamento da criação.

  7. Selecione DeployCloudFormationStack para ver o andamento 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.

  8. Quando a ação DeployCloudFormationStack 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 na ação Testar ou BuildBackend, selecione Logs para solucionar o problema.

    • Se a execução do fluxo de trabalho falhar na ação DeployCloudFormationStack, escolha a ação de implantação e, depois, escolha a guia Resumo. Role até a seção Eventos do CloudFormation para ver a mensagem de erro detalhada. Se ocorrer uma reversão, exclua a pilha codecatalyst-cfn-stack por meio do console do AWS CloudFormation na 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.)

  2. Ao lado de HelloWorldApi, cole o URL https:// 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 fazer com que o CodeCatalyst exiba esse URL no diagrama do fluxo de trabalho com algumas configurações pequenas. Para ter mais informações, consulte Exibir o URL da aplicação no diagrama do fluxo de trabalho.

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.

  2. Selecione TestReport para visualizar os resultados do teste de unidade ou selecione CoverageReport para visualizar os detalhes da cobertura de código dos arquivos que estão sendo testados, neste caso, app.js e test-handler.js.

Para verificar os recursos implantados

  1. Faça login no AWS Management Console e abra o console do API Gateway em https://console.aws.amazon.com/apigateway/.

  2. Observe a API codecatalyst-cfn-stack criada pelo modelo do AWS SAM. O nome da API vem do valor Configuration/name no arquivo de definição do fluxo de trabalho (codecatalyst-cfn-workflow.yaml).

  3. Abra o console AWS Lambda em https://console.aws.amazon.com/lambda/.

  4. Selecione Funções no painel de navegação.

  5. Selecione a função do Lambda, codecatalyst-cfn-stack-HelloWorldFunction-string.

  6. Você pode ver como o gateway de API é um gatilho para a função. Essa integração foi configurada automaticamente pelo tipo de recurso AWS::Serverless::Function do AWS SAM.

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. Navegue até o seu projeto no CodeCatalyst.

  2. No painel de navegação, selecione Código e, depois, selecione Repositórios de origem.

  3. Escolha seu repositório de origem codecatalyst-cfn-source-repository.

  4. Altere o arquivo da aplicação:

    1. Escolha a pasta hello-world.

    2. Escolha o arquivo app.js.

    3. Selecione a opção Editar.

    4. Na linha 23, altere hello world para Tutorial complete!.

    5. 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.

  5. Atualize os testes de unidade:

    1. Selecione hello-world\tests\unit\test-handler.js.

    2. Selecione a opção Editar.

    3. Na linha 19, altere hello world para Tutorial complete!.

    4. 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.

  6. No painel de navegação, escolha CI/CD e Fluxos de trabalho.

  7. Selecione codecatalyst-cfn-workflow e Execuções.

  8. Escolha o ID da última execução. O status ainda deve ser em andamento.

  9. Escolha Teste, BuildBackend e DeployCloudFormationStack para ver o andamento da execução do fluxo de trabalho.

  10. Quando o fluxo de trabalho terminar, selecione Variáveis (7) na parte superior.

  11. Ao lado de HelloWorldApi, cole o URL https:// 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 console do CodeCatalyst

  1. Abra o console do CodeCatalyst em https://codecatalyst.aws/.

  2. Exclua codecatalyst-cfn-workflow.

  3. Exclua codecatalyst-cfn-environment.

  4. Exclua codecatalyst-cfn-source-repository.

  5. Exclua codecatalyst-cfn-project.

Para limpar no AWS Management Console

  1. Limpe no CloudFormation, da seguinte forma:

    1. Abra o console do AWS CloudFormation em https://console.aws.amazon.com/cloudformation.

    2. 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.

  2. Limpe no Amazon S3, da seguinte forma:

    1. Abra o console do Amazon S3 em https://console.aws.amazon.com/s3/.

    2. Selecione a codecatalyst-cfn-s3-bucket.

    3. Exclua os conteúdos do bucket.

    4. Excluir o bucket.

  3. Limpe no IAM, da seguinte forma:

    1. Abra o console do IAM em https://console.aws.amazon.com/iam/.

    2. Exclua o codecatalyst-deploy-policy.

    3. Exclua o codecatalyst-build-policy.

    4. Exclua o codecatalyst-stack-policy.

    5. Exclua o codecatalyst-deploy-role.

    6. Exclua o codecatalyst-build-role.

    7. Exclua o codecatalyst-stack-role.

Neste tutorial, você aprendeu a implantar uma aplicação sem servidor como uma pilha do CloudFormation usando um fluxo de trabalho do CodeCatalyst e uma ação Implantar pilha do AWS CloudFormation.