Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Esegui le build in batch
<a name="batch-build"></a>

Puoi utilizzarlo AWS CodeBuild per eseguire build simultanee e coordinate di un progetto con build in batch. 

**Topics**
+ [

## Ruolo di sicurezza
](#batch_security_role)
+ [

## Tipi di build in batch
](#batch_build_types)
+ [

## Modalità report Batch
](#batch-report-mode)
+ [

## Ulteriori informazioni
](#batch_more_info)

## Ruolo di sicurezza
<a name="batch_security_role"></a>

Le compilazioni in batch introducono un nuovo ruolo di sicurezza nella configurazione in batch. Questo nuovo ruolo è obbligatorio in quanto CodeBuild devi essere in grado di richiamare le `RetryBuild` azioni `StartBuild``StopBuild`, e per conto dell'utente per eseguire le build come parte di un batch. I clienti devono utilizzare un nuovo ruolo e non lo stesso ruolo che usano nella compilazione, per due motivi:
+ Dare al ruolo di compilazione le autorizzazioni `StartBuild`, `StopBuild` e `RetryBuild` consentirebbe a una singola compilazione di avviare più compilazioni tramite buildspec.
+ CodeBuild le build in batch forniscono restrizioni che limitano il numero di build e i tipi di calcolo che possono essere utilizzati per le build del batch. Se il ruolo di compilazione dispone di queste autorizzazioni, è possibile che le compilazioni stesse possano ignorare queste restrizioni.

## Tipi di build in batch
<a name="batch_build_types"></a>

CodeBuild supporta i seguenti tipi di build in batch:

**Topics**
+ [

### Costruisci un grafico
](#batch_build_graph)
+ [

### Crea un elenco
](#batch_build_list)
+ [

### Costruisci una matrice
](#batch_build_matrix)
+ [

### Crea fanout
](#batch_build_fanout)

### Costruisci un grafico
<a name="batch_build_graph"></a>

Un grafico di compilazione definisce un insieme di attività che dipendono da altre attività del batch. 

L'esempio seguente definisce un grafico di compilazione che crea una catena di dipendenze. 

```
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
```

In questo esempio:
+ `build1`viene eseguito per primo perché non ha dipendenze.
+ `build2`ha una dipendenza da`build1`, quindi `build2` viene eseguito dopo `build1` il completamento.
+ `build3`dipende da`build2`, quindi `build3` viene eseguito dopo il completamento. `build2`

Per ulteriori informazioni sulla sintassi build graph buildspec, vedi. [`batch/build-graph`](batch-build-buildspec.md#build-spec.batch.build-graph)

### Crea un elenco
<a name="batch_build_list"></a>

Un elenco di build definisce una serie di attività eseguite in parallelo. 

L'esempio seguente definisce un elenco di build. Le `build2` build `build1` and verranno eseguite in parallelo.

```
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
```

Per ulteriori informazioni sulla sintassi buildspec della lista di compilazione, consulta. [`batch/build-list`](batch-build-buildspec.md#build-spec.batch.build-list)

### Costruisci una matrice
<a name="batch_build_matrix"></a>

Una matrice di compilazione definisce le attività con diverse configurazioni eseguite in parallelo. CodeBuild crea una build separata per ogni possibile combinazione di configurazione. 

L'esempio seguente mostra una matrice di compilazione con due file buildspec e tre valori per una variabile di ambiente.

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

In questo esempio, CodeBuild crea sei build:
+ `matrix1.yml` con `$MY_VAR=VALUE1`
+ `matrix1.yml` con `$MY_VAR=VALUE2`
+ `matrix1.yml` con `$MY_VAR=VALUE3`
+ `matrix2.yml` con `$MY_VAR=VALUE1`
+ `matrix2.yml` con `$MY_VAR=VALUE2`
+ `matrix2.yml` con `$MY_VAR=VALUE3`

Ogni build avrà le seguenti impostazioni:
+ `ignore-failure`impostato su `false`
+ `env/type`impostato su `LINUX_CONTAINER`
+ `env/image`impostato su `aws/codebuild/amazonlinux-x86_64-standard:4.0`
+ `env/privileged-mode`impostato su `true`

Queste build vengono eseguite in parallelo.

Per ulteriori informazioni sulla sintassi buildspec della matrice di compilazione, vedere. [`batch/build-matrix`](batch-build-buildspec.md#build-spec.batch.build-matrix)

### Crea fanout
<a name="batch_build_fanout"></a>

Un fanout di compilazione definisce un'attività che verrà suddivisa in più build nel batch. Può essere usato per eseguire test in parallelo. CodeBuild crea una build separata per ogni frammento di casi di test in base al valore impostato nel `parallelism` campo.

L'esempio seguente definisce un build fanout che crea cinque build che vengono eseguite in parallelo.

```
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'
```

In questo esempio, supponendo che ci siano 100 test da eseguire, CodeBuild crea cinque build che eseguono ciascuna 20 test in parallelo.

Per ulteriori informazioni sulla sintassi build graph buildspec, consulta. [`batch/build-fanout`](batch-build-buildspec.md#build-spec.batch.build-fanout)

## Modalità report Batch
<a name="batch-report-mode"></a>

Se il provider di origine del progetto è Bitbucket o GitHub Enterprise e il progetto è configurato per riportare gli stati di compilazione al provider di origine, puoi selezionare il modo in cui desideri che gli stati della compilazione in batch vengano inviati al provider di origine. GitHub Puoi scegliere di inviare gli stati come un unico rapporto di stato aggregato per il batch o di riportare singolarmente lo stato di ogni build del batch.

Per ulteriori informazioni, consulta i seguenti argomenti:
+ [Configurazione Batch (creazione)](create-project.md#create-project-console-batch-config)
+ [Configurazione in batch (aggiornamento)](change-project.md#change-project-console-batch-config)

## Ulteriori informazioni
<a name="batch_more_info"></a>

Per ulteriori informazioni, consulta i seguenti argomenti:
+ [Riferimento buildspec per la compilazione in batch](batch-build-buildspec.md)
+ [Configurazione Batch](create-project.md#create-project-console-batch-config)
+ [Esegui una build in batch (AWS CLI)](run-batch-build-cli.md)
+ [Interrompi gli accumuli in batch AWS CodeBuild](stop-batch-build.md)