

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

# GitLab Corredores autogerenciados em AWS CodeBuild
<a name="gitlab-runner"></a>

GitLab fornece dois modos de execução para executar GitLab trabalhos em seu CI/CD pipeline. Um modo são os executores GitLab hospedados, que são gerenciados GitLab e totalmente integrados com o. GitLab O outro modo são os executores autogerenciados, que permitem que você traga seu próprio ambiente personalizado para executar trabalhos no pipeline de GitLab CI/CD.

As etapas de alto nível para configurar um CodeBuild projeto para executar trabalhos de pipeline de GitLab CI/CD são as seguintes:

1. Se você ainda não fez isso, conecte-se a um OAuth aplicativo ao qual conectar seu projeto GitLab.

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

1. Atualize seu pipeline de GitLab CI/CD YAML GitLab para configurar seu ambiente de compilação.

Para obter um procedimento mais detalhado, consulte [Tutorial: Configurar um CodeBuild executor hospedado GitLab](sample-gitlab-runners.md).

Esse recurso permite que seus trabalhos de pipeline de GitLab CI/CD obtenham integração nativa AWS, o que fornece segurança e conveniência por meio de recursos como IAM e Amazon VPC. AWS CloudTrail Você pode acessar os tipos de instância mais recentes, incluindo instâncias baseadas em ARM.

**Topics**
+ [Sobre o CodeBuild -hosted runner GitLab](gitlab-runner-questions.md)
+ [Tutorial: Configurar um CodeBuild executor hospedado GitLab](sample-gitlab-runners.md)
+ [Substituições de rótulos suportadas pelo executor hospedado CodeBuild GitLab](gitlab-runners-update-labels.md)
+ [Imagens de computação compatíveis com o executor CodeBuild hospedado GitLab](sample-gitlab-runners-gitlab-ci.images.md)

# Sobre o CodeBuild -hosted runner GitLab
<a name="gitlab-runner-questions"></a>

A seguir estão algumas perguntas comuns sobre o CodeBuild -hosted GitLab runner.

## Quais tipos de fonte são compatíveis com CodeBuild GitLab executores hospedados?
<a name="gitlab-runner-source"></a>

CodeBuild-hosted GitLab runners são compatíveis com o tipo de `GITLAB_SELF_MANAGED` fonte `GITLAB` e.

## Quando devo incluir as substituições de imagem e instância no rótulo?
<a name="gitlab-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 uma das suas tarefas de pipeline de GitLab CI/CD. Isso pode ser feito sem a necessidade de criar vários CodeBuild projetos ou webhooks.

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

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

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

