

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: crie um pipeline que crie e teste seu aplicativo Android com AWS Device Farm
<a name="tutorials-codebuild-devicefarm"></a>

Você pode usar AWS CodePipeline para configurar um fluxo de integração contínua no qual seu aplicativo é criado e testado sempre que uma confirmação é enviada. Este tutorial mostra como criar e configurar um pipeline para criar e testar seu aplicativo Android com o código-fonte em um GitHub repositório. O pipeline detecta a chegada de um novo GitHub commit e, em seguida, o usa [CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/welcome.html)para criar o aplicativo e o [Device Farm](https://docs.aws.amazon.com/devicefarm/latest/developerguide/welcome.html) para testá-lo.

**Importante**  
Como parte da criação de um pipeline no console, um bucket de artefatos S3 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.

**Importante**  
Muitas das ações que você adiciona 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).

Você pode experimentar isso usando seu aplicativo Android e as definições de teste existentes ou pode usar o [aplicativo de exemplo e as definições de teste fornecidas pelo Device Farm](https://github.com/aws-samples/aws-device-farm-sample-app-for-android).

**Antes de começar**

1. Entre no AWS Device Farm console e escolha **Criar um novo projeto**.

1. Selecione o projeto. No navegador, copie o URL do novo projeto. O URL contém o ID do projeto. 

1. Copie e retenha esse ID de projeto. Você pode usá-lo ao criar o pipeline no CodePipeline.

   Este é um exemplo de URL para um projeto. Para extrair o ID do projeto, copie o valor depois de `projects/`. Neste exemplo, o ID do produto é `eec4905f-98f8-40aa-9afc-4c1cfexample`.

   ```
   https://<region-URL>/devicefarm/home?region=us-west-2#/projects/eec4905f-98f8-40aa-9afc-4c1cfexample/runs
   ```

## Configure CodePipeline para usar seus testes do Device Farm
<a name="codepipeline-configure-tests"></a>

1. 

   Adicione e confirme um arquivo chamado [https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html](https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html)na raiz do código do seu aplicativo e envie-o para o seu repositório. CodeBuild usa esse arquivo para executar comandos e acessar os artefatos necessários para criar seu aplicativo.

   ```
   version: 0.2
   
   phases:
     build:
       commands:
         - chmod +x ./gradlew
         - ./gradlew assembleDebug
   artifacts:
     files:
        - './android/app/build/outputs/**/*.apk'
     discard-paths: yes
   ```

1. (Opcional) Se você [usa o Calabash ou o Appium para testar seu aplicativo](https://docs.aws.amazon.com/devicefarm/latest/developerguide/test-types-intro.html), adicione o arquivo de definição de teste ao seu repositório. Em uma etapa posterior, você pode configurar o Device Farm para usar as definições que executarão o pacote de teste. 

   Se você usar os testes integrados do Device Farm, poderá ignorar esta etapa.

1. Para criar seu pipeline e adicionar um estágio de origem, faça o seguinte:

   1. Faça login no Console de gerenciamento da AWS e 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 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 **Service role (Função de serviço)**, deixe **New service role (Nova função de serviço) ** selecionado e não altere **Role name (Nome da função)**. Você também pode optar por usar uma função de serviço existente se tiver criado uma.
**nota**  
Se você usa uma função CodePipeline de serviço criada antes de julho de 2018, precisa adicionar permissões para o Device Farm. Para fazer isso, abra o console do IAM, localize o perfil e, em seguida, adicione as seguintes permissões à política do perfil. Para obter mais informações, consulte [Adicionar permissões à função CodePipeline de serviço](how-to-custom-role.md#how-to-update-role-new-services).  

      ```
      {
           "Effect": "Allow",
           "Action": [
              "devicefarm:ListProjects",
              "devicefarm:ListDevicePools",
              "devicefarm:GetRun",
              "devicefarm:GetUpload",
              "devicefarm:CreateUpload",
              "devicefarm:ScheduleRun"
           ],
           "Resource": "*"
      }
      ```

   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 (via GitHub aplicativo)**.

   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 **Repository (Repositório)**, selecione o repositório de origem.

   1. Em **Branch (Ramificação)**, selecione a ramificação que você deseja usar.

   1. Deixe os padrões restantes para a ação de origem. Escolha **Próximo**.

1. Em **Etapa 4: Adicionar etapa de compilação**, adicione um estágio de compilação:

   1. Em **Provedor de compilação**, escolha **Outros fornecedores de compilação** e **AWS CodeBuild**. Permita que **Region (Região)** seja definida para a região do pipeline.

   1. Escolha **Criar projeto**.

   1. Em **Nome do projeto**, insira um nome para esse projeto de compilação.

   1. Em **Environment image (Imagem do ambiente)**, escolha **Managed image (Imagem gerenciada)**. Para **Operating system**, selecione **Ubuntu**.

   1. Em **Runtime (Tempo de execução)**, selecione **Standard (Padrão)**. **Para **Imagem**, escolha: 5.0aws/codebuild/standard.**

      CodeBuild usa essa imagem do sistema operacional, que tem o Android Studio instalado, para criar seu aplicativo.

   1. Em **Função de serviço**, escolha sua função CodeBuild de serviço existente ou crie uma nova.

   1. Para **Build specifications (Especificações da compilação)**, escolha **Use a buildspec file (Usar um arquivo buildspec)**.

   1. Escolha **Continuar para CodePipeline**. Isso retorna ao CodePipeline console e cria um CodeBuild projeto que usa o `buildspec.yml` em seu repositório para configuração. O projeto de criação usa um perfil de serviço para gerenciar permissões de AWS service (Serviço da AWS) . Essa etapa pode levar alguns minutos.

   1. Escolha **Próximo**.

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 página **Etapa 6: Adicionar estágio de implantação**, escolha **Ignorar estágio de implantação** e, em seguida, aceite a mensagem de aviso escolhendo **Ignorar** novamente. Escolha **Próximo**.

1. Na **Etapa 7: Revisão**, escolha **Criar funil**. Você deve ver um diagrama que mostra a origem e os estágios de compilação.

1. Adicione uma ação de teste do Device Farm ao pipeline:

   1. No canto superior direito, escolha **Edit (Editar)**.

   1. Na parte inferior do diagrama, escolha **\$1 Add stage (\$1 Adicionar estágio)**. Em **Nome do estágio**, insira um nome, como **Test**.

   1. Escolha **\$1 Add action group (Adicionar grupo de ação)**.

   1. Em **Nome da ação**, insira um nome. 

   1. Em **Provedor de ação**, selecione **AWS Device Farm**. Permita que **Region (Região)** seja definida para a região do pipeline.

   1. Em **Input artifacts (Artefatos de entrada)**, selecione o artefato de entrada que corresponde ao artefato de saída do estágio que vem antes do estágio de teste, como `BuildArtifact`. 

      No AWS CodePipeline console, você pode encontrar o nome do artefato de saída para cada estágio passando o mouse sobre o ícone de informações no diagrama do pipeline. Se seu pipeline testar seu aplicativo diretamente do estágio de **origem**, escolha **SourceArtifact**. Se o pipeline incluir um estágio de **construção**, escolha **BuildArtifact**.

   1. Em **ProjectId**, insira o ID do projeto do Device Farm. Use as etapas no início deste tutorial para recuperar o ID do projeto.

   1. Em **DevicePoolArn**, insira o ARN do pool de dispositivos. Para obter o pool de dispositivos disponível ARNs para o projeto, incluindo o ARN dos principais dispositivos, use a AWS CLI para inserir o seguinte comando: 

      ```
      aws devicefarm list-device-pools --arn arn:aws:devicefarm:us-west-2:account_ID:project:project_ID
      ```

   1. Em **AppType**, insira **Android**.

      Veja a seguir uma lista de valores válidos para **AppType**:
      + **iOS**
      + **Android**
      + **Web**

   1. Em **App (Aplicativo)**, insira o caminho do pacote do aplicativo compilado. O caminho é relativo à raiz do artefato de entrada do estágio de teste. Normalmente, esse caminho é semelhante a `app-release.apk`.

   1. Em **TestType**, insira seu tipo de teste e, em **Teste**, insira o caminho do arquivo de definição do teste. O caminho é relativo à raiz do artefato de entrada para o teste.

      Veja a seguir uma lista de valores válidos para **TestType**:
      + **APPIUM\$1JAVA\$1JUNIT**
      + **APPIUM\$1JAVA\$1TESTING**
      + **APPIUM\$1NODE**
      + **APPIUM\$1RUBY**
      + **APPIUM\$1PYTHON**
      + **APPIUM\$1WEB\$1JAVA\$1JUNIT**
      + **APPIUM\$1WEB\$1JAVA\$1TESTING**
      + **APPIUM\$1WEB\$1NODE**
      + **APPIUM\$1WEB\$1RUBY**
      + **APPIUM\$1WEB\$1PYTHON**
      + **BUILTIN\$1FUZZ**
      + **INSTRUMENTATION**
      + **XCTEST**
      + **XCTEST\$1UI**
**nota**  
Os nós de ambiente personalizados não são compatíveis.

   1. Nos campos restantes, forneça a configuração que seja apropriada para seu teste e tipo de aplicativo.

   1. (Opcional) Em **Advanced (Avançado)**, forneça informações de configuração para a execução do teste.

   1. Escolha **Salvar**.

   1. No estágio que está editando, escolha **Done (Concluído)**. No painel do AWS CodePipeline , escolha **Save (Salvar)** e selecione **Save (Salvar)** na mensagem de aviso.

   1. Para enviar suas alterações e iniciar uma compilação do pipeline, selecione **Liberar alteração** e, depois, **Liberar**.