View a markdown version of this page

Tutorial: Configurar um CodeBuild-hosted GitLab corredor - AWS CodeBuild
Etapa 1: criar um CodeBuild projeto com um webhookEtapa 2: criar um arquivo .gitlab-ci.yml no repositórioEtapa 3: revisar os resultadosFiltrar eventos de GitLab webhook (CloudFormation)

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: Configurar um CodeBuild-hosted GitLab corredor

Este tutorial mostra como configurar seus CodeBuild projetos para executar trabalhos de GitLab CI/CD pipeline. Para obter mais informações sobre como usar GitLab ou GitLab ser autogerenciado com CodeBuild, consulteSelf-managed GitLab corredores em AWS CodeBuild.

Para concluir este tutorial, você deve primeiramente:

  • Conecte-se com um aplicativo OAuth usando. CodeConnections Observe que, ao se conectar a um aplicativo OAuth, você deve usar o CodeBuild console para fazer isso. Para obter mais instruções, consulte GitLab acesso em CodeBuild.

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

    nota

    Isso só precisa ser feito se você não tiver se conectado GitLab à sua conta.

    Com esse recurso, CodeBuild precisa de permissões adicionais, como create_runner e manage_runner do aplicativo GitLab OAuth. Se existirem CodeConnections para uma 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. Depois de concluir essa etapa, 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

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.

  2. 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:

      • Para o 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.

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

      • Em Repositório, escolha o nome do seu projeto 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 GitLab CI/CD YAML do seu funil. Para obter mais informações, consulte Etapa 2: criar um arquivo .gitlab-ci.yml no repositório.

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

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

  4. Abra o GitLab console em https://gitlab.com/user-name/repository-name/-/hooks para verificar se um webhook foi criado e está habilitado para entregar eventos de tarefas de fluxo de trabalho.

Etapa 2: criar um arquivo .gitlab-ci.yml no repositório

Nesta etapa, você criará um .gitlab-ci.yml arquivo GitLab para configurar seu ambiente de compilação e usar executores GitLab autogerenciados em. CodeBuild Para obter mais informações, consulte Usar executores autogerenciados.

Atualize seu GitLab CI/CD pipeline YAML

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 mapear a compilação para execuções de tarefas específicas do pipeline e interromper a compilação quando a execução do pipeline for cancelada.

    nota

    Certifique-se de que seu <project-name> corresponda ao nome do projeto em que você criou CodeBuild. Se não corresponder, não CodeBuild processará o webhook e o GitLab CI/CD pipeline poderá travar.

    Veja a seguir um exemplo de um GitLab CI/CD pipeline 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 Calcule imagens compatíveis com o executor CodeBuild-hosted GitLab. Para usar imagens personalizadas, consulte Substituições de etiquetas suportadas pelo executor CodeBuild-hosted GitLab. 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 GitLab CI/CD pipeline 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. 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 GitLab CI/CD pipeline 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 GitLab CI/CD pipeline 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 funil será acionado e build-job ele enviará uma notificação de webhook que iniciará sua integração. CodeBuild

Execute comandos buildspec nas fases INSTALL, PRE_BUILD e POST_BUILD

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 executor começar 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 construção falhar na INSTALL fase PRE_BUILD ou, o executor autogerenciado não CodeBuild iniciará e o trabalho do GitLab CI/CD pipeline 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 corredor GitLab autogerenciado.

Etapa 3: revisar os resultados

Sempre que ocorrer uma execução de GitLab CI/CD pipeline, CodeBuild receberia os eventos de trabalho do CI/CD pipeline por meio do webhook. Para cada trabalho no CI/CD pipeline, CodeBuild inicia uma compilação para executar um executor efêmero GitLab . O executor é responsável por executar um único trabalho de CI/CD pipeline. 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 tarefas do CI/CD pipeline, navegue até seu repositório em GitLab, escolha Criar, Trabalhos 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 autogerenciado. CodeBuild

Filtrar eventos de GitLab 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 de GitLab CI/CD pipeline com um nome de CI/CD pipeline 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: 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\]