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á. # Usando CI/CD sistemas e pipelines para implantar com AWS SAM AWS SAM ajuda as organizações a criar pipelines para seus CI/CD sistemas preferidos, para que possam obter os benefícios CI/CD com o mínimo esforço, como acelerar a frequência de implantação, reduzir o tempo de espera para mudanças e reduzir os erros de implantação. AWS SAM simplifica CI/CD tarefas para aplicativos sem servidor com a ajuda da criação de imagens de contêiner. As imagens AWS SAM fornecidas incluem as ferramentas AWS SAMCLI e de construção para vários AWS Lambda tempos de execução compatíveis. Isso facilita a criação e o empacotamento de aplicativos sem servidor usando o. AWS SAMCLI Essas imagens também aliviam a necessidade de as equipes criarem e gerenciarem suas próprias imagens para CI/CD sistemas. Para obter mais informações sobre como AWS SAM criar imagens de contêiner, consulte[Repositórios de imagens para AWS SAM](serverless-image-repositories.md). Vários CI/CD sistemas suportam a AWS SAM criação de imagens de contêineres. O CI/CD sistema que você deve usar depende de vários fatores. Isso inclui se seu aplicativo usa um único runtime ou vários tempos de execução, ou se você deseja criar seu aplicativo em uma imagem de contêiner ou diretamente em uma máquina host, seja uma máquina virtual (VM) ou um host bare metal. AWS SAM também fornece um conjunto de modelos de pipeline padrão para vários CI/CD sistemas que encapsulam as melhores práticas AWS de implantação da empresa. Esses modelos de pipeline padrão usam formatos de configuração de JSON/YAML pipeline padrão, e as melhores práticas integradas ajudam a realizar implantações em várias contas e em várias regiões, além de verificar se os pipelines não podem fazer alterações não intencionais na infraestrutura. Você tem duas opções principais para AWS SAM implantar seus aplicativos sem servidor: 1) Modifique sua configuração de pipeline existente para usar AWS SAMCLI comandos ou 2) Gere um exemplo de configuração de CI/CD pipeline que você possa usar como ponto de partida para seu próprio aplicativo. **Topics** + [O que é um pipeline?](#deploying-whatis-pipeline) + [Como AWS SAM carrega arquivos locais na implantação](deploy-upload-local-files.md) + [Gere um CI/CD pipeline inicial com AWS SAM](serverless-generating-example-ci-cd.md) + [Como personalizar tubulações iniciais com AWS SAM](serverless-customizing-starter-pipelines.md) + [Automatize a implantação do seu aplicativo AWS SAM](serverless-deploying-modify-pipeline.md) + [Como usar a autenticação OIDC com pipelines AWS SAM](deploying-with-oidc.md) ## O que é um pipeline? Um pipeline é uma sequência automatizada de etapas que são executadas para lançar uma nova versão de uma aplicação. [Com AWS SAM, você pode usar muitos CI/CD sistemas comuns para implantar seus aplicativos, incluindo [Jenkins [AWS CodePipeline](https://aws.amazon.com/codepipeline)](https://www.jenkins.io/), [GitLab CI/CD](https://docs.gitlab.com/ee/ci/) e Actions. GitHub](https://github.com/features/actions) Os modelos de pipeline incluem as melhores práticas de AWS implantação para ajudar nas implantações em várias contas e em várias regiões. AWS ambientes como desenvolvimento e produção normalmente existem em AWS contas diferentes. Isso permite que as equipes de desenvolvimento configurem pipelines de implantação seguros, sem fazer alterações não intencionais na infraestrutura. Você também pode fornecer seus próprios modelos de pipeline personalizados para ajudar a padronizar os pipelines entre as equipes de desenvolvimento. # Como AWS SAM carrega arquivos locais na implantação Quando você implanta seu aplicativo no Nuvem AWS, é AWS CloudFormation necessário que seus arquivos locais sejam primeiro carregados em um AWS serviço acessível, como o Amazon Simple Storage Service (Amazon S3). Isso inclui arquivos locais aos quais seu AWS SAM modelo faz referência. Para atender a esse requisito, a CLI do AWS SAM faz o seguinte, quando você usa o comando `sam deploy` ou `sam package`: 1. Carrega automaticamente seus arquivos locais em um AWS serviço acessível. 1. Atualiza automaticamente o modelo da aplicação para fazer referência ao novo caminho do arquivo. **Topics** + [Demonstração: use o AWS SAMCLI para fazer upload do código da função do Lambda](#deploy-upload-local-files-demo) + [Casos de uso compatíveis](#deploy-upload-local-files-use) + [Saiba mais](#deploy-upload-local-files-learn) ## Demonstração: use o AWS SAMCLI para fazer upload do código da função do Lambda Nesta demonstração, inicializamos o aplicativo Hello World de amostra usando um tipo de pacote.zip para nossa função do Lambda. Usamos o AWS SAMCLI para carregar automaticamente nosso código de função do Lambda para o Amazon S3 e referenciar seu novo caminho em nosso modelo de aplicativo. Primeiro, executamos `sam init` para inicializar nosso aplicativo Hello World. ``` $ sam init ... Which template source would you like to use? 1 - AWS Quick Start Templates 2 - Custom Template Location Choice: 1 Choose an AWS Quick Start application template 1 - Hello World Example 2 - Multi-step workflow ... Template: 1 Use the most popular runtime and package type? (Python and zip) [y/N]: y Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: ENTER Would you like to enable monitoring using CloudWatch Application Insights? For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER Project name [sam-app]: demo ----------------------- Generating application: ----------------------- Name: demo Runtime: python3.9 Architectures: x86_64 Dependency Manager: pip Application Template: hello-world Output Directory: . Configuration file: demo/samconfig.toml ... ``` Nosso código de função do Lambda é organizado no subdiretório `hello_world` do nosso projeto. ``` demo ├── README.md ├── hello_world │ ├── __init__.py │ ├── app.py │ └── requirements.txt ├── template.yaml └── tests ``` Em nosso AWS SAM modelo, referenciamos o caminho local para nosso código de função Lambda usando a `CodeUri` propriedade. ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 ... Resources: HelloWorldFunction: Type: AWS::Serverless::Function # More info about Function Resource: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction Properties: CodeUri: hello_world/ Handler: app.lambda_handler Runtime: python3.9 ... ``` Em seguida, executamos `sam build` para criar nosso aplicativo e nos preparar para a implantação. ``` $ sam build Starting Build use cache Manifest file is changed (new hash: 3298f13049d19cffaa37ca931dd4d421) or dependency folder (.aws-sam/deps/7896875f-9bcc-4350-8adb-2c1d543627a1) is missing for (HelloWorldFunction), downloading dependencies and copying/building source Building codeuri: /Users/.../demo/hello_world runtime: python3.9 metadata: {} architecture: x86_64 functions: HelloWorldFunction Running PythonPipBuilder:CleanUp Running PythonPipBuilder:ResolveDependencies Running PythonPipBuilder:CopySource Running PythonPipBuilder:CopySource Build Succeeded Built Artifacts : .aws-sam/build Built Template : .aws-sam/build/template.yaml ... ``` Em seguida, executamos `sam deploy --guided` para implantar nosso aplicativo. ``` $ sam deploy --guided Configuring SAM deploy ====================== Looking for config file [samconfig.toml] : Found Reading default arguments : Success Setting default arguments for 'sam deploy' ========================================= Stack Name [demo]: ENTER AWS Region [us-west-2]: ENTER #Shows you resources changes to be deployed and require a 'Y' to initiate deploy Confirm changes before deploy [Y/n]: n #SAM needs permission to be able to create roles to connect to the resources in your template Allow SAM CLI IAM role creation [Y/n]: ENTER #Preserves the state of previously provisioned resources when an operation fails Disable rollback [y/N]: ENTER HelloWorldFunction may not have authorization defined, Is this okay? [y/N]: y Save arguments to configuration file [Y/n]: ENTER SAM configuration file [samconfig.toml]: ENTER SAM configuration environment [default]: ENTER Looking for resources needed for deployment: ... Saved arguments to config file Running 'sam deploy' for future deployments will use the parameters saved above. The above parameters can be changed by modifying samconfig.toml Learn more about samconfig.toml syntax at https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-config.html File with same data already exists at demo/da3c598813f1c2151579b73ad788cac8, skipping upload Deploying with following values =============================== Stack name : demo Region : us-west-2 Confirm changeset : False Disable rollback : False Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr Capabilities : ["CAPABILITY_IAM"] Parameter overrides : {} Signing Profiles : {} Initiating deployment ===================== ... Waiting for changeset to be created.. CloudFormation stack changeset ------------------------------------------------------------------------------------------------- Operation LogicalResourceId ResourceType Replacement ------------------------------------------------------------------------------------------------- + Add HelloWorldFunctionHell AWS::Lambda::Permissio N/A oWorldPermissionProd n + Add HelloWorldFunctionRole AWS::IAM::Role N/A ... ------------------------------------------------------------------------------------------------- Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1680906292/1164338d-72e7-4593-a372-f2b3e67f542f 2023-04-07 12:24:58 - Waiting for stack create/update to complete CloudFormation events from stack operations (refresh every 5.0 seconds) ------------------------------------------------------------------------------------------------- ResourceStatus ResourceType LogicalResourceId ResourceStatusReason ------------------------------------------------------------------------------------------------- CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole - CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole Resource creation Initiated ... ------------------------------------------------------------------------------------------------- CloudFormation outputs from deployed stack ------------------------------------------------------------------------------------------------- Outputs ------------------------------------------------------------------------------------------------- Key HelloWorldFunctionIamRole Description Implicit IAM Role created for Hello World function Value arn:aws:iam::012345678910:role/demo-HelloWorldFunctionRole-VQ4CU7UY7S2K Key HelloWorldApi Description API Gateway endpoint URL for Prod stage for Hello World function Value https://satnon55e9.execute-api.us-west-2.amazonaws.com/Prod/hello/ Key HelloWorldFunction Description Hello World Lambda Function ARN Value arn:aws:lambda:us-west-2:012345678910:function:demo- HelloWorldFunction-G14inKTmSQvK ------------------------------------------------------------------------------------------------- Successfully created/updated stack - demo in us-west-2 ``` Durante a implantação, o carrega AWS SAMCLI automaticamente nosso código de função do Lambda para o Amazon S3 e atualiza nosso modelo. Nosso modelo modificado no CloudFormation console reflete o caminho do bucket do Amazon S3. ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 ... Resources: HelloWorldFunction: Type: AWS::Serverless::Function Properties: CodeUri: s3://aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr/demo/da3c598813f1c2151579b73ad788cac8 Handler: app.lambda_handler ... ``` ## Casos de uso compatíveis Eles AWS SAMCLI podem facilitar automaticamente esse processo para vários tipos de arquivos, tipos de CloudFormation recursos e CloudFormation macros. ### Tipos de arquivo Arquivos e imagens do aplicativo Docker são suportados. ### CloudFormation tipos de recursos Veja a seguir uma lista dos tipos de recursos compatíveis e suas propriedades: | Recurso | Propriedades | | --- | --- | | AWS::ApiGateway::RestApi | BodyS3Location | | AWS::ApiGatewayV2::Api | BodyS3Location | | AWS::AppSync:FunctionConfiguration | `CodeS3Location` `RequestMappingTemplateS3Location` `ResponseMappingTemplateS3Location` | | AWS::AppSync::GraphQLSchema | DefinitionS3Location | | AWS::AppSync::Resolver | `CodeS3Location` `RequestMappingTemplateS3Location` `ResponseMappingTemplateS3Location` | | AWS::CloudFormation::ModuleVersion | ModulePackage | | AWS::CloudFormation::ResourceVersion | SchemaHandlerPackage | | AWS::ECR::Repository | RepositoryName | | AWS::ElasticBeanstalk::ApplicationVersion | SourceBundle | | AWS::Glue::Job | Command.ScriptLocation | | AWS::Lambda::Function | `Code` `Code.ImageUri` | | AWS::Lambda::LayerVersion | Content | | AWS::Serverless::Api | DefinitionUri | | AWS::Serverless::Function | `CodeUri` `ImageUri` | | AWS::Serverless::GraphQLApi | `SchemaUri` `Function.CodeUri` `Resolver.CodeUri` | | AWS::Serverless::HttpApi | DefinitionUri | | AWS::Serverless::LayerVersion | ContentUri | | AWS::Serverless::StateMachine | DefinitionUri | | AWS::StepFunctions::StateMachine | DefinitionS3Location | ### CloudFormation macros Os arquivos referenciados usando a macro de transformação `AWS::Include` são suportados. ## Saiba mais Para saber mais sobre a `AWS::Include` transformação, consulte [ AWS::Include transform](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/create-reusable-transform-function-snippets-and-add-to-your-template-with-aws-include-transform.html) no *Guia do AWS CloudFormation usuário*. Para ver um exemplo do uso da `AWS::Include` transformação em um AWS SAM modelo, consulte o padrão API [HTTP API to SQS do API Gateway](https://serverlessland.com/patterns/apigw-sqs) em *Serverless* Land. # Gere um CI/CD pipeline inicial com AWS SAM Quando estiver pronto para automatizar a implantação, você poderá usar um dos nossos modelos AWS SAM de pipeline inicial para gerar um pipeline de implantação para o CI/CD sistema que você escolher usar. O pipeline de implantação é o que você configura e usa para automatizar a implantação da aplicação sem servidor. Um modelo de pipeline inicial é pré-configurado para ajudar você a configurar rapidamente o pipeline de implantação para a aplicação sem servidor. Com um modelo de pipeline inicial, você pode gerar pipelines em poucos minutos usando o comando [sam pipeline init](sam-cli-command-reference-sam-pipeline-init.md). Os modelos iniciais do pipeline usam a JSON/YAML sintaxe familiar do CI/CD sistema e incorporam as melhores práticas, como gerenciar artefatos em várias contas e regiões e usar a quantidade mínima de permissões necessárias para implantar o aplicativo. [https://github.com/features/actions](https://github.com/features/actions) Aqui estão as tarefas de alto nível que você precisa realizar para gerar uma configuração inicial do pipeline: 1. **Crie recursos de infraestrutura** — Seu pipeline requer determinados AWS recursos, por exemplo, o usuário e as funções do IAM com as permissões necessárias, um bucket do Amazon S3 e, opcionalmente, um repositório do Amazon ECR. 1. **Conecte seu repositório Git ao seu CI/CD sistema — Seu CI/CD sistema** precisa saber qual repositório Git acionará a execução do pipeline. Observe que essa etapa pode não ser necessária, dependendo da combinação do repositório Git e do CI/CD sistema que você está usando. 1. **Gere sua configuração de pipeline** — Essa etapa gera uma configuração inicial de pipeline que inclui dois estágios de implantação. 1. **Confirme a configuração do pipeline no repositório Git** — Essa etapa é necessária para garantir que seu CI/CD sistema esteja ciente da configuração do pipeline e seja executada quando as alterações forem confirmadas. Depois de gerar a configuração inicial do pipeline e confirmá-la no seu repositório Git, sempre que alguém fizer uma alteração de código nesse repositório, seu pipeline será acionado para ser executado automaticamente. A ordem dessas etapas e os detalhes de cada etapa variam de acordo com seu sistema de CI/CD: + Se você estiver usando AWS CodePipeline, consulte[Gerando um pipeline inicial para AWS CodePipeline AWS SAM](serverless-generating-example-ci-cd-codepipeline.md). + Se você estiver usando Jenkins, GitLab CI/CD, GitHub Actions ou Bitbucket Pipelines, consulte. [Use AWS SAM para gerar pipelines iniciais para Jenkins, GitLab CI/CD, Actions, Bitbucket Pipelines GitHub](serverless-generating-example-ci-cd-others.md) # Gerando um pipeline inicial para AWS CodePipeline AWS SAM Para gerar uma configuração de pipeline inicial para AWS CodePipeline, execute as seguintes tarefas nesta ordem: 1. Criar recursos de infraestrutura 1. Gere a configuração do pipeline 1. Confirme a configuração do pipeline no repositório Git 1. Conecte seu repositório Git ao seu sistema CI/CD **nota** O procedimento a seguir utiliza dois comandos AWS SAMCLI, `sam pipeline bootstrap` e `sam pipeline init`. A razão pela qual existem dois comandos é lidar com o caso de uso em que os administradores (ou seja, usuários que precisam de permissão para configurar AWS recursos de infraestrutura, como usuários e funções do IAM) têm mais permissão do que os desenvolvedores (ou seja, usuários que precisam apenas de permissão para configurar pipelines individuais, mas não os AWS recursos de infraestrutura necessários). ## Etapa 1: Criar recursos de infraestrutura Os pipelines que usam AWS SAM exigem determinados AWS recursos, como um usuário e funções do IAM com as permissões necessárias, um bucket do Amazon S3 e, opcionalmente, um repositório Amazon ECR. Você deve ter um conjunto de recursos de infraestrutura para cada estágio de implantação do pipeline. Você pode executar o seguinte comando para ajudar nesta configuração: ``` sam pipeline bootstrap ``` **nota** Execute o comando anterior para cada estágio de implantação do seu pipeline. ## Etapa 2: Gerar a configuração do pipeline Para gerar a configuração do pipeline, execute o comando a seguir. ``` sam pipeline init ``` ## Etapa 3: Confirme a configuração do pipeline no repositório Git Essa etapa é necessária para garantir que seu CI/CD sistema esteja ciente da configuração do pipeline e seja executada quando as alterações forem confirmadas. ## Etapa 4: Conecte seu repositório Git ao seu sistema CI/CD Pois agora AWS CodePipeline você pode criar a conexão executando o seguinte comando: ``` sam deploy -t codepipeline.yaml --stack-name --capabilities=CAPABILITY_IAM --region ``` Se você estiver usando o GitHub Bitbucket, depois de executar o **sam deploy** comando anteriormente, conclua a conexão seguindo as etapas em **Para concluir uma conexão, encontradas no tópico Atualizar uma conexão** [pendente](https://docs.aws.amazon.com/dtconsole/latest/userguide/connections-update.html) no *guia do usuário do console Developer Tools*. Além disso, armazene uma cópia `CodeStarConnectionArn` do da saída do **sam deploy** comando, pois você precisará dela se quiser usar AWS CodePipeline com outra ramificação diferente de`main`. ## Configurando outras ramificações Por padrão, AWS CodePipeline usa a `main` ramificação com AWS SAM. Se quiser usar uma ramificação diferente de `main`, você deve executar o comando **sam deploy** novamente. Observe que, dependendo do repositório Git que você estiver usando o, poderá ser necessário fornecer o `CodeStarConnectionArn`: ``` # For GitHub and Bitbucket sam deploy -t codepipeline.yaml --stack-name --capabilities=CAPABILITY_IAM --parameter-overrides="FeatureGitBranch= CodeStarConnectionArn=" # For AWS CodeCommit sam deploy -t codepipeline.yaml --stack-name --capabilities=CAPABILITY_IAM --parameter-overrides="FeatureGitBranch=" ``` ## Saiba mais *Para ver um exemplo prático de configuração de um CI/CD pipeline, consulte [CI/CD AWS CodePipeline em The Complete Workshop](https://catalog.workshops.aws/complete-aws-sam/en-US/module-4-cicd). AWS SAM * # Use AWS SAM para gerar pipelines iniciais para Jenkins, GitLab CI/CD, Actions, Bitbucket Pipelines GitHub Para gerar uma configuração inicial de pipeline para Jenkins, GitLab CI/CD, GitHub Actions ou Bitbucket Pipelines, execute as seguintes tarefas nesta ordem: 1. Criar recursos de infraestrutura 1. Conecte seu repositório Git ao seu sistema CI/CD 1. Crie objetos de credencial 1. Gere a configuração do pipeline 1. Confirme a configuração do pipeline no repositório Git **nota** O procedimento a seguir utiliza dois comandos AWS SAMCLI, `sam pipeline bootstrap` e `sam pipeline init`. A razão pela qual existem dois comandos é lidar com o caso de uso em que os administradores (ou seja, usuários que precisam de permissão para configurar AWS recursos de infraestrutura, como usuários e funções do IAM) têm mais permissão do que os desenvolvedores (ou seja, usuários que precisam apenas de permissão para configurar pipelines individuais, mas não os AWS recursos de infraestrutura necessários). ## Etapa 1: Criar recursos de infraestrutura Os pipelines que usam AWS SAM exigem determinados AWS recursos, como um usuário e funções do IAM com as permissões necessárias, um bucket do Amazon S3 e, opcionalmente, um repositório Amazon ECR. Você deve ter um conjunto de recursos de infraestrutura para cada estágio de implantação do pipeline. Você pode executar o seguinte comando para ajudar nesta configuração: ``` sam pipeline bootstrap ``` **nota** Execute o comando anterior para cada estágio de implantação do seu pipeline. Você deve capturar AWS as credenciais (ID da chave e chave secreta) dos usuários do pipeline em cada estágio de implantação do seu pipeline, pois elas são necessárias para as etapas subsequentes. ## Etapa 2: Conecte seu repositório Git ao seu sistema CI/CD É necessário conectar seu repositório Git ao seu CI/CD sistema para que o CI/CD sistema possa acessar o código-fonte do seu aplicativo para compilações e implantações. **nota** Você pode ignorar esta etapa se estiver usando uma das combinações a seguir, porque a conexão é feita para você automaticamente: GitHub Ações com GitHub repositório GitLab CI/CD com repositório GitLab Pipelines do Bitbucket com um repositório do Bitbucket Para conectar seu repositório Git ao seu CI/CD sistema, faça o seguinte: + Se você estiver usando o Jenkins, consulte a [documentação do Jenkins](https://www.jenkins.io/doc/book/pipeline/multibranch/) para “Adicionar uma fonte de ramificação”. + Se você estiver usando GitLab CI/CD e um repositório Git diferente GitLab, consulte a [GitLabdocumentação](https://docs.gitlab.com/ee/ci/ci_cd_for_external_repos/) para “conectar um repositório externo”. ## Etapa 3: Criar objetos de credencial Cada CI/CD sistema tem sua própria maneira de gerenciar as credenciais necessárias para que o CI/CD sistema acesse seu repositório Git. Para criar os objetos de credencial necessários, faça o seguinte: + Se você estiver usando o Jenkins, crie uma única “credencial” que armazene o ID da chave e a chave secreta. Siga as instruções no blog [Como criar um pipeline do Jenkins com AWS SAM](https://aws.amazon.com/blogs/compute/building-a-jenkins-pipeline-with-aws-sam/), na seção **Configurar o Jenkins**. Você precisará dessa “ID de credencial” para a próxima etapa. + Se você estiver usando GitLab CI/CD, crie duas “variáveis protegidas”, uma para cada ID de chave e chave secreta. Siga as instruções na [GitLab documentação](https://docs.gitlab.com/ee/ci/variables/) — você precisará de duas “chaves variáveis” para a próxima etapa. + Se você estiver usando GitHub Ações, crie dois “segredos criptografados”, um para cada chave e uma chave secreta. Siga as instruções na [GitHubdocumentação](https://docs.github.com/en/actions/reference/encrypted-secrets) - você precisará de dois “nomes secretos” para a próxima etapa. + Se você estiver usando o Bitbucket Pipelines, crie duas “variáveis seguras”, uma para cada ID de chave e chave secreta. Siga as instruções em [Variáveis e segredos](https://support.atlassian.com/bitbucket-cloud/docs/variables-and-secrets) - você precisará de dois "nomes secretos" para a próxima etapa. ## Etapa 4: Gerar a configuração do pipeline Para gerar a configuração do pipeline, execute o comando a seguir. Você precisará inserir o objeto de credencial criado na etapa anterior: ``` sam pipeline init ``` ## Etapa 5: Confirme a configuração do pipeline no repositório Git Essa etapa é necessária para garantir que seu CI/CD sistema esteja ciente da configuração do pipeline e seja executada quando as alterações forem confirmadas. ## Saiba mais *Para ver um exemplo prático de como configurar um CI/CD pipeline usandoGitHub Actions, consulte [CI/CD GitHub em The Complete Workshop](https://s12d.com/sam-ws-en-gh). AWS SAM * # Como personalizar tubulações iniciais com AWS SAM Como CI/CD administrador, talvez você queira personalizar um modelo de pipeline inicial e as instruções guiadas associadas que os desenvolvedores da sua organização possam usar para criar configurações de pipeline. O AWS SAMCLI usa modelos Cookiecutter ao criar modelos iniciais. Para obter detalhes sobre o cookie cutter template, [Cookiecutter](https://cookiecutter.readthedocs.io/en/latest/README.html). Você também pode personalizar os prompts que AWS SAMCLI exibe aos usuários ao criar configurações de pipeline usando o comando `sam pipeline init`. Para personalizar os prompts do usuário, faça o seguinte: 1. **Criar um arquivo `questions.json` ** — O arquivo `questions.json` deve estar na raiz do repositório do projeto. Este é o mesmo diretório do arquivo `cookiecutter.json`. Para ver o esquema do arquivo `questions.json`, consulte [questions.json.schema](https://github.com/aws/aws-sam-cli/blob/2b831b29f76ac9c4e0cbcbd68b37f8f664e136d8/samcli/lib/pipeline/init/questions.json.schema). Para ver um arquivo `questions.json` de exemplo, consulte [questions.json.](https://github.com/aws/aws-sam-cli-pipeline-init-templates/blob/main/Jenkins/two-stage-pipeline-template/questions.json) 1. **Mapeie chaves de pergunta com nomes de cookiecutter** — Cada objeto no arquivo `questions.json` precisa de uma chave que corresponda a um nome no modelo cookiecutter. Essa combinação de teclas é a forma como AWS SAMCLI mapeia as respostas rápidas do usuário ao modelo do cortador de biscoitos. Para obter exemplo dessa correspondência de teclas, consulte a seção [Exemplo de arquivos](#serverless-customizing-starter-pipelines-example-files) mais adiante neste tópico. 1. **Crie um `metadata.json` arquivo** - Declare o número de estágios que o pipeline terá no arquivo `metadata.json` . O número de estágios instrui o comando `sam pipeline init` sobre quantos estágios solicitar informações ou, no caso da opção `--bootstrap`, para quantos estágios criar recursos de infraestrutura. Para ver um arquivo `metadata.json` de exemplo que declara um pipeline com dois estágios, consulte [metadata.json](https://github.com/aws/aws-sam-cli-pipeline-init-templates/blob/main/Jenkins/two-stage-pipeline-template/metadata.json). ## Projetos de exemplo Aqui estão exemplos de projetos, cada um incluindo um modelo Cookiecutter, um arquivo `questions.json` e um arquivo: `metadata.json` + Exemplo do Jenkins: [modelo de pipeline do Jenkins em dois estágios](https://github.com/aws/aws-sam-cli-pipeline-init-templates/tree/main/Jenkins/two-stage-pipeline-template) + CodePipeline exemplo: [modelo de CodePipeline pipeline de dois estágios](https://github.com/aws/aws-sam-cli-pipeline-init-templates/tree/main/AWS-CodePipeline/two-stage-pipeline-template) ## Exemplo de arquivos O conjunto de arquivos a seguir mostra como as perguntas no arquivo `questions.json` são associadas às entradas no arquivo de modelo Cookiecutter. Observe que esses exemplos são trechos de arquivo, não arquivos completos. Para ver exemplos de arquivos completos, consulte a seção [Projetos de exemplo](#serverless-customizing-starter-pipelines-example-projects) anterior neste tópico. Exemplo de **`questions.json`**: ``` { "questions": [{ "key": "intro", "question": "\nThis template configures a pipeline that deploys a serverless application to a testing and a production stage.\n", "kind": "info" }, { "key": "pipeline_user_jenkins_credential_id", "question": "What is the Jenkins credential ID (via Jenkins plugin \"aws-credentials\") for pipeline user access key?", "isRequired": true }, { "key": "sam_template", "question": "What is the template file path?", "default": "template.yaml" }, { ... ``` Exemplo de **`cookiecutter.json`**: ``` { "outputDir": "aws-sam-pipeline", "pipeline_user_jenkins_credential_id": "", "sam_template": "", ... ``` Exemplo de **`Jenkinsfile`**: ``` pipeline { agent any environment { PIPELINE_USER_CREDENTIAL_ID = '{{cookiecutter.pipeline_user_jenkins_credential_id}}' SAM_TEMPLATE = '{{cookiecutter.sam_template}}' ... ``` # Automatize a implantação do seu aplicativo AWS SAM Em AWS SAM, a forma como você automatiza a implantação do seu AWS SAM aplicativo varia de acordo com o CI/CD sistema que você está usando. Por esse motivo, os exemplos desta seção mostram como configurar vários CI/CD sistemas para automatizar a criação de aplicativos sem servidor em uma imagem de contêiner de AWS SAM compilação. Essas imagens de contêiner de construção facilitam a criação e o empacotamento de aplicativos sem servidor usando o. AWS SAMCLI Os procedimentos do CI/CD pipeline existente para implantar aplicativos sem servidor AWS SAM são um pouco diferentes, dependendo do CI/CD sistema que você está usando. Os tópicos a seguir fornecem exemplos de como configurar seu CI/CD sistema para criar aplicativos sem servidor em uma imagem de contêiner de AWS SAM compilação: **Topics** + [Usando AWS CodePipeline para implantar com AWS SAM](deploying-using-codepipeline.md) + [Usando o Bitbucket Pipelines para implantar com AWS SAM](deploying-using-bitbucket.md) + [Usando o Jenkins para implantar com AWS SAM](deploying-using-jenkins.md) + [Usando GitLab CI/CD para implantar com AWS SAM](deploying-using-gitlab.md) + [Usando GitHub ações para implantar com AWS SAM](deploying-using-github.md) # Usando AWS CodePipeline para implantar com AWS SAM Para configurar seu [AWS CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html)pipeline para automatizar a criação e a implantação do seu AWS SAM aplicativo, seu CloudFormation modelo e `buildspec.yml` arquivo devem conter linhas que façam o seguinte: 1. Faça referência a uma imagem de contêiner de construção com o tempo de execução necessário a partir das imagens disponíveis. O exemplo a seguir usa a imagem do contêiner de compilação do `public.ecr.aws/sam/build-nodejs20.x`. 1. Configure os estágios do pipeline para executar os AWS SAM comandos necessários da interface de linha de comando (CLI). O exemplo a seguir executa dois comandos AWS SAM CLI: **sam build** e **sam deploy** (com as opções necessárias). Este exemplo pressupõe que você tenha declarado todas as funções e camadas em seu arquivo AWS SAM de modelo com`runtime: nodejs20.x`. **CloudFormation trecho do modelo:** ``` CodeBuildProject: Type: AWS::CodeBuild::Project Properties: Environment: ComputeType: BUILD_GENERAL1_SMALL Image: public.ecr.aws/sam/build-nodejs20.x Type: LINUX_CONTAINER ... ``` **`buildspec.yml` snippet:** ``` version: 0.2 phases: build: commands: - sam build - sam deploy --no-confirm-changeset --no-fail-on-empty-changeset ``` Para obter a lista das imagens de contêiner disponíveis para a criação do Amazon Elastic Container Registry (Amazon ECR), consulte [Repositórios de imagens para AWS SAM](serverless-image-repositories.md). # Usando o Bitbucket Pipelines para implantar com AWS SAM Para configurar seu [Bitbucket Pipeline](https://support.atlassian.com/bitbucket-cloud/docs/get-started-with-bitbucket-pipelines/) para automatizar a criação e a implantação do seu AWS SAM aplicativo, seu `bitbucket-pipelines.yml` arquivo deve conter linhas que façam o seguinte: 1. Faça referência a uma imagem de contêiner de construção com o tempo de execução necessário a partir das imagens disponíveis. O exemplo a seguir usa a imagem do contêiner de compilação do `public.ecr.aws/sam/build-nodejs20.x`. 1. Configure os estágios do pipeline para executar os AWS SAM comandos necessários da interface de linha de comando (CLI). O exemplo a seguir executa dois comandos AWS SAM CLI: **sam build** e **sam deploy** (com as opções necessárias). Este exemplo pressupõe que você tenha declarado todas as funções e camadas em seu arquivo AWS SAM de modelo com`runtime: nodejs20.x`. ``` image: public.ecr.aws/sam/build-nodejs20.x pipelines: branches: main: # branch name - step: name: Build and Package script: - sam build - sam deploy --no-confirm-changeset --no-fail-on-empty-changeset ``` Para obter a lista das imagens de contêiner disponíveis para a criação do Amazon Elastic Container Registry (Amazon ECR), consulte [Repositórios de imagens para AWS SAM](serverless-image-repositories.md). # Usando o Jenkins para implantar com AWS SAM Para configurar seu pipeline do [Jenkins](https://www.jenkins.io/) para automatizar a criação e a implantação do seu AWS SAM aplicativo, você `Jenkinsfile` deve conter linhas que façam o seguinte: 1. Faça referência a uma imagem de contêiner de construção com o tempo de execução necessário a partir das imagens disponíveis. O exemplo a seguir usa a imagem do contêiner de compilação do `public.ecr.aws/sam/build-nodejs20.x`. 1. Configure os estágios do pipeline para executar os AWS SAM comandos necessários da interface de linha de comando (CLI). O exemplo a seguir executa dois comandos AWS SAM CLI: **sam build** e **sam deploy** (com as opções necessárias). Este exemplo pressupõe que você tenha declarado todas as funções e camadas em seu arquivo AWS SAM de modelo com`runtime: nodejs20.x`. ``` pipeline { agent { docker { image 'public.ecr.aws/sam/build-nodejs20.x' } } stages { stage('build') { steps { sh 'sam build' sh 'sam deploy --no-confirm-changeset --no-fail-on-empty-changeset' } } } } ``` Para obter a lista das imagens de contêiner disponíveis para a criação do Amazon Elastic Container Registry (Amazon ECR), consulte [Repositórios de imagens para AWS SAM](serverless-image-repositories.md). # Usando GitLab CI/CD para implantar com AWS SAM Para configurar seu [GitLab](https://about.gitlab.com)pipeline para automatizar a criação e a implantação do seu AWS SAM aplicativo, seu `gitlab-ci.yml` arquivo deve conter linhas que façam o seguinte: 1. Faça referência a uma imagem de contêiner de construção com o tempo de execução necessário a partir das imagens disponíveis. O exemplo a seguir usa a imagem do contêiner de compilação do `public.ecr.aws/sam/build-nodejs20.x`. 1. Configure os estágios do pipeline para executar os AWS SAM comandos necessários da interface de linha de comando (CLI). O exemplo a seguir executa dois comandos AWS SAM CLI: **sam build** e **sam deploy** (com as opções necessárias). Este exemplo pressupõe que você tenha declarado todas as funções e camadas em seu arquivo AWS SAM de modelo com`runtime: nodejs20.x`. ``` image: public.ecr.aws/sam/build-nodejs20.x deploy: script: - sam build - sam deploy --no-confirm-changeset --no-fail-on-empty-changeset ``` Para obter a lista das imagens de contêiner disponíveis para a criação do Amazon Elastic Container Registry (Amazon ECR), consulte [Repositórios de imagens para AWS SAM](serverless-image-repositories.md). # Usando GitHub ações para implantar com AWS SAM Para configurar seu [GitHub](https://github.com/)pipeline para automatizar a criação e a implantação do seu AWS SAM aplicativo, você deve primeiro instalar a interface de linha de AWS SAM comando (CLI) em seu host. Você pode usar [GitHub Ações](https://github.com/features/actions) em seu GitHub fluxo de trabalho para ajudar nessa configuração. O exemplo GitHub de fluxo de trabalho a seguir configura um host Ubuntu usando uma série de GitHub ações e, em seguida, executa AWS SAMCLI comandos para criar e implantar um AWS SAM aplicativo: ``` on: push: branches: - main jobs: deploy: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - uses: actions/setup-python@v3 - uses: aws-actions/setup-sam@v2 - uses: aws-actions/configure-aws-credentials@v1 with: aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }} aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }} aws-region: us-east-2 - run: sam build --use-container - run: sam deploy --no-confirm-changeset --no-fail-on-empty-changeset ``` Para obter a lista das imagens de contêiner disponíveis para a criação do Amazon Elastic Container Registry (Amazon ECR), consulte [Repositórios de imagens para AWS SAM](serverless-image-repositories.md). # Como usar a autenticação OIDC com pipelines AWS SAM AWS Serverless Application Model (AWS SAM) suporta autenticação de usuário OpenID Connect (OIDC) para Bitbucket, GitHub Actions e integração GitLab contínua e entrega contínua (contas de CI/CD) platforms. With this support, you can use authorized CI/CD usuário de qualquer uma dessas plataformas) para gerenciar seus pipelines de aplicativos sem servidor. Caso contrário, você precisaria criar e gerenciar vários usuários AWS Identity and Access Management (IAM) para controlar o acesso aos AWS SAM pipelines. ## Configurar o OIDC com pipeline AWS SAM Durante o processo `sam pipeline bootstrap` de configuração, faça o seguinte para configurar o OIDC com seu AWS SAM pipeline. 1. Quando solicitado a escolher um provedor de identidade, selecione **OIDC**. 1. Em seguida, selecione um provedor OIDC compatível. 1. Insira a URL do provedor OIDC, começando com **https://**. **nota** AWS SAM faz referência a esse URL quando ele gera o tipo de `AWS::IAM::OIDCProvider` recurso. 1. Em seguida, siga as instruções e insira as informações da CI/CD plataforma necessárias para acessar a plataforma selecionada. Esses detalhes variam de acordo com a plataforma e podem incluir: + ID do cliente do OIDC. + Nome do repositório do código ou identificador universalmente exclusivo (UUUID). + O nome do grupo ou da organização associada ao repositório. + GitHub organização à qual o repositório de código pertence. + GitHub nome do repositório. + Filial a partir da qual as implantações ocorrerão. 1. AWS SAM exibe um resumo da configuração do OIDC inserida. Insira o número de uma configuração para editá-la ou pressione Enter para continuar. 1. Quando solicitado a confirmar a criação dos recursos necessários para suportar a conexão OIDC inserida, pressione Y para continuar. AWS SAM gera um `AWS::IAM::OIDCProvider` AWS CloudFormation recurso com a configuração fornecida que assume a função de execução do pipeline. Para saber mais sobre esse tipo de CloudFormation recurso, consulte [AWS: :IAM:: OIDCProvider](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-oidcprovider.html) no *Guia do AWS CloudFormation usuário*. **nota** Se o recurso do provedor de identidade (IdP) já existir no seu Conta da AWS, AWS SAM faça referência a ele em vez de criar um novo recurso. ## Exemplo A seguir está um exemplo de configuração do OIDC com AWS SAM pipeline. ``` Select a permissions provider: 1 - IAM (default) 2 - OpenID Connect (OIDC) Choice (1, 2): 2 Select an OIDC provider: 1 - GitHub Actions 2 - GitLab 3 - Bitbucket Choice (1, 2, 3): 1 Enter the URL of the OIDC provider [https://token.actions.githubusercontent.com]: Enter the OIDC client ID (sometimes called audience) [sts.amazonaws.com]: Enter the GitHub organization that the code repository belongs to. If there is no organization enter your username instead: my-org Enter GitHub repository name: testing Enter the name of the branch that deployments will occur from [main]: [3] Reference application build resources Enter the pipeline execution role ARN if you have previously created one, or we will create one for you []: Enter the CloudFormation execution role ARN if you have previously created one, or we will create one for you []: Please enter the artifact bucket ARN for your Lambda function. If you do not have a bucket, we will create one for you []: Does your application contain any IMAGE type Lambda functions? [y/N]: [4] Summary Below is the summary of the answers: 1 - Account: 123456 2 - Stage configuration name: dev 3 - Region: us-east-1 4 - OIDC identity provider URL: https://token.actions.githubusercontent.com 5 - OIDC client ID: sts.amazonaws.com 6 - GitHub organization: my-org 7 - GitHub repository: testing 8 - Deployment branch: main 9 - Pipeline execution role: [to be created] 10 - CloudFormation execution role: [to be created] 11 - Artifacts bucket: [to be created] 12 - ECR image repository: [skipped] Press enter to confirm the values above, or select an item to edit the value: This will create the following required resources for the 'dev' configuration: - IAM OIDC Identity Provider - Pipeline execution role - CloudFormation execution role - Artifact bucket Should we proceed with the creation? [y/N]: ``` ## Saiba mais Para obter mais informações sobre como usar o OIDC com o AWS SAM pipeline, consulte. [sam pipeline bootstrap](sam-cli-command-reference-sam-pipeline-bootstrap.md)