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 de quatro estágios
Agora que criou o primeiro pipeline em [Tutorial: Criar um pipeline simples (bucket do S3)](tutorials-simple-s3.md) ou [Tutorial: criar um pipeline simples (CodeCommit repositório)](tutorials-simple-codecommit.md), você pode começar a criar pipelines mais complexos. Este tutorial orientará você na criação de um pipeline de quatro estágios que usa um GitHub repositório para sua fonte, um servidor de compilação Jenkins para criar o projeto e um CodeDeploy aplicativo para implantar o código criado em um servidor de teste. O diagrama a seguir mostra o pipeline inicial de três estágios.
Após a criação do pipeline, você o editará para adicionar um estágio com uma ação de teste para testar o código, também usando Jenkins.
Antes de criar esse pipeline, você deve configurar os recursos necessários. Por exemplo, se você quiser usar um GitHub repositório para seu código-fonte, deverá criar o repositório antes de adicioná-lo a um pipeline. Como parte da configuração, este tutorial orienta você a configurar o Jenkins em uma instância do EC2 para fins de demonstração.
**Importante**
Muitas das ações adicionadas ao pipeline nesse procedimento envolvem AWS recursos que você precisa criar antes de criar o pipeline. AWS os recursos para suas ações de origem sempre devem ser criados na mesma AWS região em que você cria seu pipeline. Por exemplo, se você criar seu pipeline na região Leste dos EUA (Ohio), seu CodeCommit repositório deverá estar na região Leste dos EUA (Ohio).
Você pode adicionar ações entre regiões ao criar seu pipeline. AWS os recursos para ações entre regiões devem estar na mesma AWS região em que você planeja executar a ação. Para obter mais informações, consulte [Adicionar uma ação entre regiões em CodePipeline](actions-create-cross-region.md).
**Importante**
Como parte da criação de um pipeline, um bucket de artefatos S3 fornecido pelo cliente será usado CodePipeline por for artefacts. (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 Contas da AWS seja de propriedade de quem é seguro e confiável.
Antes de iniciar este tutorial, você já deve ter concluído os pré-requisitos gerais em [Começando com CodePipeline](getting-started-codepipeline.md).
**Topics**
+ [Etapa 1: Concluir os pré-requisitos](#tutorials-four-stage-pipeline-prerequisites)
+ [Etapa 2: criar um pipeline no CodePipeline](#tutorials-four-stage-pipeline-pipeline-create)
+ [Etapa 3: Adicionar outro estágio ao pipeline](#tutorials-four-stage-pipeline-add-stage)
+ [Etapa 4: Limpar os recursos](#tutorials-four-stage-pipeline-clean-up)
## Etapa 1: Concluir os pré-requisitos
Para se integrar com o Jenkins, é AWS CodePipeline necessário instalar o CodePipeline plug-in para Jenkins em qualquer instância do Jenkins com a qual você queira usar. CodePipeline Você também deve configurar um usuário ou função do IAM dedicado para usar como permissões entre seu projeto Jenkins e. CodePipeline A maneira mais fácil de integrar o Jenkins CodePipeline é instalar o Jenkins em uma instância do EC2 que usa uma função de instância do IAM criada por você para a integração com o Jenkins. Para a conexão dos links no pipeline das ações do Jenkins ocorrer com êxito, é necessário definir as configurações de proxy e firewall no servidor ou na instância do EC2 para permitir conexões de entrada na porta usada pelo projeto do Jenkins. Verifique se você configurou o Jenkins para autenticar usuários e aplicar o controle de acesso antes de permitir conexões nessas portas (por exemplo, 443 e 8443 se você fixou Jenkins para usar somente conexões HTTPS, ou 80 e 8080 se você permite conexões HTTP). Para obter mais informações, consulte [Como fixar Jenkins](https://wiki.jenkins.io/display/JENKINS/Securing+Jenkins).
**nota**
Este tutorial usa uma amostra de código e configura as etapas de criação que convertem a amostra de Haml em HTML. Você pode baixar o código de amostra de código aberto do GitHub repositório seguindo as etapas em. [Copiar ou clonar a amostra em um repositório GitHub](#tutorials-four-stage-pipeline-prerequisites-github) Você precisará da amostra inteira em seu GitHub repositório, não apenas do arquivo.zip.
Este tutorial também pressupõe que:
Você está familiarizado com a instalação e administração do Jenkins e com a criação de projetos do Jenkins.
Você instalou o Rake e o gem de Haml para Ruby no mesmo computador ou instância que hospeda o projeto do Jenkins.
Você definiu as variáveis do ambiente do sistema exigidas para que os comandos do Rake possam ser executados do terminal ou da linha de comando (por exemplo, em sistemas Windows, alterar a variável PATH para incluir o diretório em que o Rake está instalado).
**Topics**
+ [Copiar ou clonar a amostra em um repositório GitHub](#tutorials-four-stage-pipeline-prerequisites-github)
+ [Criar um perfil do IAM a ser usado na integração do Jenkins](#tutorials-four-stage-pipeline-prerequisites-jenkins-iam-role)
+ [Instale e configure o Jenkins e o CodePipeline plug-in para Jenkins](#tutorials-four-stage-pipeline-prerequisites-jenkins-configure)
### Copiar ou clonar a amostra em um repositório GitHub
**Para clonar a amostra e enviá-la para um repositório GitHub**
1. Baixe o código de amostra do GitHub repositório ou clone os repositórios em seu computador local. Há dois pacotes de amostra:
+ [Se você for implantar sua amostra em instâncias Amazon Linux, RHEL ou Ubuntu Server, escolha codepipeline-jenkins-aws-codedeploy \_linux.zip.](https://github.com/awslabs/aws-codepipeline-jenkins-aws-codedeploy_linux)
+ Se você for implantar sua amostra em instâncias do Windows Server, escolha [CodePipeline-Jenkins](https://github.com/awslabs/AWSCodePipeline-Jenkins-AWSCodeDeploy_windows) - .zip. AWSCodeDeploy\_Windows
1. No repositório, selecione **Fork** para clonar a amostra do repositório em um repositório na sua conta do Github. Para obter mais informações, consulte a [documentação do GitHub](https://help.github.com/articles/create-a-repo/).
### Criar um perfil do IAM a ser usado na integração do Jenkins
Como prática recomendada, considere lançar uma instância do EC2 para hospedar seu servidor Jenkins e usar uma função do IAM para conceder à instância as permissões necessárias para interagir. CodePipeline
1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação do console do IAM, selecione **Perfis** e, depois, **Criar perfil**.
1. Em **Select type of trusted entity** (Selecionar o tipo de entidade confiável), escolha **AWS service (Serviço da AWS)**. Em **Choose the service that will use this role (Escolha o serviço que usará essa função)**, escolha **EC2**. Em **Select your use case (Selecione seu caso de uso)**, escolha **EC2**.
1. Escolha **Próximo: Permissões**. Na página **Attach permissions policies (Anexar políticas de permissões)**, selecione a política gerenciada `AWSCodePipelineCustomActionAccess` e escolha **Next: Tags (Próximo: tags)**. Escolha **Próximo: revisar**.
1. Na página **Review (Revisar)** em **Role name (Nome da função)**, insira o nome da função a ser criada especificamente para integração do Jenkins (por exemplo {{JenkinsAccess}}) e escolha **Create role (Criar função)**.
Ao criar a instância do EC2 em que você instalará o Jenkins, em **Step 3: Configure Instance Details (Etapa 3: configurar os detalhes da instância)**, selecione a função da instância (por exemplo, {{JenkinsAccess}}).
Para obter mais informações sobre os perfis de instância e o Amazon EC2, consulte [Funções do IAM para Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html), [Uso de uma função do IAM para conceder permissões a aplicações em execução em instâncias do Amazon EC2](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-usingrole-ec2instance.html) e [Criar uma função para delegar permissões a um AWS service (Serviço da AWS)](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-creatingrole-service.html).
### Instale e configure o Jenkins e o CodePipeline plug-in para Jenkins
**Para instalar o Jenkins e o CodePipeline plug-in para Jenkins**
1. Crie uma instância do EC2 em que você instalará o Jenkins e, em **Step 3: Configure Instance Details (Etapa 3: configurar os detalhes da instância)**, selecione a função da instância que você criou (por exemplo {{JenkinsAccess}}). Para obter mais informações sobre a criação de instâncias do EC2, consulte [Launch an Amazon EC2 instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-instance_linux.html) no *Guia do usuário do Amazon EC2*.
**nota**
Se você já tem recursos do Jenkins que deseja utilizar, pode usá-los, mas deve criar um usuário especial do IAM, aplicar a política gerenciada `AWSCodePipelineCustomActionAccess` a esse usuário e, depois, configurar e usar as credenciais de acesso para esse usuário no recurso do Jenkins. Se deseja utilizar a IU Jenkins para fornecer as credenciais, configure o Jenkins para permitir apenas HTTPS. Para obter mais informações, consulte [Solução de problemas CodePipeline](troubleshooting.md).
1. Instale o Jenkins na instância do EC2. Para obter mais informações, consulte a documentação do Jenkins para [instalar o Jenkins](https://www.jenkins.io/doc/book/installing/linux/) e [iniciar e acessar o Jenkins](https://wiki.jenkins.io/JENKINS/Starting-and-Accessing-Jenkins.html), assim como [details of integration with Jenkins](integrations-action-type.md#JenkinsInt_2) em [Integrações de produtos e serviços com CodePipeline](integrations.md).
1. Inicie o Jenkins e, na página inicial, selecione **Gerenciar Jenkins**.
1. Na página **Gerenciar Jenkins**, selecione **Gerenciar plug-ins**.
1. Selecione a guia **Available (Disponível)** e, na caixa de pesquisa **Filter (Filtro)**, insira **AWS CodePipeline**. Escolha **CodePipeline Plugin para Jenkins** na lista e escolha **Baixar agora e instalar após reiniciar**.
1. Na página **Instalar plug-ins/atualizações**, selecione **Reiniciar Jenkins quando a instalação estiver concluída e nenhum trabalho estiver em execução**.
1. Selecione **Voltar para o painel**.
1. Na página principal, selecione **Novo item**.
1. Em **Nome do item**, insira um nome para o projeto Jenkins (por exemplo,{{MyDemoProject}}). Selecione **Projeto estilo livre** e depois **OK**.
**nota**
Verifique se o nome do projeto atende aos requisitos do CodePipeline. Para obter mais informações, consulte [Cotas no AWS CodePipeline.](limits.md).
1. Na página de configuração do projeto, selecione a caixa de seleção **Executar construções simultâneas se necessário**. Em **Source Code Management (Gerenciamento de código-fonte)**, selecione **AWS CodePipeline**. Se você instalou o Jenkins em uma instância do EC2 e configurou o AWS CLI com o perfil do usuário do IAM que você criou para integração entre CodePipeline e o Jenkins, deixe todos os outros campos vazios.
1. Escolha **Avançado** e, em **Provedor**, insira um nome para o provedor da ação conforme ele aparecerá em CodePipeline (por exemplo,{{MyJenkinsProviderName}}). Certifique-se de que esse nome seja exclusivo e fácil de lembrar. Você o utilizará quando adicionar uma ação de construção para o pipeline mais adiante neste tutorial e novamente quando adicionar uma ação de teste.
**nota**
Este nome de ação deve atender aos requisitos de nomenclatura para ações no CodePipeline. Para obter mais informações, consulte [Cotas no AWS CodePipeline.](limits.md).
1. Em **Construir triggers**, desmarque todas as caixas de seleção e depois selecione **Apurar SCM**. Em **Schedule (Programação)**, insira cinco asteriscos separados por espaços, conforme a seguir:
```
* * * * *
```
Isso faz pesquisas a CodePipeline cada minuto.
1. Em **Construir**, selecione **Adicionar etapa da construção**. Selecione **Executar shell** (Amazon Linux, RHEL ou Ubuntu Server) **Executar comando em lote** (Windows Server) e, depois, digite o seguinte:
```
rake
```
**nota**
Verifique se o ambiente está configurado com as variáveis e as configurações necessárias para executar rake; caso contrário, a construção falhará.
1. Escolha **Adicionar ação pós-compilação** e, em seguida, escolha **AWS CodePipeline Publisher**. Selecione **Adicionar**, e em **Criar pontos de saída**, deixe o local em branco. Esta configuração é o padrão. Ela criará um arquivo compactado no final do processo de construção.
1. Selecione **Salvar** para salvar seu projeto Jenkins.
## Etapa 2: criar um pipeline no CodePipeline
Nesta parte do tutorial, você criará o pipeline usando o assistente **Create Pipeline (Criar pipeline)**.
**Para criar um processo de liberação CodePipeline automatizado**
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).
1. Se necessário, use o seletor de região para alterar a região para aquela em que os recursos do pipeline estão localizados. Por exemplo, se você criou recursos para o tutorial anterior em `us-east-2`, verifique se o seletor de região está definido como Leste dos EUA (Ohio).
Para obter mais informações sobre as regiões e os endpoints disponíveis CodePipeline, consulte [AWS CodePipeline endpoints e](https://docs.aws.amazon.com/general/latest/gr/codepipeline.html) cotas.
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 a página de configurações do pipeline**, em **Nome do pipeline**, insira o nome do seu pipeline.
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 de 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. Na página **Etapa 3: Adicionar estágio de origem**, em **Provedor de origem**, escolha **GitHub**.
1. Em **Conexão**, escolha uma conexão existente ou crie uma nova. Para criar ou gerenciar uma conexão para sua ação GitHub de origem, consulte[GitHub conexões](connections-github.md).
1. Em **Etapa 4: adicionar estágio de compilação**, escolha **Adicionar Jenkins**. Em **Nome do provedor**, insira o nome da ação que você forneceu no CodePipeline Plugin para Jenkins (por exemplo{{MyJenkinsProviderName}}). Esse nome deve corresponder exatamente ao nome no CodePipeline Plugin para Jenkins. Em **Server URL (URL do servidor)**, digite o URL da instância do EC2 onde Jenkins está instalado. Em **Nome do projeto**, insira o nome do projeto que você criou no Jenkins, como{{MyDemoProject}}, e escolha **Avançar**.
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**, reutilize o CodeDeploy aplicativo e o grupo de implantação que você criou. [Tutorial: Criar um pipeline simples (bucket do S3)](tutorials-simple-s3.md) Em **Deploy provider (Fornecedor de implantação)**, escolha **CodeDeploy**. Em **Application name (Nome do aplicativo)**, insira **CodePipelineDemoApplication** ou selecione o botão de atualização e selecione o nome do aplicativo na lista. Em **Deployment group (Grupo de implantação)**, insira **CodePipelineDemoFleet** ou selecione-o na lista e selecione **Next (Próximo)**.
**nota**
Você pode usar seus próprios CodeDeploy recursos ou criar novos, mas poderá incorrer em custos adicionais.
1. Na **Etapa 7: Revisar**, revise as informações e escolha **Criar funil**.
1. O pipeline inicia automaticamente e executa a amostra através do pipeline. Você pode visualizar mensagens de progresso, sucesso e falha à medida que o pipeline cria a amostra de Haml em HTML e a implanta em uma página da web em cada uma das instâncias do Amazon EC2 na implantação. CodeDeploy
## Etapa 3: Adicionar outro estágio ao pipeline
Agora, você adicionará um estágio de teste e uma ação de teste a esse estágio que use o teste do Jenkins incluído na amostra para determinar se a página da web tem algum conteúdo. Esse teste é apenas para fins de demonstração.
**nota**
Se não quiser adicionar outro estágio ao pipeline, você poderá adicionar uma ação de teste ao estágio Preparação do pipeline, antes ou depois da ação de implantação.
### Adicionar um estágio de teste ao pipeline
**Topics**
+ [Procurar o endereço IP de uma instância](#tutorials-four-stage-pipeline-instance-ip-lookup)
+ [Criar um projeto do Jenkins para testar a implantação](#tutorials-four-stage-pipeline-create-jenkins-project)
+ [Criar um quarto estágio](#tutorials-four-stage-pipeline-create-fourth-stage)
#### Procurar o endereço IP de uma instância
**Para verificar o endereço IP de uma instância onde você implantou seu código**
1. Após a exibição do status **Bem-sucedido** para o pipeline, na área do status para o estágio Staging, selecione **Detalhes**.
1. Na seção **Detalhes da implantação**, em **ID da instância**, selecione a ID da instância de uma das instâncias implantadas com êxito.
1. Copie o endereço IP da instância (por exemplo,{{192.168.0.4}}). Você usará esse endereço IP em seu teste Jenkins.
#### Criar um projeto do Jenkins para testar a implantação
**Para criar o projeto Jenkins**
1. Na instância onde você instalou o Jenkins, abra Jenkins e, na página principal, selecione **Novo item**.
1. Em **Nome do item**, insira um nome para o projeto Jenkins (por exemplo,{{MyTestProject}}). Selecione **Projeto estilo livre** e depois **OK**.
**nota**
Certifique-se de que o nome do seu projeto atenda aos CodePipeline requisitos. Para obter mais informações, consulte [Cotas no AWS CodePipeline.](limits.md).
1. Na página de configuração do projeto, selecione a caixa de seleção **Executar construções simultâneas se necessário**. Em **Source Code Management (Gerenciamento de código-fonte)**, selecione **AWS CodePipeline**. Se você instalou o Jenkins em uma instância do EC2 e configurou o AWS CLI com o perfil do usuário do IAM que você criou para integração entre CodePipeline e o Jenkins, deixe todos os outros campos vazios.
**Importante**
Se você estiver configurando um projeto Jenkins e ele não estiver instalado em uma instância do Amazon EC2 ou estiver instalado em uma instância do EC2 que esteja executando um sistema operacional Windows, preencha os campos conforme exigido pelas configurações de porta e host proxy e forneça as credenciais do usuário ou função do IAM que você configurou para integração entre Jenkins e. CodePipeline
1. Selecione **Avançado** e, em **Categoria**, selecione **Testar**.
1. Em **Provedor**, insira o mesmo nome que você usou para o projeto de construção (por exemplo,{{MyJenkinsProviderName}}). Você usará esse nome quando adicionar a ação de teste ao seu pipeline mais adiante neste tutorial.
**nota**
Esse nome deve atender aos requisitos de CodePipeline nomenclatura das ações. Para obter mais informações, consulte [Cotas no AWS CodePipeline.](limits.md).
1. Em **Construir triggers**, desmarque todas as caixas de seleção e depois selecione **Apurar SCM**. Em **Schedule (Programação)**, insira cinco asteriscos separados por espaços, conforme a seguir:
```
* * * * *
```
Isso faz pesquisas a CodePipeline cada minuto.
1. Em **Construir**, selecione **Adicionar etapa da construção**. Se você estiver implantando em instâncias do Amazon Linux, do RHEL ou do Ubuntu Server, selecione **Executar shell**. Insira o seguinte, onde o endereço IP é o endereço da instância do EC2 que você copiou anteriormente:
```
TEST_IP_ADDRESS={{192.168.0.4}} rake test
```
Se você estiver implantando em instâncias do Windows Server, selecione **Executar comando em lote** e insira o seguinte, em que o endereço IP é o endereço da instância do EC2 que você copiou anteriormente:
```
set TEST_IP_ADDRESS={{192.168.0.4}} rake test
```
**nota**
O teste assume uma porta padrão de 80. Se você deseja especificar uma porta diferente, adicione uma instrução de porta de teste, conforme a seguir:
```
TEST_IP_ADDRESS={{192.168.0.4}} TEST_PORT={{8000}} rake test
```
1. Escolha **Adicionar ação pós-compilação** e, em seguida, escolha **AWS CodePipeline Publisher**. Não selecione **Adicionar**.
1. Selecione **Salvar** para salvar seu projeto Jenkins.
#### Criar um quarto estágio
**Para adicionar um estágio ao seu pipeline que inclui a ação de teste Jenkins**
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).
1. Em **Name (Nome)**, selecione o nome do pipeline que você criou, MySecondPipeline.
1. Na página de detalhes do pipeline, selecione **Editar**.
1. Na página **Edit (Editar)**, selecione **\+ Stage (Estágio)** para adicionar um estágio imediatamente após o estágio de compilação.
1. No campo de nome para o novo estágio, insira um nome (por exemplo, **Testing**) e escolha **\+ Add action group (\+ Adicionar grupo de ações)**.
1. Em **Nome da ação**, insira{{MyJenkinsTest-Action}}. Em **Provedor de teste**, escolha o nome do provedor que você especificou no Jenkins (por exemplo,{{MyJenkinsProviderName}}). Em **Nome do projeto**, insira o nome do projeto que você criou no Jenkins (por exemplo,{{MyTestProject}}). **Em **Artefatos de entrada**, escolha o artefato da compilação do Jenkins cujo nome padrão é e{{BuildArtifact}}, em seguida, escolha Concluído.**
**nota**
Como a ação de teste do Jenkins é executada no aplicativo criado na etapa de compilação do Jenkins, use o artefato de compilação para o artefato de entrada na ação de teste.
Para obter mais informações sobre artefatos de entrada e saída e a estrutura de pipelines, consulte [CodePipeline referência de estrutura de tubulação](reference-pipeline-structure.md).
1. Na página **Editar**, selecione **Salvar alterações do pipeline**. Na caixa de diálogo da opção **Salvar alterações do pipeline**, selecione **Salvar e continuar**.
1. Embora o novo estágio tenha sido adicionado ao seu pipeline, um status de **Ainda não executado** é exibido para o estágio, pois nenhuma alteração acionou outra execução do pipeline. Para executar a amostra por meio do pipeline revisado, na página de detalhes do pipeline, selecione **Lançar alteração**.
A visualização do pipeline exibe os estágios e ações em seu pipeline e o estado da revisão em execução através desses quatro estágios. O tempo necessário para que o pipeline seja executado por todos os estágios dependerá do tamanho dos artefatos, da complexidade de sua construção ações de teste, além de outros fatores.
## Etapa 4: Limpar os recursos
Após concluir este tutorial, você deverá excluir o pipeline e os recursos usados para não ser cobrado pelo uso contínuo desses recursos. Se você não pretende continuar usando CodePipeline, exclua o pipeline, depois o CodeDeploy aplicativo e suas instâncias associadas do Amazon EC2 e, finalmente, o bucket do Amazon S3 usado para armazenar artefatos. Você também deve considerar a possibilidade de excluir outros recursos, como o GitHub repositório, caso não pretenda continuar usando-os.
**Para limpar os recursos usados neste tutorial**
1. Abra uma sessão de terminal em sua máquina Linux, macOS ou Unix local ou um prompt de comando em sua máquina Windows local e execute o comando **delete-pipeline** para excluir o pipeline que você criou. Em **MySecondPipeline**, insira o seguinte comando:
```
aws codepipeline delete-pipeline --name "MySecondPipeline"
```
Esse comando não retorna nada.
1. Para limpar seus CodeDeploy recursos, siga as instruções em [Limpeza](https://docs.aws.amazon.com/codedeploy/latest/userguide/getting-started-walkthrough.html#getting-started-walkthrough-clean-up).
1. Para limpar os recursos de sua instância, exclua a instância do EC2 onde você instalou o Jenkins. Para obter mais informações, consulte [Limpeza da sua instância](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-clean-up-your-instance.html).
1. Se você não pretende criar mais pipelines ou usar CodePipeline novamente, exclua o bucket do Amazon S3 usado para armazenar artefatos para seu pipeline. Para excluir o bucket, siga as instruções em [Excluir um bucket](https://docs.aws.amazon.com/AmazonS3/latest/UG/DeletingaBucket.html).
1. Se você não pretende usar a outros recursos para esse pipeline novamente, considere excluí-los, seguindo as orientações para esse recurso específico. Por exemplo, se você quiser excluir o GitHub repositório, siga as instruções em [Excluindo um repositório no site](https://help.github.com/articles/deleting-a-repository/). GitHub