

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

# Executadores de GitHub ações auto-hospedados em AWS CodeBuild
<a name="action-runner-overview"></a>

Você pode configurar seu projeto para configurar executores de GitHub ações auto-hospedados em CodeBuild contêineres para processar seus trabalhos de fluxo de trabalho do GitHub Actions. Isso pode ser feito configurando um webhook usando seu CodeBuild projeto e atualizando seu fluxo de trabalho de GitHub ações YAML para usar executores auto-hospedados hospedados em máquinas. CodeBuild 

As etapas de alto nível para configurar um CodeBuild projeto para executar trabalhos de GitHub ações são as seguintes:

1. Se você ainda não tiver feito isso, crie um token de acesso pessoal ou conecte-se a um OAuth aplicativo ao qual conectar seu projeto GitHub.

1. Navegue até o CodeBuild console, crie um CodeBuild projeto com um webhook e configure seus filtros de webhook.

1. Atualize seu fluxo de trabalho de GitHub ações YAML GitHub para configurar seu ambiente de compilação.

Para obter um procedimento mais detalhado, consulte [Tutorial: Configurar um CodeBuild executor de GitHub ações hospedado](action-runner.md).

Esse recurso permite que seus trabalhos de fluxo de trabalho do GitHub Actions obtenham integração nativa AWS, o que fornece segurança e conveniência por meio de recursos como IAM AWS CloudTrail, AWS Secrets Manager integração e Amazon VPC. Você pode acessar os tipos de instância mais recentes, incluindo instâncias baseadas em ARM.

**Topics**
+ [Sobre o executor CodeBuild de GitHub ações hospedado](action-runner-questions.md)
+ [Tutorial: Configurar um CodeBuild executor de GitHub ações hospedado](action-runner.md)
+ [Solucionar problemas do webhook](action-runner-troubleshoot-webhook.md)
+ [Substituições de rótulos suportadas pelo executor de ações CodeBuild hospedado GitHub](sample-github-action-runners-update-labels.md)
+ [Imagens de computação compatíveis com o executor CodeBuild de ações hospedado GitHub](sample-github-action-runners-update-yaml.images.md)

# Sobre o executor CodeBuild de GitHub ações hospedado
<a name="action-runner-questions"></a>

A seguir estão algumas perguntas comuns sobre o executor CodeBuild de GitHub ações hospedado.

## Quando devo incluir as substituições de imagem e instância no rótulo?
<a name="action-runner-image-label"></a>

