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 GitLab ou gerenciar automaticamente com CodeBuild, consulteSelf-managed GitLab corredores em AWS CodeBuild.

Para concluir este tutorial, você deve primeiramente:

  • Conecte-se a 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 estiver conectado GitLab à sua conta.

    Com esse recurso, CodeBuild precisa de permissões adicionais, como create_runner e manage_runner do aplicativo GitLab OAuth. 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

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 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 GitLab CI/CD YAML do pipeline. 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 fornecer eventos de trabalhos do Workflow.

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

Nesta etapa, você criará um .gitlab-ci.yml arquivo GitLabpara 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 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 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 Imagens de computação compatíveis com o executor CodeBuild-hosted GitLab. Para usar imagens personalizadas, consulte Substituições de etiquetas suportadas pelo corredor 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 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_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 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 construção falhar na INSTALL fase PRE_BUILD ou, o executor autogerenciado não CodeBuild será iniciado e o trabalho do GitLab CI/CD pipeline precisará ser cancelado manualmente.

  • CodeBuild busca o token do corredor 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

Sempre que ocorre uma execução do GitLab CI/CD pipeline, CodeBuild receberia os eventos do 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 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 YAML-formatted parte a seguir de um CloudFormation modelo 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 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\]