Etapa 1: criar um CodeBuild projeto com um webhook Etapa 2: atualizar seu fluxo de trabalho de GitHub ações YAML Etapa 3: revisar os resultados GitHub Opções de configuração do Actions Runner Filtrar GitHub ações e eventos de webhook (CloudFormation)Filtrar GitHub ações e eventos de webhook (AWS CDK)Filtrar eventos de webhook de GitHub ações (Terraform)Filtrar GitHub ações e eventos de webhook (AWS CLI)

Tutorial: Configurar um executor de CodeBuild-hosted GitHub ações

Este tutorial mostra como configurar seus CodeBuild projetos para executar trabalhos do GitHub Actions. Para obter mais informações sobre como usar GitHub Ações com, CodeBuild consulteTutorial: Configurar um executor de CodeBuild-hosted GitHub ações.

Para concluir este tutorial, você deve primeiramente:

Conecte-se com um token de acesso pessoal, um segredo do Secrets Manager, aplicativo OAuth ou GitHub aplicativo. Se quiser se conectar a um aplicativo OAuth, 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. Para obter mais instruções, consulte GitHub e acesso ao GitHub Enterprise Server em CodeBuild.
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, aplicativo OAuth ou GitHub aplicativo. Para instruções, consulte GitHub e acesso ao GitHub Enterprise Server em CodeBuild.
- Você pode importar suas GitHub credenciais por meio da ImportSourceCredentials API. Isso só pode ser feito com um token de acesso pessoal. Para se conectar usando uma aplicação OAuth, use o console. Para instruções, consulte Conecte-se GitHub com um token de acesso (CLI).
nota
Isso só precisa ser feito se você não tiver se conectado GitHub à sua conta.

Etapa 1: criar um CodeBuild projeto com um webhook

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 como criar um webhook no GitHub Enterprise, consulteGitHub webhooks manuais.

Para criar um CodeBuild projeto com um webhook

Abra o AWS CodeBuild console em https://console.aws.amazon.com/codesuite/codebuild/home.
Crie um projeto de compilação. Para obter informações, consulte Criar um projeto de compilação (console) e Executar uma compilação (console).
Em Tipo de projeto, escolha Projeto de executor.

Em Executor:
1. Para o provedor Runner, escolha GitHub.
2. Em Localização do executor, escolha Repositório.
3. Em URL do repositório, em Repositório, escolha. https://github.com/user-name/repository-name
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.
- 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 YAML do fluxo de trabalho de GitHub ações. Para obter mais informações, consulte Etapa 2: atualizar seu fluxo de trabalho de GitHub ações 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.
Continue com os valores padrão e escolha Criar projeto de compilação.
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 entregar eventos de tarefas de fluxo de trabalho.

Etapa 2: atualizar seu fluxo de trabalho de GitHub ações YAML

Nesta etapa, você atualizará seu arquivo YAML do fluxo de trabalho do GitHub Actions GitHub 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 e Substituições de rótulos suportadas com o CodeBuild-hosted GitHub executor de ações.

Atualize seu fluxo de trabalho de GitHub ações YAML

Navegue GitHub e atualize a runs-on 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 do GitHub Actions 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 mapeia sua compilação para execuções de fluxo de trabalho específicas e interrompe a compilação quando a execução do fluxo de trabalho é cancelada. Para obter mais informações, consulte o contexto do github.
```
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 YAML de GitHub ações:
```
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 Calcule imagens compatíveis com o CodeBuild-hosted GitHub executor de ações. Para usar imagens personalizadas, consulte Substituições de rótulos suportadas com o CodeBuild-hosted GitHub executor de ações. 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 YAML de GitHub ações:
```
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. 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 YAML de GitHub ações:
```
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 daqueles que CodeBuild suportam. 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 pelos GitHub-hosted executores 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 setup-python para instalar o Python no ambiente de compilação.

Execute comandos buildspec nas fases INSTALL, PRE_BUILD e POST_BUILD

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

Usando 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 começar 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 construção falhar na INSTALL fase PRE_BUILD ou, não CodeBuild iniciará o executor auto-hospedado 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 executor poderá expirar antes do início do executor GitHub auto-hospedado.

Etapa 3: revisar os resultados

Sempre que ocorre a execução de um fluxo de trabalho de GitHub ações, CodeBuild você recebe os eventos de 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 seus registros de trabalho de fluxo de trabalho, navegue até seu repositório em GitHub, escolha Ações, escolha o fluxo de trabalho desejado e, em seguida, escolha o trabalho específico para o qual você gostaria de revisar os registros.

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

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

GitHub Opções de configuração do Actions Runner

É 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. Consulte mais informações sobre o registro de executores no nível da organização e as permissões necessárias em Create configuration for a just-in-time runner for an organization.

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. Consulte mais informações sobre o registro de executores no nível da empresa e as permissões necessárias em Create configuration for a just-in-time runner for an Enterprise.

nota

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.

CODEBUILD_CONFIG_GITHUB_ACTIONS_RUNNER_GROUP_ID

CodeBuild registrará executores auto-hospedados no ID do grupo de executores inteiros 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.

CODEBUILD_CONFIG_GITHUB_ACTIONS_ORG_REGISTRATION_NAME

Para configurar o registro de executores em nível de organização usando seu 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 seu 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 de GitHub ações, 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 GitHub ações e eventos de webhook (CloudFormation)

A YAML-formatted parte a seguir de um CloudFormation modelo cria um grupo de filtros que aciona uma construçã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 GitHub ações e eventos de webhook (AWS CDK)

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)

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 GitHub ações e eventos de webhook (AWS CLI)

Os AWS CLI comandos a seguir criam um projeto de executor 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 ela é 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\"}]]"

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Sobre o CodeBuild-hosted GitHub executor de ações

Solucionar problemas do webhook