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: criar um pipeline simples (CodeCommit repositório)
Neste tutorial, você usa CodePipeline para implantar o código mantido em um CodeCommit repositório em uma única instância do Amazon EC2. Seu funil é acionado quando você envia uma alteração para o CodeCommit repositório. O pipeline implanta suas alterações em uma instância do Amazon EC2 usando CodeDeploy como serviço de implantação.
**Importante**
Como parte da criação de um pipeline, um bucket de artefatos do S3 fornecido pelo cliente será usado pelo CodePipeline for artefatos. (Este bucket não é o mesmo utilizado para uma ação de origem do S3.) Se o bucket de artefatos do S3 estiver em uma conta diferente da conta do seu pipeline, certifique-se de que o bucket de artefatos do S3 seja de propriedade de Contas da AWS pessoas seguras e confiáveis.
O pipeline tem dois estágios:
+ Um estágio de origem (**Fonte**) para sua ação CodeCommit de origem.
+ Um estágio de implantação (**Implantação**) para sua ação CodeDeploy de implantação.
A maneira mais fácil de começar AWS CodePipeline é usar o ** assistente ** Create Pipeline no CodePipeline console.
**nota**
Antes de começar, certifique-se de ter configurado seu cliente Git para trabalhar com CodeCommit ele. Para obter instruções, consulte [Configuração para o CodeCommit](https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up.html).
## Etapa 1: criar um CodeCommit repositório
Primeiro, você cria um repositório no CodeCommit. Seu pipeline obtém o código-fonte desse repositório quando for executado. Você também cria um repositório local onde mantém e atualiza o código antes de enviá-lo ao CodeCommit repositório.
**Para criar um CodeCommit repositório**
1. Abra o CodeCommit console em [ https://console.aws.amazon.com/codecommit/](https://console.aws.amazon.com/codecommit/).
1. No seletor de região, escolha Região da AWS onde você deseja criar o repositório e o pipeline. Para obter mais informações, consulte [Regiões da AWS e endpoints](https://docs.aws.amazon.com/general/latest/gr/rande.html).
1. Na página **Repositories (Repositórios)**, selecione **Create repository (Criar repositório)**.
1. Na página **Create repository (Criar repositório)**, em **Repository name (Nome do repositório)**, insira um nome para o repositório (por exemplo **MyDemoRepo**).
1. Escolha **Criar**.
**nota**
As etapas restantes neste tutorial são usadas **MyDemoRepo** para o nome do seu CodeCommit repositório. Se você escolher um nome diferente, certifique-se de usá-lo durante todo este tutorial.
**Como configurar um repositório local**
Nesta etapa, você configurará um repositório local para se conectar ao repositório remoto do CodeCommit.
**nota**
Não é necessário configurar um repositório local. Você também pode usar o console do para fazer upload dos arquivos, conforme descrito em [Etapa 2: adicionar código de amostra ao seu CodeCommit repositório](#codecommit-add-code).
1. Com o novo repositório aberto no console, escolha **Clone URL (Clonar URL)** no canto superior direito da página e, depois, escolha **Clone SSH (Clonar SSH)**. O endereço para clonar o repositório Git é copiado na área de transferência.
1. No terminal ou na linha de comando, navegue até um diretório local onde você deseja que seu repositório local seja armazenado. Neste tutorial, usamos `/tmp`.
1. Execute o comando a seguir para clonar o repositório, substituindo o endereço SSH pelo que você copiou na etapa anterior. Esse comando cria um diretório chamado `MyDemoRepo`. Copie um aplicativo de exemplo nesse diretório.
```
git clone ssh://git-codecommit.us-west-2.amazonaws.com/v1/repos/MyDemoRepo
```
## Etapa 2: adicionar código de amostra ao seu CodeCommit repositório
Nesta etapa, você baixa o código de um aplicativo de amostra que foi criado para uma CodeDeploy amostra passo a passo e o adiciona ao seu CodeCommit repositório.
1. Depois, faça download de um exemplo e salve-o em uma pasta ou um diretório no computador local.
1. Escolha uma das opções a seguir. Selecione `SampleApp_Linux.zip` se deseja seguir as etapas deste tutorial para instâncias do Linux.
+ Se você quiser implantar em instâncias Amazon Linux usando CodeDeploy, baixe o aplicativo de amostra aqui: [ SampleApp \_ Linux.zip](samples/SampleApp_Linux.zip).
+ Se você quiser implantar em instâncias do Windows Server usando CodeDeploy, baixe o aplicativo de amostra aqui: [ SampleApp \_ Windows.zip](samples/SampleApp_Windows.zip).
O aplicativo de amostra contém os seguintes arquivos para implantação com CodeDeploy:
+ `appspec.yml`— O arquivo de especificação do aplicativo (AppSpecarquivo) é um arquivo [ formatado em ](http://www.yaml.org) YAML usado pelo CodeDeploy para gerenciar uma implantação. Para obter mais informações sobre o AppSpec arquivo, consulte Referência [ CodeDeploy AppSpec do arquivo ](https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file.html) no Guia *AWS CodeDeploy do usuário*.
+ `index.html`: o arquivo de índice contém a página inicial da aplicação de exemplo implantada.
+ `LICENSE.txt`: o arquivo de licença contém informações de licença da aplicação de exemplo.
+ Arquivos para scripts: a aplicação de exemplo usa scripts para gravar arquivos de texto em um local na instância. Um arquivo é gravado para cada um dos vários eventos do ciclo de vida da CodeDeploy implantação da seguinte forma:
+ Pasta `scripts` (somente exemplo do Linux): a pasta contém os seguintes scripts de shell para instalar dependências e iniciar e interromper a aplicação de exemplo para a implantação automatizada: `install_dependencies`, `start_server` e `stop_server`.
+ (Somente exemplo do Windows) `before-install.bat`: um script em lote para o evento de ciclo de vida de implantação `BeforeInstall`, que será executado para remover os arquivos antigos gravados durante implantações anteriores deste exemplo e criar um local na instância onde os novos arquivos serão gravados.
1. Faça download do arquivo compactado.
1. Descompacte os arquivos de [ SampleApp \_ Linux.zip ](samples/SampleApp_Linux.zip) no diretório local que você criou anteriormente (por exemplo, `/tmp/MyDemoRepo` ou`c:\temp\MyDemoRepo`).
Certifique-se de alocar os arquivos diretamente em seu repositório local. Não inclua uma pasta `SampleApp_Linux`. Na máquina Linux, macOS ou Unix local, por exemplo, a hierarquia de arquivos e diretórios deve ser semelhante a:
```
/tmp
└-- MyDemoRepo
│-- appspec.yml
│-- index.html
│-- LICENSE.txt
└-- scripts
│-- install_dependencies
│-- start_server
└-- stop_server
```
1. Para fazer upload dos arquivos para o repositório, use um dos métodos a seguir.
1. Para usar o CodeCommit console para fazer upload de seus arquivos:
1. Abra o CodeCommit console e escolha seu repositório na lista ** Repositórios. **
1. Selecione **Add file (Adicionar arquivo)** e clique em **Upload file (Carregar arquivo)**.
1. Selecione **Choose file (Escolher arquivo)** e procure o arquivo. Para adicionar um arquivo em uma pasta, selecione **Criar arquivo** e, depois, insira o nome da pasta com o nome do arquivo, como `scripts/install_dependencies`. Cole o conteúdo do arquivo no novo arquivo.
Informe seu nome de usuário e endereço de e-mail para confirmar a alteração.
Escolha **Commit changes (Confirmar alterações)**.
1. Repita esta etapa para cada arquivo.
O conteúdo do repositório deve ter a seguinte aparência:
```
│-- appspec.yml
│-- index.html
│-- LICENSE.txt
└-- scripts
│-- install_dependencies
│-- start_server
└-- stop_server
```
1. Para usar os comandos do git para fazer upload dos arquivos:
1. Altere diretórios para o seu repositório local:
```
{{(For Linux, macOS, or Unix)}} cd /tmp/MyDemoRepo
{{(For Windows)}} cd c:\temp\MyDemoRepo
```
1. Execute o seguinte comando para organizar todos os seus arquivos de uma só vez:
```
git add -A
```
1. Execute o seguinte comando para confirmar os arquivos com uma mensagem de confirmação:
```
git commit -m "Add sample application files"
```
1. Execute o seguinte comando para enviar os arquivos de seu repositório local para seu repositório do CodeCommit:
```
git push
```
1. Os arquivos que você baixou e adicionou ao seu repositório local agora foram adicionados à `main` ramificação em seu CodeCommit `MyDemoRepo` repositório e estão prontos para serem incluídos em um pipeline.
## Etapa 3: Crie uma instância Linux do Amazon EC2 e instale o agente CodeDeploy
Nesta etapa, você vai criar a instância do Amazon EC2 na qual implantará uma aplicação de exemplo. Como parte desse processo, crie uma função de instância que permita a instalação e o gerenciamento do CodeDeploy agente na instância. O CodeDeploy agente é um pacote de software que permite que uma instância seja usada em CodeDeploy implantações. Você também anexa políticas que permitem que a instância busque arquivos que o CodeDeploy agente usa para implantar seu aplicativo e permitir que a instância seja gerenciada pelo SSM.
**Como criar uma função de instância**
1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel do console, escolha **Roles (Funções)**.
1. Selecione **Criar perfil**.
1. Em **Selecionar tipo de entidade confiável**, selecione **AWS service (Serviço da AWS)**. Em **Escolha um caso de uso**, selecione **EC2**. Em **Select your use case (Selecione seu caso de uso)**, escolha **EC2**. Escolha **Próximo: Permissões**.
1. Procure e selecione a política chamada **`AmazonEC2RoleforAWSCodeDeploy`**.
1. Procure e selecione a política chamada **`AmazonSSMManagedInstanceCore`**. Escolha **Próximo: tags**.
1. Selecione **Próximo: revisar**. Forneça um nome para a função (por exemplo, **EC2InstanceRole**).
**nota**
Anote o nome da função para a próxima etapa. Escolha essa função ao criar a instância.
Selecione **Criar perfil**.
**Como iniciar uma instância**
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Na navegação lateral, escolha **Instâncias** e selecione **Executar instâncias** na parte superior da página.
1. Em **Nome**, insira **MyCodePipelineDemo**. Isso atribui à instância uma tag **Chave** de **Name** e uma tag **Valor** de **MyCodePipelineDemo**. Posteriormente, você cria um CodeDeploy aplicativo que implanta o aplicativo de amostra nessa instância. CodeDeployseleciona instâncias a serem implantadas com base nas tags.
1. Em Imagens de ** aplicativos e sistemas operacionais (Amazon Machine Image)**, localize a opção ** Amazon Linux ** AMI com o AWS logotipo e verifique se ela está selecionada. (Essa AMI é descrita como AMI do Amazon Linux 2 (HVM) e é identificada como “Elegível para o nível gratuito”.)
1. Em **Tipo de instância**, selecione o tipo `t2.micro` elegível para o nível gratuito como configuração de hardware para a instância.
1. Na seção **Par de chaves (login)**, selecione um par de chaves ou crie um.
Também é possível selecionar **Prosseguir sem um par de chaves**.
**nota**
Para os fins deste tutorial, é possível prosseguir sem um par de chaves. Para usar o SSH para se conectar às instâncias, crie ou use um par de chaves.
1. Em **Configurações de rede**, faça o seguinte:
Em IP ** Auto-assign público**, verifique se o status é ** Ativado**.
Selecione o grupo de segurança criado, escolha **HTTP** e, em **Tipo de origem**, escolha **Meu IP**.
1. Expanda **Advanced details** (Detalhes avançados). Em **Perfil de instância do IAM**, selecione o perfil do IAM criado no procedimento anterior (por exemplo, **EC2InstanceRole**).
1. Em **Resumo**, em **Número de instâncias**, insira `1`.
1. Escolha **Iniciar instância**.
1. É possível visualizar o status da ativação na página **Instâncias**. Ao executar uma instância, seu estado inicial é `pending`. Após o início da instância, seu estado muda para `running` e ela recebe um nome DNS público. (Se a ** coluna DNS ** público não for exibida, escolha o ** Show/Hide ** ícone e selecione DNS ** ** público.)
## Etapa 4: criar um aplicativo no CodeDeploy
Em CodeDeploy, um [* aplicativo *](https://docs.aws.amazon.com/codedeploy/latest/userguide/applications.html) é um recurso que contém o aplicativo de software que você deseja implantar. Posteriormente, você usa esse aplicativo com CodePipeline para automatizar as implantações do aplicativo de amostra em sua instância do Amazon EC2.
Primeiro, você cria uma função que permite CodeDeploy realizar implantações. Depois, crie um aplicativo do CodeDeploy .
**Para criar uma função CodeDeploy de serviço**
1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel do console, escolha **Roles (Funções)**.
1. Selecione **Criar perfil**.
1. Em **Selecionar entidade confiável**, escolha **AWS service (Serviço da AWS)**. Em **Use case** (Caso de uso), escolha **CodeDeploy**. **CodeDeploy**Escolha entre as opções listadas. Escolha **Próximo**. A política gerenciada `AWSCodeDeployRole` já está anexada à função.
1. Escolha **Próximo**.
1. Insira um nome para a função (por exemplo, **CodeDeployRole**) e escolha **Create role (Criar função)**.
**Para criar um aplicativo no CodeDeploy**
1. Abra o CodeDeploy console em [ https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy).
1. Se a página **Aplicações** não for exibida, no menu, selecione **Aplicações**.
1. Escolha **Criar aplicativo**.
1. Em **Nome do aplicativo**, insira **MyDemoApplication**.
1. Em ** Compute Platform**, escolha ** EC2/On-premises**.
1. Selecione **Criar aplicativo**.
**Para criar um grupo de implantação no CodeDeploy**
Um [*grupo de implantação*](https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-groups.html) é um recurso que define configurações relacionadas à implantação, como em quais instâncias implantar e com que rapidez implantá-las.
1. Na página que mostra o aplicativo, selecione **Create deployment group (Criar grupo de implantação)**.
1. Em **Nome do grupo de implantação**, insira **MyDemoDeploymentGroup**.
1. Em **Perfil de serviço**, selecione o perfil de serviço criado anteriormente (por exemplo, **`arn:aws:iam::{{account_ID}}:role/CodeDeployRole`**).
1. Em Tipo de ** implantação**, escolha ** In-place**.
1. Em **Environment configuration (Configuração do ambiente)**, selecione **Amazon EC2 Instances (Instâncias do Amazon EC2)**. No campo, **Chave**, insira **Name**. No campo **Valor**, insira o nome usado para marcar a instância (por exemplo, **MyCodePipelineDemo**).
1. Em Configuração do ** agente com o AWS Systems Manager**, escolha ** Agora e agende atualizações**. Isso vai instalar o agente na instância. A instância Linux já está configurada com o agente SSM e agora será atualizada com o CodeDeploy agente.
1. Em **Deployment configuration (Configuração de implantação)**, selecione `CodeDeployDefault.OneAtaTime`.
1. Em **Balanceador de carga**, verifique se **Habilitar balanceamento de carga** não está selecionado. Você não precisa configurar um load balancer ou escolher um grupo de destino para este exemplo.
1. Selecione **Criar grupo de implantação**.
## Etapa 5: crie seu primeiro funil no CodePipeline
Agora, você está pronto para criar e executar seu primeiro pipeline. Nesta etapa, você cria um pipeline que é executado automaticamente quando o código é enviado ao seu CodeCommit repositório.
**Para criar um CodePipeline funil**
1. Faça login no Console de gerenciamento da AWS e abra o CodePipeline console em [ http://console.aws.amazon.com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).
Abra o CodePipeline console em [ https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/).
1. Na página **Welcome (Bem-vindo)**, **Getting started (Conceitos básicos)** ou **Pipelines**, selecione **Create pipeline (Criar pipeline)**.
1. Na página **Etapa 1: Escolher opção de criação**, em **Opções de criação**, selecione a opção **Criar pipeline personalizado**. Escolha **Próximo**.
1. Em **Etapa 2: Escolher as configurações do pipeline**, em **Nome do pipeline**, insira **MyFirstPipeline**.
1. CodePipeline fornece tubulações do tipo V1 e V2, que diferem em características e preço. O tipo V2 é o único tipo que você pode escolher no console. Para ter mais informações, consulte [Pipeline types](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html?icmpid=docs_acp_help_panel). Para obter informações sobre preços para CodePipeline, consulte [ Preços](https://aws.amazon.com/codepipeline/pricing/).
1. Em Função ** de serviço**, escolha ** Nova função de serviço ** para permitir CodePipeline a criação de uma função de serviço no IAM.
1. Deixe as configurações em **Advanced settings (Configurações avançadas)** como padrão e escolha **Next (Próximo)**.
1. Em **Etapa 3: Adicionar etapa de origem**, em **Provedor de origem**, escolha **CodeCommit**. Em Nome ** do repositório**, escolha o nome do CodeCommit repositório em que você criou. [Etapa 1: criar um CodeCommit repositório](#codecommit-create-repository) Em **Branch name (Nome da ramificação)**, escolha `main` e, depois, selecione **Next step (Próxima etapa)**.
Depois de selecionar o nome e a ramificação do repositório, uma mensagem exibe a regra do Amazon CloudWatch Events a ser criada para esse pipeline.
Em **Change detection options (Alterar opções de detecção)**, deixe os valores padrão. Isso permite CodePipeline usar o Amazon CloudWatch Events para detectar alterações em seu repositório de origem.
Escolha **Próximo**.
1. Em **Etapa 4: Adicionar etapa de compilação**, escolha **Ignorar etapa de compilação** e aceite a mensagem de aviso escolhendo **Ignorar** novamente. Escolha **Próximo**.
**nota**
Neste tutorial, você está implantando um código que não requer um serviço de compilação, portanto, ignore esta etapa. No entanto, se o código-fonte precisar ser compilado antes de ser implantado em instâncias, você poderá configurar [CodeBuild](https://aws.amazon.com/codebuild/) nesta etapa.
1. Em **Etapa 5: Adicionar etapa de teste**, escolha **Ignorar etapa de teste** e aceite a mensagem de aviso escolhendo **Ignorar** novamente.
Escolha **Próximo**.
1. Na ** Etapa 6: Adicionar estágio de implantação**, em Provedor de ** implantação**, escolha ** CodeDeploy**. Em **Application name (Nome do aplicativo)**, escolha **MyDemoApplication**. Em **Deployment group (Grupo de implantação)**, escolha **MyDemoDeploymentGroup** e, depois, selecione **Next step (Próxima etapa)**.
1. Na ** Etapa 7: Revisar**, revise as informações e escolha ** Criar funil**.
1. O pipeline começa a ser executado depois de ser criado. Ele baixa o código do seu CodeCommit repositório e cria uma CodeDeploy implantação na sua instância do EC2. Você pode ver as mensagens de progresso, sucesso e falha à medida que a CodePipeline amostra implanta a página da web na instância do Amazon EC2 na implantação. CodeDeploy
Parabéns\! Você acabou de criar um funil simples em CodePipeline.
Depois, você verifica os resultados.
**Para verificar se o seu pipeline foi executado com êxito**
1. Visualize o progresso inicial do pipeline. O status de cada estágio muda de **No executions yet** (Ainda não executado) para **In Progress** (Em andamento) e, então, para **Succeeded** (Bem-sucedido) ou **Failed** (Falhou). O pipeline deve concluir a primeira execução dentro de alguns minutos.
1. Depois que ** Suceeded ** for exibido para o status do pipeline, na área de status do ** estágio ** Implantação, escolha ** CodeDeploy**. Isso abre o CodeDeploy console. Se ** Sucedido não ** for exibido, consulte[Solução de problemas CodePipeline](troubleshooting.md).
1. Na guia **Implantações**, selecione o ID de implantação. Na página da implantação, em **Eventos de ciclo de vida da implantação**, selecione o ID da instância. Isso abre o console do EC2.
1. Na guia **Description (Descrição)**, em **Public DNS (DNS público)**, copie o endereço (por exemplo, `ec2-192-0-2-1.us-west-2.compute.amazonaws.com`) e cole-o na barra de endereços de seu navegador da Web.
A página da web é exibida para o aplicativo de amostra que você baixou e enviou para o seu CodeCommit repositório.
Para obter mais informações sobre os estágios, as ações e o funcionamento dos pipelines, consulte [CodePipeline conceitos](concepts.md).
## Etapa 6: modificar o código em seu CodeCommit repositório
O pipeline está configurado para ser executado sempre que forem feitas alterações de código no repositório do CodeCommit. Nesta etapa, você faz alterações no arquivo HTML que faz parte do CodeDeploy aplicativo de amostra no CodeCommit repositório. Quando essas alterações são enviadas, o pipeline é executado novamente, e as alterações feitas ficam visíveis no endereço da web acessado anteriormente.
1. Altere diretórios para o seu repositório local:
```
{{(For Linux, macOS, or Unix)}} cd /tmp/MyDemoRepo
{{(For Windows)}} cd c:\temp\MyDemoRepo
```
1. Use um editor de texto para modificar o arquivo `index.html`:
```
{{(For Linux or Unix)}}gedit index.html
{{(For OS X)}}open –e index.html
{{(For Windows)}}notepad index.html
```
1. Revise o conteúdo do arquivo `index.html` para alterar a cor do plano de fundo e parte do texto na página da web e depois salve o arquivo.
```
Updated Sample Deployment
Updated Sample Deployment
This application was updated using CodePipeline, CodeCommit, and CodeDeploy.
```
1. Confirme e envie suas alterações para o seu CodeCommit repositório executando os seguintes comandos, um de cada vez:
```
git commit -am "Updated sample application files"
```
```
git push
```
**Como verificar se seu pipeline foi executado com êxito**
1. Visualize o progresso inicial do pipeline. O status de cada estágio muda de **No executions yet** (Ainda não executado) para **In Progress** (Em andamento) e, então, para **Succeeded** (Bem-sucedido) ou **Failed** (Falhou). A execução do pipeline deve ser concluída em alguns minutos.
1. Depois que **Succeeded (Bem-sucedido)** for exibido para o status da ação, atualize a página de demonstração acessada anteriormente no navegador.
A página da web atualizada é exibida.
## Etapa 7: Limpar os recursos
É possível usar alguns dos recursos criados neste tutorial para outros tutoriais neste guia. Por exemplo, você pode reutilizar o CodeDeploy aplicativo e a implantação. No entanto, depois de finalizar este e outros tutoriais, você deverá excluir o pipeline e os recursos usados para não ser cobrado pelo uso contínuo desses recursos. Primeiro, exclua o pipeline, depois o CodeDeploy aplicativo e sua instância associada do Amazon EC2 e, finalmente, o CodeCommit repositório.
**Para limpar os recursos usados neste tutorial**
1. Para limpar seus CodePipeline recursos, siga as instruções em [ Excluir um funil em AWS CodePipeline](pipelines-delete.md).
1. Para limpar seus CodeDeploy recursos, siga as instruções em Recursos passo a passo de implantação do [ Clean Up. ](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorials-simple-s3alkthrough.html#tutorials-simple-s3alkthrough-clean-up)
1. Para excluir o CodeCommit repositório, siga as instruções em [ Excluir um CodeCommit repositório](https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-delete-repository.html).
## Etapa 8: Outras fontes de leitura
Saiba mais sobre como CodePipeline funciona:
+ Para obter mais informações sobre os estágios, as ações e o funcionamento dos pipelines, consulte [CodePipeline conceitos](concepts.md).
+ Para obter informações sobre as ações que você pode realizar usando CodePipeline, consulte[Integrações com tipos de CodePipeline ação](integrations-action-type.md).
+ Experimente este tutorial mais avançado, [Tutorial: Criar um pipeline de quatro estágios](tutorials-four-stage-pipeline.md). Ele cria um pipeline de vários estágios incluindo uma etapa que cria o código antes de ser implantado.