Tutorial: Configurar um CodeBuild executor hospedado GitLab

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.

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.

• Conecte-se CodeBuild à sua GitLab conta. Para fazer isso, você pode adicionar GitLab como provedor de origem no console. Para obter 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 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 concluído, você pode 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 analisará 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 Source (Origem):

     • Em Source provider, escolha GitLab.

     • Para Credencial, escolha 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 obter instruções, consulte Conecte-se CodeBuild a GitLab.

     • Em Repositório, escolha o nome do seu projeto em GitLab especificando o caminho do projeto com o namespace.

   • Em eventos de webhook de fonte primária:

     • Para Webhook, opcional, selecione Reconstruir sempre que uma alteração de código for enviada para esse repositório.

     • Em Tipo de evento, selecione WORKFLOW_ JOB _ QUEUED. Depois que isso for ativado, as compilações serão acionadas somente por eventos de trabalhos de pipeline de GitLab CI/CD.

       nota

       CodeBuild só processará eventos de trabalhos de pipeline de GitLab CI/CD se um webhook tiver grupos de filtros contendo o filtro de eventos WORKFLOW_ JOB _ QUEUED.

       

   • Em Environment (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 em seu pipeline de GitLab CI/CD. YAML Para obter mais informações, consulte Etapa 2: criar um arquivo.gitlab-ci.yml no seu repositório.

   • Em Buildspec:

     • Observe que seu buildspec será ignorado, a menos que buildspec-override:true seja adicionado como um 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 construçã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 seu 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 pipeline de GitLab CI/CD YAML

Navegue até seu repositório https://gitlab.com/user-name/project-name/-/tree/branch-name e crie um .gitlab-ci.yml arquivo nele. Você pode configurar seu ambiente de compilação fazendo o seguinte:

• 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 noYAML, 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> corresponde ao nome do projeto em 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 sua imagem e o tipo de computação na tag. Consulte Imagens de computação compatíveis com o executor CodeBuild hospedado GitLab para obter uma lista das imagens disponíveis. O tipo de computação e a imagem no rótulo substituirão as configurações do ambiente em seu projeto. Para substituir suas configurações de ambiente para uma compilação EC2 computacional da Amazon, 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 sua construção na tag. Isso substituirá as configurações de frota definidas em seu projeto para usar a frota especificada. Para obter mais informações, consulte O Run se baseia em frotas de capacidade reservada. Para substituir as configurações da sua frota para uma compilação EC2 computacional da Amazon, 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 construçã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 comandos buildspec nas fases INSTALLBUILD, PRE _ 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, eles buildspec-override:true podem ser adicionados 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 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: analise seus resultados

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 construção associado serão encerrados imediatamente.

Para visualizar os registros de trabalhos do pipeline de CI/CD, navegue até seu repositório em 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 ()AWS CloudFormation

A parte YAML formatada a seguir de um AWS CloudFormation modelo 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
      FilterGroups:
        - - Type: EVENT
            Pattern: WORKFLOW_JOB_QUEUED
          - Type: WORKFLOW_NAME
            Pattern: \[CI-CodeBuild\]