Tutorial: implantar um aplicativo sem servidor - Amazon CodeCatalyst
Pré-requisitosEtapa 1: criar um repositório de origemEtapa 2: criar AWS funçõesEtapa 3: adicionar AWS funções a CodeCatalystEtapa 4: criar um bucket do Amazon S3Etapa 5: Adicionar arquivos de origemEtapa 6: criar e executar um fluxo de trabalhoEtapa 7: faça uma alteraçãoLimpeza

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

Tutorial: implantar um aplicativo sem servidor

Neste tutorial, você aprende a criar, testar e implantar um aplicativo sem servidor como uma CloudFormation pilha usando um fluxo de trabalho.

O aplicativo neste tutorial é um aplicativo 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), que é uma extensão do AWS CloudFormation.

Pré-requisitos

Antes de começar

  • Você precisa de um CodeCatalyst espaço com uma AWS conta conectada. Para ter mais informações, consulte Criando 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 Criando um projeto vazio na Amazon CodeCatalyst.

  • 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 a IAMfunção padrão, escolha qualquer função. Você especificará uma função diferente posteriormente.

    Para ter mais informações, consulte Implantação em e Contas da AWS 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 Lambda.

Para obter mais informações sobre repositórios de origem, consulteCriação de um repositório de origem.

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.

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

  3. Em Nome do repositório, digite:

    codecatalyst-cfn-source-repository

  4. Escolha Criar.

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

Etapa 2: criar AWS funções

Nesta etapa, você cria as seguintes AWS IAM funções:

  • Função de implantação — concede permissão à ação CodeCatalyst Deploy AWS CloudFormation stack para acessar sua AWS conta e CloudFormation serviço onde você implantará seu aplicativo sem servidor. A ação Deploy AWS 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 obter mais informações sobre IAM funções, consulte IAMfunções no Guia AWS Identity and Access Management do usuário.

nota

Para economizar tempo, você pode criar uma única função, chamada de CodeCatalystWorkflowDevelopmentRole-spaceName função, em vez das três funções listadas anteriormente. Para ter mais informações, consulte Criando a CodeCatalystWorkflowDevelopmentRole-spaceNamefunção para sua conta e espaço. Entenda que a CodeCatalystWorkflowDevelopmentRole-spaceName função tem permissões muito amplas que podem representar um risco à segurança. Recomendamos que você use essa função somente em tutoriais e cenários em que a segurança seja menos preocupante. Este tutorial pressupõe que você esteja criando as três funções listadas anteriormente.

nota

Uma função de execução do Lambda também é necessária, mas você não precisa criá-la agora porque o sam-template.yml arquivo a cria para você quando você executa o fluxo de trabalho na etapa 5.