Você pode incluir as substituições de imagem e instância no rótulo para especificar um ambiente de criação diferente para cada um dos trabalhos do fluxo de trabalho do GitHub Actions. Isso pode ser feito sem a necessidade de criar vários CodeBuild projetos ou webhooks. Por exemplo, isso é útil quando você precisa usar uma [matriz para os trabalhos de fluxo de trabalho](https://docs.github.com/en/actions/using-jobs/using-a-matrix-for-your-jobs).

```
name: Hello World
on: [push]
jobs:
  Hello-World-Job:
    runs-on:
      - codebuild-myProject-${{ github.run_id }}-${{ github.run_attempt }}
        image:${{ matrix.os }}
        instance-size:${{ matrix.size }}
    strategy:
      matrix:
        include:
          - os: arm-3.0
            size: small
          - os: linux-5.0
            size: large
    steps:
      - run: echo "Hello World!"
```

**nota**  
As aspas podem ser necessárias se houver `runs-on` vários rótulos contendo o contexto de GitHub ações.

## Posso usar CloudFormation esse recurso?
<a name="action-runner-cfn"></a>

Sim, você pode incluir um grupo de filtros em seu CloudFormation modelo que especifica um filtro de eventos de trabalho do fluxo de trabalho do GitHub Actions no webhook do seu projeto.

```
Triggers:
  Webhook: true
  FilterGroups:
    - - Type: EVENT
        Pattern: WORKFLOW_JOB_QUEUED
```

Para obter mais informações, consulte [Filtrar eventos de GitHub webhook ()CloudFormation](github-webhook-events-cfn.md).

Se precisar de ajuda para configurar as credenciais do projeto em seu CloudFormation modelo, consulte [AWS::CodeBuild::SourceCredential](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codebuild-sourcecredential.html)o *Guia do AWS CloudFormation usuário* para obter mais informações.

## Como posso mascarar segredos ao usar esse recurso?
<a name="action-runner-secrets"></a>

Por padrão, os segredos impressos no log não são mascarados. Se você quiser mascarar os segredos, poderá usar a seguinte sintaxe: `::add-mask::value`. Veja abaixo um exemplo de como você pode usar essa sintaxe no YAML:

```
name: Secret Job
on: [push]
jobs:
  Secret-Job:
    runs-on: codebuild-myProject-${{ github.run_id }}-${{ github.run_attempt }}
    env:
      SECRET_NAME: "secret-name"
    steps:
      - run: echo "::add-mask::$SECRET_NAME"
```

Para obter mais informações, consulte [Mascarar um valor em um logon](https://docs.github.com/en/actions/using-workflows/workflow-commands-for-github-actions#masking-a-value-in-a-log) GitHub.

## Posso receber eventos de webhook do GitHub Actions de vários repositórios em um único projeto?
<a name="action-runner-webhooks"></a>

CodeBuild oferece suporte a webhooks de nível organizacional e global, que recebem eventos de uma organização ou empresa específica. Para obter mais informações, consulte [GitHub webhooks globais e organizacionais](github-global-organization-webhook.md).

## Quais regiões oferecem suporte ao uso de um executor CodeBuild de GitHub ações hospedado?
<a name="action-runner-hosted-regions"></a>

CodeBuildOs executores de GitHub ações hospedados são suportados em todas as CodeBuild regiões. Para obter mais informações sobre Regiões da AWS onde CodeBuild está disponível, consulte [AWS Serviços por região](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/).

## Quais plataformas oferecem suporte ao uso de um executor CodeBuild de GitHub ações hospedado?
<a name="action-runner-platform"></a>

CodeBuildexecutores de GitHub ações hospedados são compatíveis tanto com o Amazon [AWS Lambda](lambda.md)EC2 quanto com a computação. É possível usar as seguintes plataformas: Amazon Linux 2, Amazon Linux 2023, Ubuntu e Windows Server Core 2019. Para obter mais informações, consulte [Imagens de computação do EC2](ec2-compute-images.md) e [Imagens de computação do Lambda](lambda-compute-images.md).

# Tutorial: Configurar um CodeBuild executor de GitHub ações hospedado
<a name="action-runner"></a>

Este tutorial mostra como configurar seus CodeBuild projetos para executar trabalhos do GitHub Actions. Para obter mais informações sobre o uso de GitHub ações com, CodeBuild consulte[Tutorial: Configurar um CodeBuild executor de GitHub ações hospedado](#action-runner).<a name="sample-github-action-runners-prerequisites"></a>

Para concluir este tutorial, você deve primeiramente:
+ Conecte-se com um token de acesso pessoal, um segredo, OAuth aplicativo ou GitHub aplicativo do Secrets Manager. Se quiser se conectar a um OAuth aplicativo, você deve usar o CodeBuild console para fazer isso. Se quiser criar um token de acesso pessoal, você pode usar o CodeBuild console ou usar a [ImportSourceCredentials API](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_ImportSourceCredentials.html). Para obter mais instruções, consulte [GitHub e acesso ao GitHub Enterprise Server em CodeBuild](access-tokens-github-overview.md).
+ Conecte-se CodeBuild à sua GitHub conta. Para fazer isso, é possível utilizar uma das seguintes opções:
  + Você pode adicionar GitHub como provedor de origem no console. Você pode se conectar com um token de acesso pessoal, um segredo do Secrets Manager, OAuth aplicativo ou GitHub aplicativo. Para instruções, consulte [GitHub e acesso ao GitHub Enterprise Server em CodeBuild](access-tokens-github-overview.md).
  + Você pode importar suas GitHub credenciais por meio da [ImportSourceCredentials API](https://docs.aws.amazon.com/cli/latest/reference/codebuild/import-source-credentials.html). Isso só pode ser feito com um token de acesso pessoal. Se você se conectar usando um OAuth aplicativo, deverá se conectar usando o console em vez disso. Para instruções, consulte [Conecte-se GitHub com um token de acesso (CLI)](access-tokens-github.md#access-tokens-github-cli).
**nota**  
Isso só precisa ser feito se você não estiver conectado GitHub à sua conta.

## Etapa 1: criar um CodeBuild projeto com um webhook
<a name="sample-github-action-runners-create-project"></a>

Nesta etapa, você criará um CodeBuild projeto com um webhook e o revisará no GitHub console. Você também pode escolher GitHub Enterprise como seu provedor de origem. Para saber mais sobre a criação de um webhook no GitHub Enterprise, consulte[GitHub webhooks manuais](github-manual-webhook.md).

**Para criar um CodeBuild projeto com um webhook**

1. Abra o AWS CodeBuild console em [https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home).

1. Crie um projeto de compilação. Para obter informações, consulte [Criar um projeto de compilação (console)](create-project.md#create-project-console) e [Executar uma compilação (console)](run-build-console.md).

1. Em **Tipo de projeto**, escolha **Projeto de executor**.

   Em **Executor:**

   1. Para **provedor Runner**, escolha **GitHub**.

   1. Em **Localização do executor**, escolha **Repositório**.

   1. **Para URL do repositório em Repositório, escolha **https://github.com/user-name/nome do repositório**.**
**nota**  
Por padrão, o projeto só receberá eventos `WORKFLOW_JOB_QUEUED` para um único repositório. Para receber eventos de todos os repositórios dentro de uma organização ou empresa, consulte [GitHub webhooks globais e organizacionais](github-global-organization-webhook.md).

1. 
   +  Em **Ambiente**: 
     + Escolha uma **imagem de ambiente** e **computação** compatíveis. Observe que você tem a opção de substituir as configurações de imagem e instância usando um rótulo no seu fluxo de trabalho de GitHub ações YAML. Para obter mais informações, consulte [Etapa 2: atualizar seu fluxo de trabalho de GitHub ações YAML](#sample-github-action-runners-update-yaml).
   +  Em **Buildspec**: 
     + Observe que o buildspec será ignorado, a menos que `buildspec-override:true` seja adicionado como rótulo. Em vez disso, o CodeBuild substituirá para usar comandos que configurarão o executor auto-hospedado.

1. Continue com os valores padrão e escolha **Criar projeto de compilação**.

1. Abra o GitHub console em `https://github.com/user-name/repository-name/settings/hooks` para verificar se um webhook foi criado e está habilitado para fornecer eventos de **trabalhos do Workflow**.

## Etapa 2: atualizar seu fluxo de trabalho de GitHub ações YAML
<a name="sample-github-action-runners-update-yaml"></a>

Nesta etapa, você atualizará o arquivo YAML do fluxo de trabalho do GitHub Actions [https://github.com/](https://github.com/)para configurar seu ambiente de compilação e usar os executores auto-hospedados do GitHub Actions em. CodeBuild Para obter mais informações, consulte [Usar rótulos com executores auto-hospedados](https://docs.github.com/en/actions/hosting-your-own-runners/managing-self-hosted-runners/using-labels-with-self-hosted-runners) e [Substituições de rótulos suportadas pelo executor de ações CodeBuild hospedado GitHub](sample-github-action-runners-update-labels.md).

### Atualize seu fluxo de trabalho de GitHub ações (YAML)
<a name="sample-github-action-runners-update-yaml.setup"></a>

Navegue até [https://github.com/](https://github.com/)e atualize a [https://docs.github.com/en/actions/hosting-your-own-runners/managing-self-hosted-runners/using-labels-with-self-hosted-runners](https://docs.github.com/en/actions/hosting-your-own-runners/managing-self-hosted-runners/using-labels-with-self-hosted-runners)configuração em seu fluxo de trabalho de GitHub ações YAML para configurar seu ambiente de compilação. Para fazer isso, é possível utilizar uma das seguintes opções:
+ Você pode especificar o nome do projeto e o ID da execução. Nesse caso, a compilação usará a configuração do projeto existente para computação, imagem, versão da imagem e tamanho da instância. O nome do projeto é necessário para vincular as configurações AWS relacionadas do seu trabalho de GitHub ações a um CodeBuild projeto específico. Ao incluir o nome do projeto no YAML, CodeBuild é permitido invocar trabalhos com as configurações corretas do projeto. Ao fornecer o ID de execução, CodeBuild mapeará sua compilação para execuções de fluxo de trabalho específicas e interromperá a compilação quando a execução do fluxo de trabalho for cancelada. Para obter mais informações, consulte o [contexto do `github`](https://docs.github.com/en/actions/learn-github-actions/contexts#github-context).

  ```
  runs-on: codebuild-<project-name>-${{ github.run_id }}-${{ github.run_attempt }}
  ```
**nota**  
Certifique-se de que seu nome *<project-name>* corresponda ao nome do projeto que você criou na etapa anterior. Se não corresponder, não CodeBuild processará o webhook e o fluxo de trabalho de GitHub ações poderá travar.

  Veja a seguir um exemplo de um fluxo de trabalho de GitHub ações YAML:

  ```
  name: Hello World
  on: [push]
  jobs:
    Hello-World-Job:
      runs-on:
        - codebuild-myProject-${{ github.run_id }}-${{ github.run_attempt }}
      steps:
        - run: echo "Hello World!"
  ```
+ Você também pode substituir a imagem e o tipo de computação no rótulo. Consulte uma lista de imagens selecionadas em [Imagens de computação compatíveis com o executor CodeBuild de ações hospedado GitHub](sample-github-action-runners-update-yaml.images.md). Para usar imagens personalizadas, consulte [Substituições de rótulos suportadas pelo executor de ações CodeBuild hospedado GitHub](sample-github-action-runners-update-labels.md). O tipo de computação e a imagem no rótulo substituirão as configurações do ambiente no projeto. Para substituir suas configurações de ambiente para uma compilação de computação CodeBuild EC2 ou Lambda, use a seguinte sintaxe:

  ```
  runs-on:
    - codebuild-<project-name>-${{ github.run_id }}-${{ github.run_attempt }}
      image:<environment-type>-<image-identifier>
      instance-size:<instance-size>
  ```

  Veja a seguir um exemplo de um fluxo de trabalho de GitHub ações YAML:

  ```
  name: Hello World
  on: [push]
  jobs:
    Hello-World-Job:
      runs-on:
        - codebuild-myProject-${{ github.run_id }}-${{ github.run_attempt }}
          image:arm-3.0
          instance-size:small
      steps:
        - run: echo "Hello World!"
  ```
+ Você pode substituir a frota usada para a compilação no rótulo. Isso substituirá as configurações de frota definidas no projeto para usar a frota especificada. Para obter mais informações, consulte [Executar compilações em frotas de capacidade reservada](fleets.md). Para substituir as configurações da frota para uma compilação computacional do Amazon EC2, use a seguinte sintaxe:

  ```
  runs-on:
    - codebuild-<project-name>-${{ github.run_id }}-${{ github.run_attempt }}
      fleet:<fleet-name>
  ```

  Para substituir a frota e a imagem usadas para a compilação, use a seguinte sintaxe:

  ```
  runs-on:
    - codebuild-<project-name>-${{ github.run_id }}-${{ github.run_attempt }}
      fleet:<fleet-name>
      image:<environment-type>-<image-identifier>
  ```

  Veja a seguir um exemplo de um fluxo de trabalho de GitHub ações YAML:

  ```
  name: Hello World
  on: [push]
  jobs:
    Hello-World-Job:
      runs-on:
        - codebuild-myProject-${{ github.run_id }}-${{ github.run_attempt }}
          fleet:myFleet
          image:arm-3.0
      steps:
        - run: echo "Hello World!"
  ```
+ Para executar seus trabalhos de GitHub ações em uma imagem personalizada, você pode configurar uma imagem personalizada em seu CodeBuild projeto e evitar fornecer um rótulo de substituição de imagem. CodeBuild usará a imagem configurada no projeto se nenhum rótulo de substituição de imagem for fornecido.
+ Opcionalmente, você pode fornecer rótulos fora dos CodeBuild compatíveis. Esses rótulos serão ignorados com o objetivo de substituir os atributos da compilação, mas não falharão na solicitação do webhook. Por exemplo, adicionar `testLabel` como rótulo não impedirá a execução da compilação.

**nota**  
Se uma dependência fornecida por GitHub -hosted runners não estiver disponível no CodeBuild ambiente, você poderá instalar a dependência usando GitHub Ações na execução do fluxo de trabalho. Por exemplo, você pode usar a ação [https://github.com/actions/setup-python](https://github.com/actions/setup-python) para instalar o Python no ambiente de compilação.

### Execute os comandos buildspec nas fases INSTALL, PRE\$1BUILD e POST\$1BUILD
<a name="sample-github-action-runners-update-yaml.buildspec"></a>

Por padrão, CodeBuild ignora qualquer comando buildspec ao executar uma compilação de ações auto-hospedada. GitHub Para executar comandos buildspec durante a compilação, `buildspec-override:true` pode ser adicionado como sufixo ao rótulo:

```
runs-on:
  - codebuild-<project-name>-${{ github.run_id }}-${{ github.run_attempt }}
    buildspec-override:true
```

Ao usar esse comando, CodeBuild criará uma pasta chamada `actions-runner` na pasta de origem primária do contêiner. Quando o executor de GitHub ações for iniciado durante a `BUILD` fase, o executor será executado no `actions-runner` diretório.

Há várias limitações ao usar uma substituição de buildspec em uma compilação de ações auto-hospedada: GitHub 
+ CodeBuild não executará comandos buildspec durante a `BUILD` fase, pois o executor auto-hospedado é executado na fase. `BUILD`
+ CodeBuild não baixará nenhuma fonte primária ou secundária durante a `DOWNLOAD_SOURCE` fase. Se você tiver um arquivo buildspec configurado, somente esse arquivo será baixado da fonte primária do projeto.
+ Se um comando de compilação falhar na `INSTALL` fase `PRE_BUILD` ou, o executor auto-hospedado não CodeBuild será iniciado e o trabalho do fluxo de trabalho de GitHub ações precisará ser cancelado manualmente.
+ CodeBuild busca o token do executor durante a `DOWNLOAD_SOURCE` fase, que tem um tempo de expiração de uma hora. Se suas `INSTALL` fases `PRE_BUILD` ou fases excederem uma hora, o token do corredor poderá expirar antes do início do corredor GitHub auto-hospedado.

## Etapa 3: revisar os resultados
<a name="sample-github-action-runners-verify"></a>

Sempre que ocorre a execução de um fluxo de trabalho do GitHub Actions, CodeBuild receberia os eventos do trabalho do fluxo de trabalho por meio do webhook. Para cada trabalho no fluxo de trabalho, CodeBuild inicia uma compilação para executar um executor de ações efêmero GitHub . O executor é responsável por executar um único trabalho de fluxo de trabalho. Depois que o trabalho for concluído, o executor e o processo de compilação associado serão encerrados imediatamente.

Para visualizar os registros de trabalhos do seu fluxo de trabalho, navegue até seu repositório GitHub, escolha **Ações**, escolha o fluxo de trabalho desejado e, em seguida, escolha o **trabalho** específico do qual você gostaria de revisar os registros.

Você pode revisar os rótulos solicitados no registro enquanto o trabalho está esperando para ser realizado por um executor auto-hospedado. CodeBuild

![\[Carregando o log do trabalho.\]](http://docs.aws.amazon.com/pt_br/codebuild/latest/userguide/images/hello-world-loading.png)


Depois que o trabalho for concluído, você poderá visualizar o log do trabalho.

![\[O log do trabalho.\]](http://docs.aws.amazon.com/pt_br/codebuild/latest/userguide/images/hello-world-log.png)


## GitHub Opções de configuração do executor de ações
<a name="sample-github-action-runners-config"></a>

É possível especificar as seguintes variáveis de ambiente na configuração do projeto para modificar a configuração dos executores auto-hospedados.

`CODEBUILD_CONFIG_GITHUB_ACTIONS_ORG_REGISTRATION_NAME`  
CodeBuild registrará executores auto-hospedados no nome da organização especificado como o valor dessa variável de ambiente. Para obter mais informações sobre o registro de corredores no nível da organização e as permissões necessárias, consulte [Criar configuração para um just-in-time corredor de uma](https://docs.github.com/en/rest/actions/self-hosted-runners?apiVersion=2022-11-28#create-configuration-for-a-just-in-time-runner-for-an-organization) organização.

`CODEBUILD_CONFIG_GITHUB_ACTIONS_ENTERPRISE_REGISTRATION_NAME`  
CodeBuild registrará executores auto-hospedados no nome da empresa especificado como o valor dessa variável de ambiente. Para obter mais informações sobre o registro de executores no nível corporativo e as permissões necessárias, consulte [Criar configuração para um just-in-time executor para uma](https://docs.github.com/en/enterprise-server/rest/actions/self-hosted-runners?apiVersion=2022-11-28#create-configuration-for-a-just-in-time-runner-for-an-enterprise) empresa.  
Os executores corporativos não estão disponíveis para os repositórios da organização por padrão. Para que executores auto-hospedados realizem trabalhos de fluxo de trabalho, talvez seja necessário definir as configurações de acesso ao grupo de executores. Consulte mais informações em [Making enterprise runners available to repositories](https://docs.github.com/en/enterprise-server/actions/hosting-your-own-runners/managing-self-hosted-runners/adding-self-hosted-runners#making-enterprise-runners-available-to-repositories).

`CODEBUILD_CONFIG_GITHUB_ACTIONS_RUNNER_GROUP_ID`  
CodeBuild registrará os executores auto-hospedados no ID inteiro do grupo de executores armazenado como o valor dessa variável de ambiente. Por padrão, esse valor é 1. Consulte mais informações sobre grupos de executores auto-hospedados em [Managing access to self-hosted runners using groups](https://docs.github.com/en/rest/actions/self-hosted-runners?apiVersion=2022-11-28#create-configuration-for-a-just-in-time-runner-for-an-organization).

`CODEBUILD_CONFIG_GITHUB_ACTIONS_ORG_REGISTRATION_NAME`  
Para configurar o registro de executores no nível da organização usando o arquivo YAML do fluxo de trabalho do GitHub Actions, você pode usar a seguinte sintaxe:  

```
name: Hello World
on: [push]
jobs:
  Hello-World-Job:
    runs-on:
      - codebuild-myProject-${{ github.run_id }}-${{ github.run_attempt }}
        organization-registration-name:myOrganization
    steps:
      - run: echo "Hello World!"
```

`CODEBUILD_CONFIG_GITHUB_ACTIONS_ENTERPRISE_REGISTRATION_NAME`  
Para configurar o registro de executores de nível corporativo usando o arquivo YAML do fluxo de trabalho do GitHub Actions, você pode usar a seguinte sintaxe:  

```
name: Hello World
on: [push]
jobs:
  Hello-World-Job:
    runs-on:
      - codebuild-myProject-${{ github.run_id }}-${{ github.run_attempt }}
        enterprise-registration-name:myEnterprise
    steps:
      - run: echo "Hello World!"
```

`CODEBUILD_CONFIG_GITHUB_ACTIONS_RUNNER_GROUP_ID`  
Para configurar o registro de executores em um ID de grupo de executores específico usando o arquivo YAML do fluxo de trabalho do GitHub Actions, você pode usar a seguinte sintaxe:  

```
name: Hello World
on: [push]
jobs:
  Hello-World-Job:
    runs-on:
      - codebuild-myProject-${{ github.run_id }}-${{ github.run_attempt }}
        registration-group-id:3
    steps:
      - run: echo "Hello World!"
```

## Filtrar eventos de webhook de GitHub ações ()CloudFormation
<a name="sample-github-action-runners-webhooks-cfn"></a>

A seguinte parte formatada em YAML de um modelo do CloudFormation cria um grupo de filtros que aciona uma compilação quando ela é avaliada como verdadeira. O grupo de filtros a seguir especifica uma solicitação de trabalho do fluxo de trabalho do GitHub Actions com um nome de fluxo de trabalho correspondente à expressão `\[CI-CodeBuild\]` regular.

```
CodeBuildProject:
  Type: AWS::CodeBuild::Project
  Properties:
    Name: MyProject
    ServiceRole: service-role
    Artifacts:
      Type: NO_ARTIFACTS
    Environment:
      Type: LINUX_CONTAINER
      ComputeType: BUILD_GENERAL1_SMALL
      Image: aws/codebuild/standard:5.0
    Source:
      Type: GITHUB
      Location: CODEBUILD_DEFAULT_WEBHOOK_SOURCE_LOCATION
    Triggers:
      Webhook: true
      ScopeConfiguration:
        Name: organization-name
        Scope: GITHUB_ORGANIZATION
      FilterGroups:
        - - Type: EVENT
            Pattern: WORKFLOW_JOB_QUEUED
          - Type: WORKFLOW_NAME
            Pattern: \[CI-CodeBuild\]
```

## Filtrar eventos de webhook de GitHub ações ()AWS CDK
<a name="sample-github-action-runners-webhooks-cdk"></a>

O AWS CDK modelo a seguir cria um grupo de filtros que aciona uma compilação quando ela é avaliada como verdadeira. O grupo de filtros a seguir especifica uma solicitação de trabalho do fluxo de trabalho do GitHub Actions.

```
import { aws_codebuild as codebuild } from 'aws-cdk-lib';
import {EventAction, FilterGroup} from "aws-cdk-lib/aws-codebuild";

const source = codebuild.Source.gitHub({
      owner: 'owner',
      repo: 'repo',
      webhook: true,
      webhookFilters: [FilterGroup.inEventOf(EventAction.WORKFLOW_JOB_QUEUED)],
    })
```

## Filtrar eventos de webhook de GitHub ações (Terraform)
<a name="sample-github-action-runners-webhooks-terraform"></a>

O modelo do Terraform a seguir cria um grupo de filtros que aciona uma compilação quando ela é avaliada como verdadeira. O grupo de filtros a seguir especifica uma solicitação de trabalho do fluxo de trabalho do GitHub Actions.

```
resource "aws_codebuild_webhook" "example" {
  project_name = aws_codebuild_project.example.name
  build_type   = "BUILD"
  filter_group {
    filter {
      type    = "EVENT"
      pattern = "WORKFLOW_JOB_QUEUED"
    }
  }
}
```

## Filtrar eventos de webhook de GitHub ações ()AWS CLI
<a name="sample-github-action-runners-webhooks-cli"></a>

Os AWS CLI comandos a seguir criam um projeto de execução de GitHub ações auto-hospedado com um grupo de filtros de solicitação de trabalho do fluxo de trabalho do GitHub Actions que aciona uma compilação quando é avaliada como verdadeira.

```
aws codebuild create-project \
--name <project name> \
--source "{\"type\":\"GITHUB\",\"location\":\"<repository location>\",\"buildspec\":\"\"}" \
--artifacts {"\"type\":\"NO_ARTIFACTS\""} \
--environment "{\"type\": \"LINUX_CONTAINER\",\"image\": \"aws/codebuild/amazonlinux-x86_64-standard:5.0\",\"computeType\": \"BUILD_GENERAL1_MEDIUM\"}" \
--service-role "<service role ARN>"
```

```
aws codebuild create-webhook \
--project-name <project name> \
--filter-groups "[[{\"type\":\"EVENT\",\"pattern\":\"WORKFLOW_JOB_QUEUED\"}]]"
```

# Solucionar problemas do webhook
<a name="action-runner-troubleshoot-webhook"></a>

**Problema:** o webhook que você configurou [Tutorial: Configurar um CodeBuild executor de GitHub ações hospedado](action-runner.md) não está funcionando ou seu trabalho de fluxo de trabalho está pendente. GitHub

**Causas possíveis:**
+ O evento de **Trabalhos de fluxo de trabalho** do webhook pode não estar conseguindo acionar uma compilação. Revise os logs de **Resposta** para ver a resposta ou a mensagem de erro.
+ Os trabalhos estão sendo atribuídos ao agente de executor incorreto devido à configuração do rótulo. Esse problema pode ocorrer quando um de seus trabalhos em uma única execução de fluxo de trabalho tem menos rótulos do que outro trabalho. Por exemplo, se você tiver dois trabalhos com os seguintes rótulos no mesmo fluxo de trabalho, execute:
  + **Trabalho 1**: `codebuild-myProject-${{ github.run_id }}-${{ github.run_attempt }}`
  + **Trabalho 2**: `codebuild-myProject-${{ github.run_id }}-${{ github.run_attempt }}`, `instance-size:medium`

  Ao rotear um trabalho de GitHub ações auto-hospedado, GitHub roteará o trabalho para qualquer executor com todos os rótulos especificados do trabalho. Esse comportamento significa que o **Trabalho 1** pode ser escolhido pelo executor criado para o **Trabalho 1** ou o **Trabalho 2**, mas o **Trabalho 2** só pode ser escolhido pelo executor criado para o **Trabalho 2**, pois tem um rótulo adicional. Se o **Trabalho 1** for escolhido pelo executor criado para o **Trabalho 2**, o **Trabalho 2** ficará travado, pois o executor do **Trabalho 1** não tem o rótulo `instance-size:medium`.

**Soluções recomendadas:**

Ao criar vários trabalhos na mesma execução do fluxo de trabalho, use o mesmo número de substituições de rótulo para cada trabalho ou atribua a cada trabalho um rótulo personalizado, como `job1` ou `job2`.

Se o erro persistir, use as instruções a seguir para depurar o problema.

1. Abra o GitHub console em `https://github.com/user-name/repository-name/settings/hooks` para ver as configurações do webhook do seu repositório. Nesta página, você verá o webhook que foi criado para o repositório.

1. Escolha **Edit** e confirme se o webhook está habilitado para fornecer eventos de **trabalhos de fluxo de trabalho.**  
![\[Os eventos de trabalho de fluxo de trabalho estão habilitados no webhook.\]](http://docs.aws.amazon.com/pt_br/codebuild/latest/userguide/images/github-actions-workflow-jobs.png)

1.  Navegue até a guia **Recent Deliveries**, encontre o evento `workflow_job.queued` correspondente e expanda o evento. 

1.  Revise o campo de **rótulos** na **Payload** e verifique se está conforme o esperado. 

1.  Por fim, revise a guia **Resposta**, pois ela contém a resposta ou a mensagem de erro retornada de CodeBuild.   
![\[A resposta ou mensagem de erro retornada de CodeBuild.\]](http://docs.aws.amazon.com/pt_br/codebuild/latest/userguide/images/github-actions-workflow-jobs-response.png)

1.  Como alternativa, você pode depurar falhas de webhook usando GitHub's. APIs Você pode ver as entregas recentes de um webhook usando a API [Listar entregas para um webhook de repositório](https://docs.github.com/en/rest/repos/webhooks?apiVersion=2022-11-28#list-deliveries-for-a-repository-webhook): 

   ```
   gh api \
     -H "Accept: application/vnd.github+json" \
     -H "X-GitHub-Api-Version: 2022-11-28" \
     /repos/owner/repo/hooks/hook-id/deliveries
   ```

    Depois de encontrar a entrega do webhook que você deseja depurar e anotar o ID de entrega, você pode usar a API [Get a delivery for a repository](https://docs.github.com/en/rest/repos/webhooks?apiVersion=2022-11-28#get-a-delivery-for-a-repository-webhook) webhook. CodeBuildA resposta da à carga útil de entrega do webhook pode ser encontrada na `response` seção: 

   ```
   gh api \
     -H "Accept: application/vnd.github+json" \
     -H "X-GitHub-Api-Version: 2022-11-28" \
     /repos/owner/repo/hooks/hook-id/deliveries/delivery-id
   ```

**Problema:** suas GitHub ações com as regras de [proteção de implantação](https://docs.github.com/en/actions/managing-workflow-runs-and-deployments/managing-deployments/reviewing-deployments) ativadas são criadas CodeBuild antes da aprovação da implantação.

**Causas possíveis:** CodeBuild busca a implantação e o ambiente associados à tarefa GitHub Actions, se existirem, para verificar se ela foi aprovada. Se CodeBuild não conseguir obter a implantação ou o ambiente, a CodeBuild compilação poderá ser acionada prematuramente.

**Soluções recomendadas:** verifique se as credenciais associadas aos seus CodeBuild projetos têm permissões de leitura para implantações e ações internas. GitHub

# Substituições de rótulos suportadas pelo executor de ações CodeBuild hospedado GitHub
<a name="sample-github-action-runners-update-labels"></a>

Em seu fluxo de trabalho de GitHub ações YAML, você pode fornecer uma variedade de substituições de rótulos que modificam sua compilação de executores auto-hospedados. Todas as compilações não reconhecidas por CodeBuild serão ignoradas, mas não falharão em sua solicitação de webhook. Por exemplo, o YAML do fluxo de trabalho a seguir inclui substituições para imagem, tamanho da instância, frota e buildspec:

```
name: Hello World
on: [push]
jobs:
  Hello-World-Job:
    runs-on:
      - codebuild-myProject-${{ github.run_id }}-${{ github.run_attempt }}
        image:${{ matrix.os }}
        instance-size:${{ matrix.size }}
        fleet:myFleet
        buildspec-override:true
    strategy:
      matrix:
        include:
          - os: arm-3.0
            size: small
          - os: linux-5.0
            size: large
    steps:
      - run: echo "Hello World!"
```

**nota**  
Se seu trabalho de fluxo de trabalho estiver suspenso GitHub, consulte [Solucionar problemas do webhook](action-runner-troubleshoot-webhook.md) e [Usando rótulos personalizados para rotear trabalhos](https://docs.github.com/en/enterprise-server@3.12/actions/hosting-your-own-runners/managing-self-hosted-runners/using-self-hosted-runners-in-a-workflow?learn=hosting_your_own_runners&learnProduct=actions#using-custom-labels-to-route-jobs).

`codebuild-<project-name>-${{github.run_id}}-${{github.run_attempt}}`(obrigatório)
+ Exemplo: `codebuild-fake-project-${{ github.run_id }}-${{ github.run_attempt }}`
+ Necessário para todo o fluxo de trabalho de GitHub ações YAMLs. *<project name>*deve ser igual ao nome do projeto para o qual o webhook do executor auto-hospedado está configurado.

`image:<environment-type>-<image-identifier>`
+ Exemplo: `image:arm-3.0`
+ Substitui a imagem e o tipo de ambiente usados ao iniciar a compilação do executor auto-hospedado com uma imagem selecionada. Para saber mais sobre os valores compatíveis, consulte [Imagens de computação compatíveis com o executor CodeBuild de ações hospedado GitHub](sample-github-action-runners-update-yaml.images.md).
  + Para substituir a imagem e o tipo de ambiente usados por uma imagem personalizada, use `image:custom-<environment-type>-<custom-image-identifier>`
  + Exemplo: `image:custom-arm-public.ecr.aws/codebuild/amazonlinux-aarch64-standard:3.0`
**nota**  
Se a imagem personalizada residir em um registro privado, consulte [Configurar uma credencial de registro privada para executores auto-hospedados](private-registry-sample-configure-runners.md).

`instance-size:<instance-size>`
+ Exemplo: `instance-size:medium`
+ Substitui o tipo de instância usado ao iniciar a compilação do executor auto-hospedado. Para saber mais sobre os valores compatíveis, consulte [Imagens de computação compatíveis com o executor CodeBuild de ações hospedado GitHub](sample-github-action-runners-update-yaml.images.md).

`fleet:<fleet-name>`
+ Exemplo: `fleet:myFleet`
+ Substitui as configurações de frota definidas no projeto para usar a frota especificada. Para obter mais informações, consulte [Executar compilações em frotas de capacidade reservada](fleets.md).

`buildspec-override:<boolean>`
+ Exemplo: `buildspec-override:true`
+ Permite que a compilação execute comandos buildspec nas fases `INSTALL`, `PRE_BUILD` e `POST_BUILD` se definida como `true`.

## Substituição de rótulo único (herdado)
<a name="sample-github-action-runners-update-single-labels"></a>

CodeBuild permite que você forneça várias substituições em uma única etiqueta usando o seguinte:
+ Para substituir as configurações de ambiente para uma compilação computacional do Amazon EC2/Lambda, use a seguinte sintaxe:

  ```
  runs-on: codebuild-<project-name>-${{ github.run_id }}-${{ github.run_attempt }}-<environment-type>-<image-identifier>-<instance-size>
  ```
+ Para substituir as configurações da frota para a compilação computacional do Amazon EC2, use a seguinte sintaxe:

  ```
  runs-on: codebuild-<project-name>-${{ github.run_id }}-${{ github.run_attempt }}-fleet-<fleet-name>
  ```
+ Para substituir a frota e a imagem usadas para a compilação, use a seguinte sintaxe:

  ```
  runs-on: codebuild-<project-name>-${{ github.run_id }}-${{ github.run_attempt }}-image-<image-version>-fleet-<fleet-name>
  ```
+ Para executar comandos buildspec durante a compilação, `-with-buildspec` pode ser adicionado como sufixo ao rótulo:

  ```
  runs-on: codebuild-<project-name>-${{ github.run_id }}-${{ github.run_attempt }}-<image>-<image-version>-<instance-size>-with-buildspec
  ```
+ Opcionalmente, você pode fornecer uma substituição do tamanho da instância sem substituir a imagem. Para compilações do Amazon EC2, você pode excluir o tipo de ambiente e o identificador de imagem. Para compilações do Lambda, você pode excluir o identificador da imagem.

# Imagens de computação compatíveis com o executor CodeBuild de ações hospedado GitHub
<a name="sample-github-action-runners-update-yaml.images"></a>

Na etiqueta em que você configurou[Tutorial: Configurar um CodeBuild executor de GitHub ações hospedado](action-runner.md), você pode substituir as configurações do seu ambiente Amazon EC2 usando os valores nas três primeiras colunas. CodeBuild fornece as seguintes imagens computacionais do Amazon EC2. Para obter mais informações sobre 

<a name="build-env-ref.supported-images"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/codebuild/latest/userguide/sample-github-action-runners-update-yaml.images.html)

Além disso, você pode substituir as configurações do ambiente Lambda usando os valores a seguir. Para obter mais informações sobre a computação CodeBuild Lambda, consulte. [Execute compilações em computação AWS Lambda](lambda.md) CodeBuild é compatível com as seguintes imagens de computação Lambda:

<a name="lambda.supported-images"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/codebuild/latest/userguide/sample-github-action-runners-update-yaml.images.html)

Para obter mais informações, consulte [Modos e tipos de computação do ambiente de compilação](build-env-ref-compute-types.md) e [Imagens do Docker fornecidas por CodeBuild](build-env-ref-available.md).