Para obter mais informações, consulte [Filtrar eventos de GitLab webhook ()CloudFormation](gitlab-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="gitlab-runner-secrets"></a>

Por padrão, os segredos impressos no log não são mascarados. Se quiser mascarar seus segredos, você pode fazer isso atualizando suas configurações de variáveis de CI/CD ambiente:

**Para mascarar segredos em GitLab**

1. Em suas **GitLab Configurações**, escolha **CI/CD**.

1. Em **Variáveis**, escolha **Editar** para o segredo que você deseja mascarar.

1. Em **Visibilidade**, selecione **Variável de máscara** e escolha **Atualizar variável** para salvar as alterações.

## Posso receber eventos de GitLab webhook de vários projetos em um único grupo?
<a name="gitlab-runner-webhooks"></a>

CodeBuild suporta webhooks de grupo, que recebem eventos de um grupo especificado GitLab . Para obter mais informações, consulte [GitLab webhooks em grupo](gitlab-group-webhook.md).

## Posso executar um trabalho no executor do Docker para o executor autogerenciado? Por exemplo, quero executar um trabalho do pipeline em uma imagem específica para manter o mesmo ambiente de compilação em um contêiner separado e isolado.
<a name="gitlab-runner-custom-image"></a>

Você pode executar o executor GitLab autogerenciado CodeBuild com uma imagem específica [criando o projeto com uma imagem personalizada ou [substituindo a imagem](sample-gitlab-runners.md#sample-gitlab-runners-gitlab-ci)](create-project.md#environment-image.console) em seu arquivo. `.gitlab-ci.yml`

## Com qual executor o executor autogerenciado trabalha? CodeBuild
<a name="gitlab-runner-shell-executor"></a>

O executor autogerenciado em CodeBuild é executado com o executor do shell, onde a compilação é executada localmente junto com o executor que está GitLab sendo executado dentro do contêiner docker.

## Posso fornecer comandos buildspec com o executor autogerenciado?
<a name="gitlab-runner-buildspec-commands"></a>

Sim, é possível adicionar comandos buildspec com o executor autogerenciado. **Você pode fornecer o arquivo buildspec.yml no seu GitLab repositório e usar a `buildspec-override:true` tag na seção Tags do trabalho.** Para obter mais informações, consulte [Nome do arquivo buildspec e local de armazenamento](build-spec-ref.md#build-spec-ref-name-storage).

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

CodeBuild GitLab -os executores 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 GitLab executor CodeBuild hospedado?
<a name="gitlab-runner-platform"></a>

CodeBuild GitLab executores 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 hospedado GitLab
<a name="sample-gitlab-runners"></a>

Este tutorial mostra como configurar seus CodeBuild projetos para executar trabalhos de pipeline de GitLab CI/CD. Para obter mais informações sobre como usar GitLab GitLab ou gerenciar automaticamente com CodeBuild, consulte[GitLab Corredores autogerenciados em AWS CodeBuild](gitlab-runner.md).<a name="sample-gitlab-runners-prerequisites"></a>

Para concluir este tutorial, você deve primeiramente:
+ Conecte-se a um OAuth aplicativo usando CodeConnections. Observe que, ao se conectar a um OAuth aplicativo, você deve usar o CodeBuild console para fazer isso. Para obter mais instruções, consulte [GitLab acesso em CodeBuild](access-tokens-gitlab-overview.md).
+ Conecte-se CodeBuild à sua GitLab conta. Para fazer isso, você pode adicionar GitLab como provedor de origem no console. Para instruções, consulte [GitLab acesso em CodeBuild](access-tokens-gitlab-overview.md).
**nota**  
Isso só precisa ser feito se você não estiver conectado GitLab à sua conta.  
Com esse recurso, CodeBuild precisa de permissões adicionais, como `create_runner` e `manage_runner` do GitLab OAuth aplicativo. Se houver uma CodeConnections GitLab conta específica, ela não solicitará automaticamente atualizações de permissão. Para fazer isso, você pode acessar o CodeConnections console e criar uma conexão fictícia com a mesma GitLab conta para acionar a reautorização e obter as permissões adicionais. Com isso, todas as conexões existentes podem usar o recurso de execução. Depois de concluir, você poderá excluir a conexão fictícia.

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

Nesta etapa, você criará um CodeBuild projeto com um webhook e o revisará no GitLab console.

**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).

   Em **Tipo de projeto**, escolha **Projeto de executor**.
   +  Em **Executor:** 
     + Para **provedor Runner**, escolha **GitLab**.
     +  Em **Credencial**, selecione uma das seguintes opções:
       + Escolha **Credencial de origem padrão**. A conexão padrão aplica uma GitLab conexão padrão em todos os projetos.
       + Escolha **Credencial de origem personalizada**. A conexão personalizada aplica uma GitLab conexão personalizada que substitui as configurações padrão da sua conta.
**nota**  
Se você ainda não criou uma conexão com seu provedor, precisará criar uma nova GitLab conexão. Para instruções, consulte [Conecte-se CodeBuild a GitLab](access-tokens-gitlab-overview.md#connections-gitlab).
     + Em **Localização do executor**, escolha **Repositório**.
     +  Em **Repositório**, escolha o nome do seu projeto em GitLab especificando o caminho do projeto com o namespace.
   +  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 pipeline de GitLab CI/CD. Para obter mais informações, consulte [Etapa 2: criar um arquivo .gitlab-ci.yml no repositório](#sample-gitlab-runners-gitlab-ci).
   +  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 autogerenciado.

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

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

## Etapa 2: criar um arquivo .gitlab-ci.yml no repositório
<a name="sample-gitlab-runners-gitlab-ci"></a>

Nesta etapa, você criará um `.gitlab-ci.yml` arquivo [https://gitlab.com/](https://gitlab.com/)para configurar seu ambiente de compilação e usar executores GitLab autogerenciados em. CodeBuild Para obter mais informações, consulte [Usar executores autogerenciados](https://docs.gitlab.com/runner/#use-self-managed-runners).

### Atualize seu pipeline de GitLab CI/CD YAML
<a name="sample-gitlab-runners-update-yaml.setup"></a>

Navegue até `https://gitlab.com/user-name/project-name/-/tree/branch-name` e crie um arquivo `.gitlab-ci.yml` no repositório. Para configurar o ambiente de compilação, execute uma destas ações:
+ Você pode especificar o nome do CodeBuild projeto. Nesse caso, a compilação usará sua configuração de 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 GitLab trabalho 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.

  ```
  tags:
      - codebuild-<codebuild-project-name>-$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME
  ```

  `$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME` é necessário para mapear a compilação para execuções de trabalhos específicos do pipeline e interromper a compilação quando a execução do pipeline é cancelada.
**nota**  
Certifique-se de que seu nome *<project-name>* corresponda ao nome do projeto que você criou CodeBuild. Se não corresponder, não CodeBuild processará o webhook e o pipeline de GitLab CI/CD poderá travar.

  Veja a seguir um exemplo de um pipeline de GitLab CI/CD YAML:

  ```
  workflow:
    name: HelloWorld
  stages:          # List of stages for jobs, and their order of execution
    - build
  
  build-job:       # This job runs in the build stage, which runs first.
    stage: build
    script:
      - echo "Hello World!"
    tags:
      - codebuild-myProject-$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME
  ```
+ Você também pode substituir a imagem e o tipo de computação na tag. Consulte uma lista de imagens selecionadas em [Imagens de computação compatíveis com o executor CodeBuild hospedado GitLab](sample-gitlab-runners-gitlab-ci.images.md). Para usar imagens personalizadas, consulte [Substituições de rótulos suportadas pelo executor hospedado CodeBuild GitLab](gitlab-runners-update-labels.md). O tipo de computação e a imagem na tag substituirão as configurações do ambiente no projeto. Para substituir as configurações de ambiente para uma compilação computacional do Amazon EC2, use a seguinte sintaxe:

  ```
  tags:
      - codebuild-<codebuild-project-name>-$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME
      - image:<environment-type>-<image-identifier>
      - instance-size:<instance-size>
  ```

  Veja a seguir um exemplo de um pipeline de GitLab CI/CD YAML:

  ```
  stages:
    - build
  
  build-job:
    stage: build
    script:
      - echo "Hello World!"
    tags:
      - codebuild-myProject-$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME
      - image:arm-3.0
      - instance-size:small
  ```
+ Você pode substituir a frota usada para a compilação na tag. 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:

  ```
  tags:
      - codebuild-<codebuild-project-name>-$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME
      - fleet:<fleet-name>
  ```

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

  ```
  tags:
      - codebuild-<codebuild-project-name>-$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME
      - fleet:<fleet-name>                    
      - image:<environment-type>-<image-identifier>
  ```

  Veja a seguir um exemplo de um pipeline de GitLab CI/CD YAML:

  ```
  stages:
    - build
  
  build-job:
    stage: build
    script:
      - echo "Hello World!"
    tags:
      - codebuild-myProject-$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME
      - fleet:myFleet
      - image:arm-3.0
  ```
+ Para executar seus trabalhos de pipeline de GitLab CI/CD 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.

Depois de confirmar suas alterações`.gitlab-ci.yml`, um GitLab pipeline será acionado e `build-job` ele enviará uma notificação de webhook que iniciará sua criação. CodeBuild

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

Por padrão, CodeBuild ignora qualquer comando buildspec ao executar uma compilação autogerenciada. GitLab Para executar comandos buildspec durante a compilação, `buildspec-override:true` pode ser adicionado como sufixo a `tags`:

```
tags:
    - codebuild-<codebuild-project-name>-$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME
    - buildspec-override:true
```

Ao usar esse comando, CodeBuild criará uma pasta chamada `gitlab-runner` na pasta de origem primária do contêiner. Quando o GitLab corredor iniciar durante a `BUILD` fase, ele será executado no `gitlab-runner` diretório.

Há várias limitações ao usar uma substituição de buildspec em uma compilação autogerenciada: GitLab 
+ CodeBuild não executará comandos buildspec durante a `BUILD` fase, pois o executor autogerenciado é 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 autogerenciado não CodeBuild iniciará e o trabalho do pipeline de GitLab CI/CD 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 de corredor poderá expirar antes que o corredor GitLab autogerenciado comece.

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

Sempre que um trabalho de GitLab CI/CD pipeline run occurs, CodeBuild would receive the CI/CD pipeline job events through the webhook. For each job in the CI/CD pipeline, CodeBuild starts a build to run an ephemeral GitLab runner. The runner is responsible for executing a single CI/CD tubulação. 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 CI/CD pipeline, navegue até seu repositório GitLab, escolha **Build**, **Jobs** e, em seguida, escolha o **Job** 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 autogerenciado. CodeBuild

## Filtrar eventos de GitLab webhook ()CloudFormation
<a name="sample-gitlab-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 um nome de GitLab CI/CD pipeline job request with a CI/CD pipeline que corresponde à 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: GITLAB
      Location: CODEBUILD_DEFAULT_WEBHOOK_SOURCE_LOCATION
    Triggers:
      Webhook: true
      ScopeConfiguration:
        Name: group-name
        Scope: GITLAB_GROUP
      FilterGroups:
        - - Type: EVENT
            Pattern: WORKFLOW_JOB_QUEUED
          - Type: WORKFLOW_NAME
            Pattern: \[CI-CodeBuild\]
```

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

Em seu pipeline de GitLab CI/CD YAML, você pode fornecer uma variedade de substituições de rótulos que modificam sua compilação de executores autogerenciados. 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 a seguir inclui substituições para imagem, tamanho da instância, frota e buildspec:

```
workflow:
  name: HelloWorld
stages:
  - build

build-job:
  stage: build
  script:
    - echo "Hello World!"
  tags:
    - codebuild-myProject-$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME
    - image:arm-3.0
    - instance-size:small
    - fleet:myFleet
    - buildspec-override:true
```

`codebuild-<project-name>-$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME`(obrigatório)
+ Exemplo: `codebuild-myProject-$CI_PROJECT_ID-$CI_PIPELINE_IID-$CI_JOB_NAME`
+ Necessário para todo o GitLab pipeline de CI/CD. YAMLs *<project name>*deve ser igual ao nome do projeto para o qual o webhook do executor autogerenciado está configurado.

`image:<environment-type>-<image-identifier>`
+ Exemplo: `image:arm-3.0`
+ Substitui a imagem e o tipo de ambiente usados quando a compilação do executor autogerenciado é iniciada. Para saber mais sobre os valores compatíveis, consulte [Imagens de computação compatíveis com o executor CodeBuild hospedado GitLab](sample-gitlab-runners-gitlab-ci.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:small`
+ Substitui o tipo de instância usado quando a compilação do executor autogerenciado é iniciada. Para saber mais sobre os valores compatíveis, consulte [Imagens de computação compatíveis com o executor CodeBuild hospedado GitLab](sample-gitlab-runners-gitlab-ci.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`.

# Imagens de computação compatíveis com o executor CodeBuild hospedado GitLab
<a name="sample-gitlab-runners-gitlab-ci.images"></a>

Na etiqueta em que você configurou[Tutorial: Configurar um CodeBuild executor hospedado GitLab](sample-gitlab-runners.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-gitlab-runners-gitlab-ci.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-gitlab-runners-gitlab-ci.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).