Para criar uma função de implantação

  1. Crie uma política para a função, da seguinte forma:

    1. Faça login em AWS.

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

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

    4. Escolha Create policy.

    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 a função for usada para executar ações de fluxo de trabalho, use o caractere curinga na declaração de política de recursos e, em seguida, 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, digite:

      codecatalyst-deploy-policy

    11. Escolha Criar política.

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

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

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

    2. Escolha a política de confiança personalizada.

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

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

      {
    "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, pesquise codecatalyst-deploy-policy e marque sua caixa de seleção.

    7. Escolha Próximo.

    8. Em Nome da função, digite:

      codecatalyst-deploy-role

    9. Em Descrição da função, insira:

      CodeCatalyst deploy role

    10. Selecione Criar função.

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

  3. Obtenha a função de implantaçãoARN, da seguinte forma:

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

    2. Na caixa de pesquisa, insira o nome da função que você acabou de criar (codecatalyst-deploy-role).

    3. Escolha a função na lista.

      A página de resumo da função é exibida.

    4. Na parte superior, copie o ARNvalor.

    Agora você criou a função de implantação com as permissões apropriadas e a obteveARN.

Para criar uma função de criação

  1. Crie uma política para a função, da seguinte forma:

    1. Faça login em AWS.

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

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

    4. Escolha Create policy.

    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 a função for usada para executar ações de fluxo de trabalho, use o caractere curinga na declaração de política de recursos e, em seguida, 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, digite:

      codecatalyst-build-policy

    11. Escolha Criar política.

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

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

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

    2. Escolha a política de confiança personalizada.

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

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

      {
    "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, pesquise codecatalyst-build-policy e marque sua caixa de seleção.

    7. Escolha Próximo.

    8. Em Nome da função, digite:

      codecatalyst-build-role

    9. Em Descrição da função, insira:

      CodeCatalyst build role

    10. Selecione Criar função.

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

  3. Obtenha a função de construçãoARN, da seguinte forma:

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

    2. Na caixa de pesquisa, insira o nome da função que você acabou de criar (codecatalyst-build-role).

    3. Escolha a função na lista.

      A página de resumo da função é exibida.

    4. Na parte superior, copie o ARNvalor.

    Agora você criou a função de criação com as permissões apropriadas e a obteveARN.

Para criar uma função de pilha

  1. Faça login AWS usando a conta na qual você deseja implantar sua pilha.

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

  3. Crie a função 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 na CloudFormationlista suspensa.

    5. Selecione o botão CloudFormationde rádio.

    6. Na parte inferior, escolha Avançar.

    7. Usando a caixa de pesquisa, localize as políticas de permissões a seguir e marque suas respectivas caixas de seleção.

      nota

      Se você pesquisar uma política e ela não aparecer, escolha Limpar filtros e tente novamente.

      • CloudWatchFullAccess

      • AWS CloudFormationFullAccess

      • IAMFullAccess

      • AWS Lambda_ FullAccess

      • Um mazonAPIGateway administrador

      • Amazon S3 FullAccess

      • Amazon EC2ContainerRegistryFullAccess

      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 obter mais informações, consulte Permissões no Guia do AWS Serverless Application Model desenvolvedor.

    8. Escolha Próximo.

    9. Em Nome da função, digite:

      codecatalyst-stack-role

    10. Selecione Criar função.

  4. Obtenha as funções da pilhaARN, da seguinte forma:

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

    2. Na caixa de pesquisa, insira o nome da função que você acabou de criar (codecatalyst-stack-role).

    3. Escolha a função na lista.

    4. Na seção Resumo, copie o ARNvalor. Você precisará disso mais tarde.

    Agora você criou a função de pilha com as permissões apropriadas e a ARN obteve.

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

Você não precisa adicionar a função 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 funções de criação e implantação à conexão da sua conta

  1. Dentro CodeCatalyst, navegue até seu espaço.

  2. Escolha AWS contas. Uma lista de conexões de conta é exibida.

  3. Escolha a conexão de conta que representa a AWS conta em que você criou suas funções de criação e implantação.

  4. Escolha Gerenciar funções no console de AWS gerenciamento.

    A página Adicionar IAM função ao CodeCatalyst espaço da Amazon é exibida. Talvez seja necessário fazer login para acessar a página.

  5. Selecione Adicionar uma função existente na qual você criou IAM.

    Uma lista suspensa é exibida. A lista exibe todas as IAM funções com uma política de confiança que inclui os diretores codecatalyst-runner.amazonaws.com e codecatalyst.amazonaws.com de serviço.

  6. Na lista suspensacodecatalyst-build-role, escolha e escolha Adicionar função.

  7. Escolha Adicionar IAM função, escolha Adicionar uma função existente na qual você criou eIAM, na lista suspensa, escolha. codecatalyst-deploy-role Escolha Add role (adicionar função).

    Agora você adicionou as funções de criação e implantação ao seu espaço.

  8. Copie o valor do nome de CodeCatalyst exibição da Amazon. Você precisará desse valor posteriormente, ao criar seu fluxo de trabalho.

Etapa 4: criar um bucket do Amazon S3

Nesta etapa, você cria um bucket do Amazon S3 onde armazena o arquivo.zip do pacote de implantação do seu aplicativo sem servidor.

Como criar um bucket do Amazon S3

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

  2. No painel principal, escolha 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ê escolheu US West (Oregon) us-west-2. Para obter informações sobre regiões suportadas pelo Amazon S3, consulte endpoints e cotas do Amazon Simple Storage Service no. Referência geral da AWS

  5. Na parte inferior da página, escolha Criar bucket.

Agora você criou um bucket chamado codecatalyst-cfn-s3-bucket na região us-west-2 do Oeste dos EUA (Oregon).

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 hello-world pasta contém os arquivos do aplicativo que você implantará. A tests pasta contém testes de unidade. A estrutura de pastas é a seguinte:

.
|— hello-world
|  |— tests
|     |— unit
|        |— test-handler.js
|  |— app.js
|— .npmignore
|— package.json
|— sam-template.yml
|— setup-sam.sh

arquivo.npmignore

O .npmignore arquivo indica quais arquivos e pastas o npm deve excluir do pacote do aplicativo. Neste tutorial, o npm exclui a tests pasta porque ela não faz parte do aplicativo.

Para adicionar o arquivo.npmignore

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

  2. Escolha seu projeto, codecatalyst-cfn-project

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

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

  5. Em Arquivos, escolha Criar arquivo.

  6. Em Nome do arquivo, digite:

    .npmignore

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

    tests/*

  8. Escolha Confirmar e, em seguida, escolha Confirmar novamente.

    Agora você criou um arquivo chamado .npmignore na raiz do seu repositório.

arquivo package.json

O package.json arquivo 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 seu aplicativo.

package.jsonNeste tutorial, incluímos uma lista de dependências e um test script. O script de teste faz o seguinte:

  • Usando o mocha, o script de teste executa os testes unitários especificados em hello-world/tests/unit/ e grava os resultados em um junit.xml arquivo 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 clover reporter. Para obter mais informações, consulte Usando repórteres alternativos na documentação de Istambul.

Para adicionar o arquivo package.json

  1. No seu repositório, em Arquivos, escolha Criar arquivo.

  2. Em Nome do arquivo, digite:

    package.json

  3. Na caixa de texto, insira o seguinte código:

    {
  "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. Escolha Confirmar e, em seguida, escolha Confirmar novamente.

    Agora você adicionou um arquivo chamado package.json à raiz do repositório.

arquivo sam-template.yml

O sam-template.yml arquivo contém as instruções para implantar a função Lambda e o Gateway API e configurá-los juntos. Ele segue a especificação do AWS Serverless Application Model modelo, que estende a especificação do AWS CloudFormation modelo.

Você usa um AWS SAM modelo neste tutorial em vez de um AWS CloudFormation modelo normal porque AWS SAM oferece um tipo de recurso útil AWS: :Serverless: :Function. Esse tipo executa muitas behind-the-scenes configurações que você normalmente precisa escrever para usar a CloudFormation sintaxe básica. Por exemplo, AWS::Serverless::Function cria uma função Lambda, uma função de execução do Lambda e mapeamentos de origem de eventos 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 ter mais informações, consulte Implantando uma pilha AWS CloudFormation.

Para adicionar o arquivo sam-template.yml

  1. No seu repositório, em Arquivos, escolha Criar arquivo.

  2. Em Nome do arquivo, digite:

    sam-template.yml

  3. Na caixa de texto, insira o seguinte código:

    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. Escolha Confirmar e, em seguida, escolha Confirmar novamente.

    Agora você adicionou um arquivo chamado sam-template.yml na pasta raiz do seu repositório.

arquivo setup-sam.sh

O setup-sam.sh arquivo contém as instruções para baixar e instalar o AWS SAM CLI utilitário. O fluxo de trabalho usa esse utilitário para empacotar a hello-world fonte.

Para adicionar o arquivo setup-sam.sh

  1. No seu repositório, em Arquivos, escolha Criar arquivo.

  2. Em Nome do arquivo, digite:

    setup-sam.sh

  3. Na caixa de texto, insira o seguinte código:

    #!/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 com sua AWS região.

  4. Escolha Confirmar e, em seguida, 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 Lambda. Neste tutorial, o código retorna o textohello world.

Para adicionar o arquivo app.js

  1. No seu repositório, em Arquivos, escolha Criar arquivo.

  2. Em Nome do arquivo, digite:

    hello-world/app.js

  3. Na caixa de texto, insira o seguinte código:

    // 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. Escolha Confirmar e, em seguida, escolha Confirmar novamente.

    Agora você criou uma pasta chamada hello-world e um arquivo chamadoapp.js.

arquivo test-handler.js

O test-handler.js arquivo contém testes de unidade para a função Lambda.

Para adicionar o arquivo test-handler.js

  1. No seu repositório, em Arquivos, escolha Criar arquivo.

  2. Em Nome do arquivo, digite:

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

  3. Na caixa de texto, insira o seguinte código:

    '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. Escolha Confirmar e, em seguida, escolha Confirmar novamente.

    Agora você adicionou um arquivo chamado test-handler.js abaixo da hello-world/tests/unit pasta.

Agora você adicionou todos os seus arquivos de origem.

Reserve um momento para verificar seu trabalho e garantir que você tenha colocado todos os arquivos nas pastas corretas. A estrutura de pastas é a seguinte:

.
|— 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 seu código-fonte do Lambda e o implanta. O fluxo de trabalho consiste nos seguintes blocos de construçã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 obter mais informações sobre gatilhos, consulte Iniciando um fluxo de trabalho executado automaticamente usando gatilhos.

  • Uma ação de teste (Test) — No gatilho, essa ação instala o gerenciador de pacotes Node (npm) e, em seguida, executa o npm run test comando. Esse comando instrui o npm a executar o test script definido no package.json arquivo. O test script, por sua vez, executa os testes unitários 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 XML relatórios em CodeCatalyst relatórios e os exibe no CodeCatalyst console, na guia Relatórios da ação de teste.

    Para obter mais informações sobre a ação de teste, consulteTestando com fluxos de trabalho.

  • Uma ação de construção (BuildBackend) — Ao concluir a ação de teste, a ação de compilação baixa e instala AWS SAM CLI, empacota a hello-world 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 obter mais informações sobre a ação de criação, consulteConstruindo 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 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.

Para criar um fluxo de trabalho

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

  2. Escolha Criar fluxo de trabalho.

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

  4. Para Branch, escolhamain.

  5. Escolha Criar.

  6. Exclua o código de YAML amostra.

  7. Adicione o YAML código a seguir:

    nota

    No YAML código a seguir, você pode omitir as Connections: seções, se quiser. Se você omitir essas seções, deverá garantir que a função especificada no campo Função padrão IAM em seu ambiente inclua as permissões e as políticas de confiança de ambas as funções descritas emEtapa 2: criar AWS funções. Para obter mais informações sobre como configurar um ambiente com uma IAM função padrão, consulteCriar 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:

    • Ambas as instâncias de codecatalyst-cfn-environment com o nome do seu ambiente.

    • Ambas as instâncias de 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 ter mais informações, consulte Etapa 3: adicionar AWS funções a CodeCatalyst.

    • codecatalyst-build-role com o nome da função de construção que você criou emEtapa 2: criar AWS funções.

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

    • Ambas as instâncias de 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 ambas as regiões estejam definidas como. us-west-2 Para obter detalhes sobre as regiões suportadas pelo Amazon S3 AWS CloudFormation, consulte Endpoints e cotas de serviço no. Referência geral da AWS

    • codecatalyst-deploy-role com o nome da função de implantação que você criou emEtapa 2: criar AWS funções.

    • codecatalyst-cfn-environment com o nome do ambiente em que você criouPré-requisitos.

    • 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

      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 com o nome ou ARN da CodeCatalystWorkflowDevelopmentRole-spaceName função. Para obter mais informações sobre essa função, consulte Etapa 2: criar AWS funções.

    Para obter informações sobre as propriedades no código mostrado anteriormente, consulte Ação “Deploy AWS CloudFormation stack” YAML o.

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

  9. Escolha Commit (Confirmar).

  10. Na caixa de diálogo Confirmar fluxo de trabalho, insira o seguinte:

    1. Para o nome do arquivo do fluxo de trabalho, mantenha o padrão,codecatalyst-cfn-workflow.

    2. Em Confirmar mensagem, digite:

      add initial workflow file

    3. Para Repositório, escolha codecatalyst-cfn-source-repository.

    4. Em Nome da filial, escolha 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 codecatalyst-cfn-workflow.yaml arquivo ao seu 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, em seguida, escolha 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 a ID da execução.

  5. Escolha Teste para ver o progresso dos testes.

  6. Escolha BuildBackendver o progresso da compilação.

  7. Escolha DeployCloudFormationStackver o progresso da implantação.

    Para obter mais informações sobre a visualização dos detalhes da execução, consulteVisualizando o status e os detalhes da execução do fluxo de trabalho.

  8. Quando a DeployCloudFormationStackaçã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 BuildBackendação, escolha Logs para solucionar o problema.

    • Se a execução do fluxo de trabalho falhar na DeployCloudFormationStackaçã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 AWS CloudFormation console AWS antes de executar novamente o fluxo de trabalho.

Para verificar a implantação

  1. Depois de uma implantação bem-sucedida, escolha Variáveis (7) na barra de menu horizontal próxima à parte superior. (Não escolha Variáveis no painel à direita.)

  2. Em seguida HelloWorldApi, cole o https:// URL em um navegador.

    Uma JSON mensagem hello world da função Lambda é exibida, indicando que o fluxo de trabalho implantou e configurou a função Lambda e o Gateway com sucesso. API

    dica

    Você pode CodeCatalyst exibir isso URL no diagrama do fluxo de trabalho com algumas configurações pequenas. Para ter mais informações, consulte Exibindo o aplicativo URL no diagrama do fluxo de trabalho.

Para verificar os resultados do teste unitário e a cobertura do código

  1. No diagrama do fluxo de trabalho, escolha Teste e, em seguida, escolha Relatórios.

  2. Escolha TestReportvisualizar os resultados do teste de unidade ou opte por CoverageReportvisualizar 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 AWS Management Console e abra o console do API Gateway em https://console.aws.amazon.com/apigateway/.

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

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

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

  5. Escolha sua função Lambda,. codecatalyst-cfn-stack-HelloWorldFunction-string

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

Etapa 7: faça uma alteração

Nesta etapa, você faz uma alteração no código-fonte do Lambda e o confirma. Esse commit inicia a execução de um novo fluxo de trabalho. Essa execução implanta a nova função Lambda em um esquema azul esverdeado que usa a configuração padrão de mudança de tráfego especificada no console Lambda.

Para fazer uma alteração na sua fonte do Lambda

  1. Em CodeCatalyst, navegue até seu projeto.

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

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

  4. Altere o arquivo do aplicativo:

    1. Escolha a pasta hello-world.

    2. Escolha o arquivo app.js.

    3. Selecione a opção Editar.

    4. Na linha 23, mude hello world paraTutorial complete!.

    5. Escolha Confirmar e, em seguida, escolha Confirmar novamente.

      A confirmação faz com que a 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 unitários:

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

    2. Selecione a opção Editar.

    3. Na linha 19, mude hello world paraTutorial complete!.

    4. Escolha Confirmar e, em seguida, escolha Confirmar novamente.

      A confirmação faz com que outra execução do fluxo de trabalho seja iniciada. Essa corrida será bem-sucedida.

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

  7. Escolha ecodecatalyst-cfn-workflow, em seguida, escolha Executar.

  8. Escolha o ID de execução da última execução. Ainda deve estar em andamento.

  9. Escolha Testar BuildBackend, e DeployCloudFormationStackpara ver o progresso da execução do fluxo de trabalho.

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

  11. Em seguida HelloWorldApi, cole o https:// URL em um navegador.

    Uma Tutorial complete! mensagem aparece no navegador, indicando que seu novo aplicativo foi implantado com sucesso.

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

  2. Excluircodecatalyst-cfn-workflow.

  3. Excluircodecatalyst-cfn-environment.

  4. Excluircodecatalyst-cfn-source-repository.

  5. Excluircodecatalyst-cfn-project.

Para limpar no AWS Management Console

  1. Limpe da CloudFormation seguinte forma:

    1. Abra o AWS CloudFormation console 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 API Gateway 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 o conteúdo do bucket.

    4. Excluir o bucket.

  3. Limpe da IAM 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 um aplicativo sem servidor como uma CloudFormation pilha usando um CodeCatalyst fluxo de trabalho e uma ação Deploy AWS CloudFormation stack.