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

# Executar compilações em lotes
<a name="batch-build"></a>

Você pode usar AWS CodeBuild para executar compilações simultâneas e coordenadas de um projeto com compilações em lote. 

**Topics**
+ [

## Perfil de segurança
](#batch_security_role)
+ [

## Tipos de compilação em lote
](#batch_build_types)
+ [

## Modo de relatório em lote
](#batch-report-mode)
+ [

## Mais informações
](#batch_more_info)

## Perfil de segurança
<a name="batch_security_role"></a>

As compilações em lote introduzem um novo perfil de segurança na configuração em lote. Essa nova função é necessária, pois CodeBuild você deve poder chamar as `RetryBuild` ações `StartBuild``StopBuild`, e em seu nome para executar compilações como parte de um lote. Os clientes devem usar um novo perfil, e não o mesmo perfil que usam na compilação, por dois motivos:
+ Fornecer ao perfil de compilação as permissões `StartBuild`, `StopBuild` e `RetryBuild` que permitem a uma única compilação iniciar mais compilações por meio do buildspec.
+ CodeBuild compilações em lote fornecem restrições que restringem o número de compilações e tipos de computação que podem ser usados para as compilações no lote. Se o perfil de compilação tiver essas permissões, será possível que as próprias compilações ignorem essas restrições.

## Tipos de compilação em lote
<a name="batch_build_types"></a>

CodeBuild suporta os seguintes tipos de compilação em lote:

**Topics**
+ [

### Grafo de compilação
](#batch_build_graph)
+ [

### Lista de compilações
](#batch_build_list)
+ [

### Matriz de compilações
](#batch_build_matrix)
+ [

### Fanout de compilação
](#batch_build_fanout)

### Grafo de compilação
<a name="batch_build_graph"></a>

Um grafo de compilação define um conjunto de tarefas que dependem de outras tarefas no lote. 

O exemplo a seguir define um grafo de compilação que cria uma cadeia de dependências. 

```
batch:
  fast-fail: false
  build-graph:
    - identifier: build1
      env:
        variables:
          BUILD_ID: build1
      ignore-failure: false
    - identifier: build2
      buildspec: build2.yml
      env:
        variables:
          BUILD_ID: build2
      depend-on:
        - build1
    - identifier: build3
      env:
        variables:
          BUILD_ID: build3
      depend-on:
        - build2
    - identifier: build4
      env:
        compute-type: ARM_LAMBDA_1GB
    - identifier: build5
      env:
        fleet: fleet_name
```

Neste exemplo:
+ A `build1` é executada primeiro porque não tem dependências.
+ A `build2` tem uma dependência em `build1`, então a `build2` é executada após a conclusão da `build1`.
+ A `build3` tem uma dependência em `build2`, então a `build3` é executada após a conclusão da `build2`.

Para obter mais informações sobre a sintaxe buildspec do grafo de compilação, consulte [`batch/build-graph`](batch-build-buildspec.md#build-spec.batch.build-graph).

### Lista de compilações
<a name="batch_build_list"></a>

Uma lista de compilações define várias tarefas que são executadas paralelamente. 

O exemplo a seguir define uma lista de compilações. As compilações `build1` e `build2` serão executadas em paralelo.

```
batch:
  fast-fail: false
  build-list:
    - identifier: build1
      env:
        variables:
          BUILD_ID: build1
      ignore-failure: false
    - identifier: build2
      buildspec: build2.yml
      env:
        variables:
          BUILD_ID: build2
      ignore-failure: true
    - identifier: build3
      env:
        compute-type: ARM_LAMBDA_1GB
    - identifier: build4
      env:
        fleet: fleet_name
    - identifier: build5
      env:
        compute-type: GENERAL_LINUX_XLAGRE
```

Para obter mais informações sobre a sintaxe buildspec da lista de compilações, consulte [`batch/build-list`](batch-build-buildspec.md#build-spec.batch.build-list).

### Matriz de compilações
<a name="batch_build_matrix"></a>

Uma matriz de construção define tarefas com configurações diferentes que são executadas paralelamente. CodeBuild cria uma compilação separada para cada combinação de configuração possível. 

O exemplo a seguir mostra uma matriz de compilações com dois arquivos buildspec e três valores para uma variável de ambiente.

```
batch:
  build-matrix:
    static:
      ignore-failure: false
    dynamic:
      buildspec: 
        - matrix1.yml
        - matrix2.yml
      env:
        variables:
          MY_VAR:
            - VALUE1
            - VALUE2
            - VALUE3
```

Neste exemplo, CodeBuild cria seis compilações:
+ `matrix1.yml` com `$MY_VAR=VALUE1`
+ `matrix1.yml` com `$MY_VAR=VALUE2`
+ `matrix1.yml` com `$MY_VAR=VALUE3`
+ `matrix2.yml` com `$MY_VAR=VALUE1`
+ `matrix2.yml` com `$MY_VAR=VALUE2`
+ `matrix2.yml` com `$MY_VAR=VALUE3`

Cada compilação terá as seguintes configurações:
+ `ignore-failure` definido como `false`
+ `env/type` definido como `LINUX_CONTAINER`
+ `env/image` definido como `aws/codebuild/amazonlinux-x86_64-standard:4.0`
+ `env/privileged-mode` definido como `true`

Essas compilações são executadas em paralelo.

Para obter mais informações sobre a sintaxe buildspec da matriz de compilações, consulte [`batch/build-matrix`](batch-build-buildspec.md#build-spec.batch.build-matrix).

### Fanout de compilação
<a name="batch_build_fanout"></a>

Um fanout de compilação define uma tarefa que será dividida em várias compilações no lote. Isso pode ser usado para executar testes em paralelo. CodeBuild cria uma compilação separada para cada fragmento de casos de teste com base no valor definido no `parallelism` campo.

O exemplo a seguir define um fanout de compilação que cria cinco compilações que são executadas em paralelo.

```
version: 0.2

batch:
   fast-fail: false 
   build-fanout:
     parallelism: 5
     ignore-failure: false

phases:
  install:
    commands:
      - npm install
   build:
    commands:
      - mkdir -p test-results
      - cd test-results
      - |
        codebuild-tests-run \
         --test-command 'npx jest --runInBand --coverage' \
         --files-search "codebuild-glob-search '**/test/**/*.test.js'" \
         --sharding-strategy 'equal-distribution'
```

Neste exemplo, supondo que haja 100 testes que precisam ser executados, CodeBuild cria cinco compilações, cada uma executando 20 testes em paralelo.

Para obter mais informações sobre a sintaxe buildspec do grafo de compilação, consulte [`batch/build-fanout`](batch-build-buildspec.md#build-spec.batch.build-fanout).

## Modo de relatório em lote
<a name="batch-report-mode"></a>

Se o provedor de origem do seu projeto for Bitbucket ou GitHub Enterprise e seu projeto estiver configurado para relatar os status de criação ao provedor de origem, você poderá selecionar como deseja que os status de criação em lote sejam enviados ao provedor de origem. GitHub É possível optar por enviar os status como um único relatório de status agregado para o lote ou ter o status de cada compilação no lote informado individualmente.

Para saber mais, consulte os seguintes tópicos:
+ [Configuração em lote (criar)](create-project.md#create-project-console-batch-config)
+ [Configuração em lote (atualizar)](change-project.md#change-project-console-batch-config)

## Mais informações
<a name="batch_more_info"></a>

Para saber mais, consulte os seguintes tópicos:
+ [Referência de buildspec de compilação em lote](batch-build-buildspec.md)
+ [Configuração em lote](create-project.md#create-project-console-batch-config)
+ [Executar uma compilação em lote (AWS CLI)](run-batch-build-cli.md)
+ [Interromper compilações em lote no AWS CodeBuild](stop-batch-build.md)