

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

# Gruppi di report
<a name="test-report-group"></a>

Un *gruppo di report* contiene i report di test e specifica le impostazioni condivise. Il file buildspec consente di specificare i casi di test con i comandi da eseguire al momento della compilazione. Un'esecuzione del progetto di compilazione crea un report di test per ogni gruppo di report in esso configurato. Più esecuzioni di un progetto di compilazione configurato con un gruppo di report creano più report di test nello stesso gruppo, ciascuno contenente i risultati dei casi di test specificati. 

 I casi di test afferenti a un gruppo di report sono indicati nel file buildspec di un progetto di compilazione. È possibile specificare fino a cinque gruppi di report, in un progetto di compilazione. In concomitanza con l'avvio di una compilazione, vengono eseguiti tutti i casi di test. Per ogni caso di test associato a un gruppo di report viene creato un nuovo report di test con i risultati. Ogni volta che si effettua una nuova compilazione, vengono eseguiti tutti i casi di test, i cui risultati vanno a generare un inedito report di test. 

 I gruppi di report possono essere utilizzati in più di un progetto di compilazione. Tutti i report di test creati con un gruppo di report condividono la stessa configurazione, ad esempio l'opzione di esportazione e le autorizzazioni, anche se generati da progetti di compilazione diversi. I report di test creati con un gruppo di report in più progetti di compilazione possono contenere i risultati derivanti dall'esecuzione di vari set di casi di test (un set per ogni progetto di compilazione). Questo perché è possibile specificare diversi file di casi di test per il gruppo di report nel file buildspec di ogni progetto. È inoltre possibile modificare i file dei casi di test per un gruppo di report in un progetto di compilazione, aggiornandone il file buildspec. Le esecuzioni di compilazione successive creeranno, quindi, nuovi report di test contenenti i risultati relativi ai file dei casi di test nel buildspec aggiornato. 

**Topics**
+ [Creazione di un gruppo di report](report-group-create.md)
+ [Denominazione dei gruppi di report](test-report-group-naming.md)
+ [Condividi gruppi di report](report-groups-sharing.md)
+ [Specifica dei file di test](report-group-test-cases.md)
+ [Specifica dei comandi di test](report-group-test-case-commands.md)
+ [Aggiungi tag a un gruppo di report in AWS CodeBuild](how-to-tag-report-group.md)
+ [Aggiornamento di un gruppo di report](report-group-export-settings.md)

# Creazione di un gruppo di report
<a name="report-group-create"></a>

 È possibile utilizzare la CodeBuild console AWS CLI, il o un file buildspec per creare un gruppo di report. Il ruolo IAM deve disporre delle autorizzazioni necessarie per creare un gruppo di report. Per ulteriori informazioni, consulta [Autorizzazioni per il rapporto di prova](test-permissions.md). 

**Topics**
+ [Creazione di un gruppo di report (buildspec)](#test-report-group-create-buildspec)
+ [Creazione di un gruppo di report (console)](#test-report-group-create-console)
+ [Creazione di un gruppo di report (CLI)](#test-report-group-create-cli)
+ [Creazione di un gruppo di report (CloudFormation)](#test-report-group-create-cfn)

## Creazione di un gruppo di report (buildspec)
<a name="test-report-group-create-buildspec"></a>

Un gruppo di report creato utilizzando buildspec non esporta i file dei risultati dei test non elaborati. È possibile visualizzare il gruppo di report e specificare le impostazioni di esportazione. Per ulteriori informazioni, consulta [Aggiornamento di un gruppo di report](report-group-export-settings.md). 

**Come creare un gruppo di report utilizzando un file buildspec**

1.  Scegli un nome di gruppo di rapporti che non sia associato a un gruppo di rapporti nel tuo account. AWS 

1.  Configurare la sezione `reports` del file buildspec con tale nome. In questo esempio, il nome del gruppo di report è `new-report-group` e i casi di test d'uso vengono creati con il JUnit framework: 

   ```
   reports:
    new-report-group: #surefire junit reports
      files:
        - '**/*'
      base-directory: 'surefire/target/surefire-reports'
   ```

   Il nome del gruppo di report può anche essere specificato utilizzando le variabili di ambiente nel buildspec:

   ```
   version: 0.2
   env:
     variables:
       REPORT_GROUP_NAME: "new-report-group"
   phases:
     build:
       commands:
         - ...
   ...
   reports:
    $REPORT_GROUP_NAME:
      files:
        - '**/*'
      base-directory: 'surefire/target/surefire-reports'
   ```

    Per ulteriori informazioni, consultare [Specifica dei file di test](report-group-test-cases.md) e [Reports syntax in the buildspec file](build-spec-ref.md#reports-buildspec-file). 

1. Nella sezione `commands`, specificare il comando di esecuzione dei test. Per ulteriori informazioni, consulta [Specifica dei comandi di test](report-group-test-case-commands.md). 

1.  Eseguire la compilazione. Al termine della compilazione, viene creato un nuovo gruppo di report con un nome che utilizza il formato `project-name-report-group-name`. Per ulteriori informazioni, consulta [Denominazione dei gruppi di report](test-report-group-naming.md). 



## Creazione di un gruppo di report (console)
<a name="test-report-group-create-console"></a>

Utilizzare la procedura seguente per creare un gruppo di report utilizzando. Console di gestione AWS

**Per creare un gruppo di report**

1. Apri la AWS CodeBuild console su [https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home).

1. Nel riquadro di navigazione, scegliere **Report groups (Gruppi di report)**. 

1. Selezionare **Create report group (Crea gruppo di report)**. 

1. Immettere un nome per il proprio gruppo di report in **Report group name (Nome gruppo di report)**. 

1. (Facoltativo) Per i **tag**, inserisci il nome e il valore di tutti i tag che desideri vengano utilizzati dai AWS servizi di supporto. Utilizzare **Add row (Aggiungi riga)** per aggiungere un tag. Puoi aggiungere fino a 50 tag. 

1. Se desideri caricare i dati grezzi dei risultati del rapporto di test in un bucket Amazon S3: 

   1. Seleziona **Esporta in Amazon S3**. 

   1. Immettere il nome del proprio bucket S3 in **S3 bucket name (Nome bucket S3)**. 

   1. (Facoltativo) Per il **proprietario del bucket S3**, inserisci l'identificatore dell' AWS account che possiede il bucket S3. In questo modo i dati dei report possono essere esportati in un bucket Amazon S3 di proprietà di un account diverso dall'account che esegue la compilazione. 

   1. Per **Path prefix (Prefisso percorso)**, immettere il percorso di caricamento dei risultati del test nel bucket S3. 

   1. Per comprimere i file di dati non elaborati con i risultati del test, selezionare **Compress test result data in a zip file (Comprimi risultati test in file zip)**. 

   1. Per visualizzare le opzioni di crittografia, espandere **Additional configuration (Configurazione aggiuntiva)**. Seleziona una delle seguenti opzioni: 
      + **Chiave AWS gestita predefinita** da utilizzare Chiave gestita da AWS per Amazon S3. Per ulteriori informazioni, consulta [Customer managed CMKs](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk) in the *AWS Key Management Service User Guide*. Questa è l'opzione di crittografia predefinita.
      + **Scegli una chiave personalizzata** per utilizzare una chiave gestita dal cliente che crei e configuri. In **AWS KMS encryption key (Chiave di crittografia )**, immettere l'ARN della chiave di crittografia. Il formato è: ` arn:aws:kms:<region-id>: <aws-account-id>:key/<key-id> `. Per ulteriori informazioni, consulta [Creazione di chiavi KMS](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) nella *Guida per l'utente di AWS Key Management Service *. 
      + **Disable artifact encryption (Disabilita crittografia artefatti)** consente di disabilitare la crittografia. Bisogna scegliere questa opzione se si desidera condividere i risultati dei test o pubblicarli su un sito Web statico. (Un sito Web dinamico può eseguire codice per decrittare i risultati dei test.)

      Per ulteriori informazioni sulla crittografia dei dati inattivi, consulta [Crittografia dei dati](security-encryption.md). 
**Nota**  
Il ruolo CodeBuild di servizio specificato nel progetto viene utilizzato per le autorizzazioni di caricamento nel bucket S3.

1. Selezionare **Create report group (Crea gruppo di report)**.

## Creazione di un gruppo di report (CLI)
<a name="test-report-group-create-cli"></a>

Utilizza la procedura seguente per creare un gruppo di report utilizzando. AWS CLI

**Per creare un gruppo di report**

1. Crea un file denominato `CreateReportGroup.json`.

1. A seconda delle esigenze, copiare uno dei seguenti frammenti di codice JSON in `CreateReportGroup.json`: 
   + Utilizza il seguente codice JSON per specificare che il gruppo di report di test esporta i file dei risultati dei test non elaborati in un bucket Amazon S3. 

     ```
     {
       "name": "<report-name>",
       "type": "TEST",
       "exportConfig": {
         "exportConfigType": "S3",
         "s3Destination": {
           "bucket": "<bucket-name>",
           "bucketOwner": "<bucket-owner>",
           "path": "<path>",
           "packaging": "NONE | ZIP",
           "encryptionDisabled": "false",
           "encryptionKey": "<your-key>"
         },
         "tags": [
           {
             "key": "tag-key",
             "value": "tag-value"
           }
         ]
       }
     }
     ```
     + Sostituiscilo *<bucket-name>* con il nome del bucket Amazon S3 e *<path>* con il percorso nel bucket verso cui desideri esportare i file. 
     + Se si desidera comprimere i file esportati, in `packaging` specificare `ZIP`. In caso contrario, specificare `NONE`. 
     + `bucketOwner`è facoltativo ed è richiesto solo se il bucket Amazon S3 è di proprietà di un account diverso dall'account che esegue la build.
     + Utilizzare `encryptionDisabled` per stabilire se crittografare i file esportati. Se crittografi i file esportati, inserisci la chiave gestita dal cliente. Per ulteriori informazioni, consulta [Aggiornamento di un gruppo di report](report-group-export-settings.md).
   + Il seguente JSON consente di specificare che il report di test non esporti file di test grezzi: 

     ```
     {
       "name": "<report-name>",
       "type": "TEST",
       "exportConfig": {
         "exportConfigType": "NO_EXPORT"
       }
     }
     ```
**Nota**  
Il ruolo CodeBuild di servizio specificato nel progetto viene utilizzato per le autorizzazioni di caricamento nel bucket S3.

1. Esegui il comando seguente: 

   ```
   aws codebuild create-report-group --cli-input-json file://CreateReportGroupInput.json
   ```

## Creazione di un gruppo di report (CloudFormation)
<a name="test-report-group-create-cfn"></a>

Utilizza le seguenti istruzioni per creare un gruppo di report utilizzando il modello CloudFormation 

 **Per creare un gruppo di report utilizzando il CloudFormation modello** 

 È possibile utilizzare un file CloudFormation modello per creare ed eseguire il provisioning di un gruppo di report. Per ulteriori informazioni, consulta la [Guida per l'utente di CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html). 

 Il seguente modello CloudFormation YAML crea un gruppo di report che non esporta file di risultati di test non elaborati. 

```
Resources:
  CodeBuildReportGroup:
    Type: AWS::CodeBuild::ReportGroup
    Properties:
      Name: my-report-group-name
      Type: TEST
      ExportConfig:
        ExportConfigType: NO_EXPORT
```

 Il seguente modello CloudFormation YAML crea un gruppo di report che esporta file di risultati di test non elaborati in un bucket Amazon S3. 

```
Resources:
  CodeBuildReportGroup:
    Type: AWS::CodeBuild::ReportGroup
    Properties:
      Name: my-report-group-name
      Type: TEST
      ExportConfig:
        ExportConfigType: S3
        S3Destination:
          Bucket: amzn-s3-demo-bucket
          Path: path-to-folder-for-exported-files
          Packaging: ZIP
          EncryptionKey: my-KMS-encryption-key
          EncryptionDisabled: false
```

**Nota**  
Il ruolo CodeBuild di servizio specificato nel progetto viene utilizzato per le autorizzazioni di caricamento nel bucket S3.

# Denominazione dei gruppi di report
<a name="test-report-group-naming"></a>

 Quando si utilizza la console AWS CLI o la AWS CodeBuild console per creare un gruppo di report, si specifica un nome per il gruppo di report. Se per la creazione ci si avvale del buildspec, il nome del nuovo gruppo presenta il formato `project-name-report-group-name-specified-in-buildspec`. Tutti i report creati eseguendo compilazioni dello stesso progetto appartengono al gruppo di report con il nuovo nome. 

 Se non desideri CodeBuild creare un nuovo gruppo di report, specifica l'ARN del gruppo di report nel file buildspec di un progetto di build. È possibile specificare l'ARN di uno stesso gruppo di report in più progetti di compilazione. Il gruppo di report, in tal caso, conterrà i report di test creati da ciascun progetto di compilazione a esecuzione avvenuta. 

 Ad esempio, se si crea un gruppo di report con il nome `my-report-group` e poi si utilizza tale nome in due diversi progetti di compilazione denominati `my-project-1` e `my-project-2` e, infine, si imposta una compilazione per entrambi i progetti, vengono creati due nuovi gruppi di report. Il risultato consiste in tre gruppi di report con i seguenti nomi: 
+  `my-report-group`: non annovera report di test. 
+  `my-project-1-my-report-group`: contiene i rapporti con i risultati dei test eseguiti dal progetto di compilazione denominato `my-project-1`. 
+  `my-project-2-my-report-group`: contiene i rapporti con i risultati dei test eseguiti dal progetto di compilazione denominato `my-project-2`. 

 Se si utilizza l'ARN del gruppo di report denominato `my-report-group` in entrambi i progetti e poi si eseguono le compilazioni di ciascun progetto, si dispone ancora di un unico gruppo di report (`my-report-group`). Tale gruppo di report contiene i rapporti con i risultati dei test eseguiti da entrambi i progetti di compilazione. 

 Se si sceglie un nome di gruppo di report che non appartiene a un gruppo presente nel proprio account AWS e lo si specifica in un file buildspec, eseguendo una compilazione del progetto correlato viene creato un nuovo gruppo di report. Il formato del nome del nuovo gruppo di report è `project-name-new-group-name`. Ad esempio, se nel tuo AWS account non è presente un gruppo di report con il nome `new-report-group` e specificalo in un progetto di compilazione chiamato`test-project`, un'esecuzione di build crea un nuovo gruppo di report con lo stesso nome. `test-project-new-report-group` 

# Condividi gruppi di report
<a name="report-groups-sharing"></a>

La condivisione di gruppi di report consente a più AWS account o utenti di visualizzare un gruppo di report, i report non scaduti e i risultati dei test dei relativi report. In questo modello, l'account titolare (proprietario) condivide il proprio gruppo di report con altri account (consumatori). Un consumatore non può modificare il gruppo di report. Un rapporto scade 30 giorni dopo la creazione.

**Topics**
+ [Condividi un gruppo di report](#report-groups-sharing-share)
+ [Servizi correlati](#report-groups-sharing-related)
+ [Accedi ai gruppi di report condivisi con te](report-groups-sharing-access-prereqs.md)
+ [Annullare la condivisione di un gruppo di report condiviso](report-groups-sharing-unshare.md)
+ [Identifica un gruppo di report condiviso](report-groups-sharing-identify.md)
+ [Autorizzazioni per il gruppo di report condiviso](report-groups-sharing-perms.md)

## Condividi un gruppo di report
<a name="report-groups-sharing-share"></a>

 Quando si condivide un gruppo di report, al consumatore viene concesso l'accesso in sola lettura al gruppo e ai relativi report. Il consumatore può utilizzare il AWS CLI per visualizzare il gruppo di report, i relativi report e i risultati del test case per ogni rapporto. Il consumatore non può: 
+  Visualizza un gruppo di report condiviso o i relativi report nella CodeBuild console. 
+  Modificare un gruppo di report condiviso. 
+  Utilizzare l'ARN del gruppo di report condiviso in un progetto, per eseguire un report. Una compilazione di progetto che specifica un gruppo di report condiviso ha esito negativo. 

È possibile utilizzare la CodeBuild console per aggiungere un gruppo di report a una condivisione di risorse esistente. La [console AWS RAM](https://console.aws.amazon.com/ram), invece, permette di creare appositamente una nuova condivisione di risorse per il gruppo di report.

Per condividere un gruppo di report con unità organizzative o un'intera organizzazione, è necessario abilitare la condivisione con AWS Organizations. Per ulteriori informazioni, consulta [Abilitare la condivisione con AWS Organizations](https://docs.aws.amazon.com/ram/latest/userguide/getting-started-sharing.html) nella *Guida per l’utente di AWS RAM *.

Puoi utilizzare la CodeBuild console, la AWS RAM console o AWS CLI per condividere i gruppi di report di cui sei proprietario.

**Prerequisito**  
Per condividere un gruppo di report, il tuo AWS account deve possederlo. Un consumatore non può condividere il gruppo di report a cui ha avuto accesso.

**Per condividere un gruppo di report di tua proprietà (CodeBuild console)**

1. Apri la AWS CodeBuild console su [https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home).

1. Nel riquadro di navigazione, scegliere **Report groups (Gruppi di report)**.

1.  Selezionare il progetto da condividere, poi fare clic su **Share (Condividi)**. Per ulteriori informazioni, consulta l'argomento relativo alla [creazione di una condivisione di risorse](https://docs.aws.amazon.com/ram/latest/userguide/getting-started-sharing.html#getting-started-sharing-create) nella *Guida per l'utente di AWS RAM *. 

**Per condividere i gruppi di report di cui sei proprietario (console)AWS RAM**  
Consulta [Creating a resource share](https://docs.aws.amazon.com/ram/latest/userguide/working-with-sharing.html#working-with-sharing-create) in *Guida per l’utente di AWS RAM *.

**Per condividere i gruppi di report di cui sei proprietario (AWS RAM comando)**  
Utilizza il comando [create-resource-share](https://docs.aws.amazon.com/cli/latest/reference/ram/create-resource-share.html).

 **Per condividere un gruppo di report di tua proprietà (CodeBuild comando)** 

Utilizza il comando [put-resource-policy](https://docs.aws.amazon.com/cli/latest/reference/codebuild/put-resource-policy.html):

1. Creare un file denominato `policy.json` e copiarvi quanto segue. 

------
#### [ JSON ]

****  

   ```
   {
      "Version":"2012-10-17",		 	 	 
      "Statement":[{
        "Effect":"Allow",
        "Principal":{
          "AWS":"111122223333"
        },
        "Action":[
          "codebuild:BatchGetReportGroups",
          "codebuild:BatchGetReports",
          "codebuild:ListReportsForReportGroup",
          "codebuild:DescribeTestCases"],
        "Resource":"arn:aws:iam::*:role/Service*"
      }]
    }
   ```

------

1. Aggiornare `policy.json` con l'ARN del gruppo di report e gli identificatori da coinvolgere nella condivisione. L'esempio seguente concede l'accesso in sola lettura al gruppo di report con l'ARN ad Alice e all'utente root `arn:aws:codebuild:us-west-2:123456789012:report-group/my-report-group` per l'account identificato da 123456789012. AWS 

------
#### [ JSON ]

****  

   ```
   {
      "Version":"2012-10-17",		 	 	 
      "Statement":[{
        "Effect":"Allow",
        "Principal":{
          "AWS": [
             "arn:aws:iam::123456789012:user/Alice",
             "123456789012"
           ]
        },
        "Action":[
          "codebuild:BatchGetReportGroups",
          "codebuild:BatchGetReports",
          "codebuild:ListReportsForReportGroup",
          "codebuild:DescribeTestCases"],
        "Resource":"arn:aws:codebuild:us-west-2:123456789012:report-group/my-report-group"
      }]
    }
   ```

------

1. Eseguire il seguente comando seguente. 

   ```
   aws codebuild put-resource-policy --resource-arn report-group-arn --policy file://policy.json
   ```

## Servizi correlati
<a name="report-groups-sharing-related"></a>

La condivisione dei gruppi di report si integra con AWS Resource Access Manager (AWS RAM), un servizio che consente di condividere le risorse con qualsiasi account o tramite. AWS AWS AWS Organizations Con AWS RAM, condividi le risorse di tua proprietà creando una *condivisione di risorse* che specifica le risorse e i consumatori con cui condividerle. I consumatori possono appartenere a singoli AWS account AWS Organizations, a unità organizzative o a AWS Organizations un'intera organizzazione.

Per ulteriori informazioni, consulta la *Guida per l'utente [AWS RAM](https://docs.aws.amazon.com/ram/latest/userguide/)*.

# Accedi ai gruppi di report condivisi con te
<a name="report-groups-sharing-access-prereqs"></a>

Un consumatore può accedere a un gruppo di report condiviso solo se il suo ruolo IAM dispone dell'autorizzazione `BatchGetReportGroups`. Puoi allegare la seguente policy al loro ruolo IAM: 

```
{
    "Effect": "Allow",
    "Resource": [
        "*"
    ],
    "Action": [
        "codebuild:BatchGetReportGroups"
    ]
}
```

 Per ulteriori informazioni, consulta [Utilizzo di politiche basate sull'identità per AWS CodeBuild](auth-and-access-control-iam-identity-based-access-control.md). 

# Annullare la condivisione di un gruppo di report condiviso
<a name="report-groups-sharing-unshare"></a>

Annullandone la condivisione, a un gruppo di report con i relativi report e risultati dei casi di test può accedere solo il proprietario. Se annulli la condivisione di un gruppo di report, qualsiasi AWS account o utente con cui lo hai condiviso in precedenza non può accedere al gruppo di report, ai relativi report o ai risultati dei test case contenuti nei report.

Per annullare, basta rimuovere il gruppo di report di proprietà dalla relativa condivisione di risorse. Puoi usare la AWS RAM console o AWS CLI farlo.

**Per annullare la condivisione di un gruppo di report condiviso di tua proprietà (AWS RAM console)**  
Consulta [Aggiornamento di una condivisione di risorse](https://docs.aws.amazon.com/ram/latest/userguide/working-with-sharing.html#working-with-sharing-update) nella *Guida per l’utente di AWS RAM *.

**Per annullare la condivisione di un gruppo di report condiviso di cui sei proprietario (comando)AWS RAM**  
Utilizza il comando [disassociate-resource-share](https://docs.aws.amazon.com/cli/latest/reference/ram/disassociate-resource-share.html).

 **Per annullare la condivisione di un gruppo di report di cui sei proprietario CodeBuild (comando)** 

Esegui il [delete-resource-policy](https://docs.aws.amazon.com/cli/latest/reference/codebuild/delete-resource-policy.html)comando e specifica l'ARN del gruppo di report che desideri annullare la condivisione:

```
aws codebuild delete-resource-policy --resource-arn report-group-arn
```

# Identifica un gruppo di report condiviso
<a name="report-groups-sharing-identify"></a>

Proprietari e consumatori possono AWS CLI utilizzarlo per identificare gruppi di report condivisi. 

I comandi seguenti consentono di identificare e ottenere informazioni su un gruppo condiviso e i relativi report: 
+  Per vedere i gruppi ARNs di report condivisi con te, esegui`[list-shared-report-groups](https://docs.aws.amazon.com/cli/latest/reference/codebuild/list-shared-report-groups.html)`: 

  ```
  aws codebuild list-shared-report-groups
  ```
+  Per visualizzare i report in un gruppo ARNs di report, esegui `[list-reports-for-report-group](https://docs.aws.amazon.com/cli/latest/reference/codebuild/list-reports-for-report-group.html)` utilizzando il gruppo di report ARN: 

  ```
  aws codebuild list-reports-for-report-group --report-group-arn report-group-arn
  ```
+  Per visualizzare le informazioni relative ai casi di test in un report, occorre eseguire `[describe-test-cases](https://docs.aws.amazon.com/cli/latest/reference/codebuild/describe-test-cases.html)` utilizzando l'ARN del report: 

  ```
  aws codebuild describe-test-cases --report-arn report-arn
  ```

   L'output sarà simile al seguente: 

  ```
  {
      "testCases": [
          {
              "status": "FAILED",
              "name": "Test case 1",
              "expired": 1575916770.0,
              "reportArn": "report-arn",
              "prefix": "Cucumber tests for agent",
              "message": "A test message",
              "durationInNanoSeconds": 1540540,
              "testRawDataPath": "path-to-output-report-files"
          },
          {
              "status": "SUCCEEDED",
              "name": "Test case 2",
              "expired": 1575916770.0,
              "reportArn": "report-arn",
              "prefix": "Cucumber tests for agent",
              "message": "A test message",
              "durationInNanoSeconds": 1540540,
              "testRawDataPath": "path-to-output-report-files"
          }
      ]
  }
  ```

# Autorizzazioni per il gruppo di report condiviso
<a name="report-groups-sharing-perms"></a>

## Autorizzazioni per i proprietari
<a name="report-groups-perms-owner"></a>

Un proprietario può modificare il gruppo di report e specificarlo in un progetto per l'esecuzione dei report.

## Autorizzazioni per gli utenti
<a name="report-groups-perms-consumer"></a>

Un consumatore può visualizzare il gruppo con i relativi report e risultati dei casi di test. Un consumatore non può modificare il gruppo di report (o i relativi report) né utilizzarlo per creare altri report.

# Specifica dei file di test
<a name="report-group-test-cases"></a>

 I file dei risultati dei test e la relativa posizione per ogni gruppo di report vanno specificati nella sezione `reports` del file buildspec afferente al progetto di compilazione. Per ulteriori informazioni, consulta [Reports syntax in the buildspec file](build-spec-ref.md#reports-buildspec-file). 

 Di seguito è riportata una sezione `reports` di esempio che specifica due gruppi di report per un progetto di compilazione. Uno è specificato con il suo ARN, l'altro con un nome. La sezione `files` specifica i file contenenti i risultati dei casi di test. La sezione facoltativa `base-directory` specifica la directory in cui si trovano i file dei casi di test. La `discard-paths` sezione facoltativa specifica se i percorsi dei file dei risultati dei test caricati su un bucket Amazon S3 vengono eliminati. 

```
reports:
  arn:aws:codebuild:your-region:your-aws-account-id:report-group/report-group-name-1: #surefire junit reports
    files:
      - '**/*'
    base-directory: 'surefire/target/surefire-reports'
    discard-paths: false
    
  sampleReportGroup: #Cucumber reports from json plugin
    files:
      - 'cucumber-json/target/cucumber-json-report.json'
    file-format: CUCUMBERJSON #Type of the report, defaults to JUNITXML
```

# Specifica dei comandi di test
<a name="report-group-test-case-commands"></a>

 È possibile specificare i comandi che eseguono i casi di test nella sezione `commands` del proprio file buildspec. Questi comandi eseguono i casi di test previsti per i gruppi di report nella sezione `reports` del file buildspec. Di seguito è riportata una sezione `commands` esemplificativa che include i comandi per l'esecuzione dei test nei file di test: 

```
commands:
    - echo Running tests for surefire junit
    - mvn test -f surefire/pom.xml -fn
    - echo
    - echo Running tests for cucumber with json plugin
    - mvn test -Dcucumber.options="--plugin json:target/cucumber-json-report.json" -f cucumber-json/pom.xml -fn
```

Per ulteriori informazioni, consulta [Sintassi buildspec](build-spec-ref.md#build-spec-ref-syntax).

# Aggiungi tag a un gruppo di report in AWS CodeBuild
<a name="how-to-tag-report-group"></a>

Un *tag* è un'etichetta di attributo personalizzata che l'utente o AWS assegna a una AWS risorsa. Ogni AWS tag è composto da due parti:
+ Una *chiave di tag* (ad esempio, `CostCenter`, `Environment`, `Project` o `Secret`). Le chiavi dei tag distinguono tra maiuscole e minuscole
+ Un campo facoltativo noto come *valore del tag* (ad esempio, `111122223333`, `Production` o un nome di team). Non specificare il valore del tag equivale a utilizzare una stringa vuota. Come le chiavi tag, i valori dei tag fanno distinzione tra maiuscole e minuscole.

Tutti questi sono noti come coppie chiave-valore. Per conoscere i possibili limiti sul numero di tag in un gruppo di report e le limitazioni di chiavi e valori di tag, consulta [Tag](limits.md#tag-limits).

I tag ti aiutano a identificare e organizzare AWS le tue risorse. Molti AWS servizi supportano l'etichettatura, quindi puoi assegnare lo stesso tag a risorse di servizi diversi per indicare che le risorse sono correlate. Ad esempio, puoi assegnare lo stesso tag a un gruppo di CodeBuild report che assegni a un bucket Amazon S3. Per ulteriori informazioni sull'utilizzo dei tag, consulta il whitepaper [Tagging best practices](https://d1.awsstatic.com/whitepapers/aws-tagging-best-practices.pdf) (Best practice relative al tagging). 

In CodeBuild, le risorse principali sono il gruppo di report e il progetto. È possibile utilizzare la CodeBuild console AWS CLI CodeBuild APIs, o AWS SDKs per aggiungere, gestire e rimuovere tag per un gruppo di report. Oltre a identificare, organizzare e tracciare il gruppo di report con i tag, puoi utilizzare i tag nelle policy IAM per controllare chi può visualizzare e interagire con il tuo gruppo di report. Per esempi di policy di accesso basate su tag, consulta [Utilizzo dei tag per controllare l'accesso alle AWS CodeBuild risorse](auth-and-access-control-using-tags.md).

**Topics**
+ [Aggiungi tag a un gruppo di report](how-to-tag-report-group-add.md)
+ [Visualizzazione dei tag per un gruppo di report](how-to-tag-report-group-list.md)
+ [Modifica tag per un gruppo di report](how-to-tag-report-group-update.md)
+ [Rimuovere i tag da un gruppo di report](how-to-tag-report-group-delete.md)

# Aggiungi tag a un gruppo di report
<a name="how-to-tag-report-group-add"></a>

L'aggiunta di tag a un gruppo di report può aiutarti a identificare e organizzare AWS le tue risorse e a gestirne l'accesso. In primo luogo, è possibile aggiungere uno o più tag (coppie chiave-valore) a un gruppo di report. Non dimenticare che esistono limiti sul numero di tag che è possibile applicare a un gruppo di report. Esistono limitazioni per i caratteri che è possibile utilizzare nei campi chiave e valore. Per ulteriori informazioni, consulta [Tag](limits.md#tag-limits). Dopo aver creato i tag, puoi creare policy IAM per gestire l'accesso al gruppo di report in base a questi tag. Puoi utilizzare la CodeBuild console o aggiungere tag AWS CLI a un gruppo di report. 

**Importante**  
L'aggiunta di tag a un gruppo di report può influire sull'accesso a tale gruppo di report. Prima di aggiungere un tag a un gruppo di report, assicurati di esaminare eventuali policy IAM che potrebbero utilizzare i tag per controllare l'accesso a risorse come i gruppi di report. Per esempi di policy di accesso basate su tag, consulta [Utilizzo dei tag per controllare l'accesso alle AWS CodeBuild risorse](auth-and-access-control-using-tags.md).

Per ulteriori informazioni sull'aggiunta di tag a un gruppo di report al momento della creazione, consulta [Creazione di un gruppo di report (console)](report-group-create.md#test-report-group-create-console).

**Topics**
+ [Aggiungere un tag a un gruppo di report (console)](#how-to-tag-report-group-add-console)
+ [Aggiungere un tag a un gruppo di report (AWS CLI)](#how-to-tag-report-group-add-cli)

## Aggiungere un tag a un gruppo di report (console)
<a name="how-to-tag-report-group-add-console"></a>

Puoi utilizzare la CodeBuild console per aggiungere uno o più tag a un gruppo di CodeBuild report. 

1. Apri la CodeBuild console all'indirizzo [https://console.aws.amazon.com/codebuild/](https://console.aws.amazon.com/codebuild/).

1. In **Gruppi di report**, scegliere il nome del gruppo di report a cui si desidera aggiungere tag.

1. Nel pannello di navigazione scegli **Impostazioni**.

1. Se non sono stati aggiunti tag al repository, scegliere **Aggiungi tag**. È inoltre possibile scegliere **Modifica** e quindi **Aggiungi tag**.

1. Per **Key (Chiave)**, inserire un nome per il tag. È possibile aggiungere un valore facoltativo al tag in **Value** (Valore). 

1. (Facoltativo) Per aggiungere un altro tag, scegliere **Add tag (Aggiungi tag)** .

1. Una volta completata l'aggiunta di tag, scegliere **Submit (Inoltra)**.

## Aggiungere un tag a un gruppo di report (AWS CLI)
<a name="how-to-tag-report-group-add-cli"></a>

Per aggiungere un tag a un gruppo di report quando lo si crea, vedere [Creazione di un gruppo di report (CLI)](report-group-create.md#test-report-group-create-cli). In `CreateReportGroup.json`, aggiungi i tuoi tag.

 Per aggiungere tag a un gruppo di report esistente, vedere [Aggiornamento di un gruppo di report (CLI)](report-group-export-settings.md#update-report-group-cli) e aggiungere i tag in `UpdateReportGroupInput.json`. 

In queste fasi, si assume che sia già installata una versione recente della AWS CLI o che sia aggiornata alla versione corrente. Per ulteriori informazioni, consultare [Installing the AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html).

# Visualizzazione dei tag per un gruppo di report
<a name="how-to-tag-report-group-list"></a>

I tag possono aiutarti a identificare e organizzare AWS le tue risorse e a gestirne l'accesso. Per ulteriori informazioni sull'utilizzo dei tag, consulta il whitepaper [Tagging best practices](https://d1.awsstatic.com/whitepapers/aws-tagging-best-practices.pdf) (Best practice relative al tagging). Per esempi di policy di accesso basate su tag, consulta [Deny or allow actions on report groups based on resource tags](auth-and-access-control-using-tags.md#report-group-tag-policy-example).

## Visualizzazione dei tag per un gruppo di report (console)
<a name="how-to-tag-report-group-list-console"></a>

Puoi utilizzare la CodeBuild console per visualizzare i tag associati a un gruppo di CodeBuild report. 

1. Apri la CodeBuild console all'indirizzo [https://console.aws.amazon.com/codebuild/](https://console.aws.amazon.com/codebuild/).

1. In **Gruppi di report**, scegliere il nome del gruppo di report in cui si desidera visualizzare i tag.

1. Nel pannello di navigazione scegli **Impostazioni**.

## Visualizzazione dei tag per un gruppo di report (AWS CLI)
<a name="how-to-tag-report-group-list-cli"></a>

Segui questi passaggi per utilizzare AWS CLI per visualizzare i AWS tag per un gruppo di report. Se non sono stati aggiunti tag, l'elenco restituito è vuoto.

1.  Usa la console o il AWS CLI per individuare l'ARN del tuo gruppo di report. Prendere nota del valore. 

------
#### [ AWS CLI ]

    Eseguire il seguente comando seguente. 

   ```
   aws list-report-groups
   ```

    Questo comando restituisce informazioni in formato JSON simili alle seguenti: 

   ```
   {
       "reportGroups": [
           "arn:aws:codebuild:region:123456789012:report-group/report-group-1",
           "arn:aws:codebuild:region:123456789012:report-group/report-group-2",
           "arn:aws:codebuild:region:123456789012:report-group/report-group-3"
       ]
   }
   ```

   Un gruppo di report ARN termina con il relativo nome, che è possibile utilizzare per identificare l'ARN per il gruppo di report.

------
#### [ Console ]

   1. Apri la CodeBuild console all'indirizzo [https://console.aws.amazon.com/codebuild/](https://console.aws.amazon.com/codebuild/).

   1. In **Gruppi di report**, scegliere il nome del gruppo di report con i tag che si desidera visualizzare.

   1.  In **Configurazione** individuare l'ARN del gruppo di report. 

------

1.  Eseguire il seguente comando seguente. Utilizzate l'ARN di cui hai preso nota per il parametro `--report-group-arns`. 

   ```
   aws codebuild batch-get-report-groups --report-group-arns arn:aws:codebuild:region:123456789012:report-group/report-group-name
   ```

    In caso di esito positivo, questo comando restituisce informazioni in formato JSON che contengono una sezione `tags` simile alla seguente: 

   ```
   {
       ...                        
       "tags": {
           "Status": "Secret",
           "Project": "TestBuild"
       }
       ...
   }
   ```

# Modifica tag per un gruppo di report
<a name="how-to-tag-report-group-update"></a>

È possibile modificare il valore di un tag associato a un gruppo di report. Puoi anche cambiare il nome della chiave, il che equivale a rimuovere il tag corrente e aggiungerne uno diverso con il nuovo nome e lo stesso valore dell'altra chiave. Tieni presente che esistono limitazioni sui caratteri che è possibile utilizzare nei campi chiave e valore. Per ulteriori informazioni, consulta [Tag](limits.md#tag-limits).

**Importante**  
La modifica dei tag per un gruppo di report può influire sull'accesso a tale gruppo di report. Prima di modificare il nome (chiave) o il valore di un tag per un gruppo di report, assicurati di esaminare eventuali policy IAM che potrebbero utilizzare la chiave o il valore di un tag per controllare l'accesso a risorse come i gruppi di report. Per esempi di policy di accesso basate su tag, consulta [Deny or allow actions on report groups based on resource tags](auth-and-access-control-using-tags.md#report-group-tag-policy-example).

## Modificare un tag per un gruppo di report (console)
<a name="how-to-tag-report-group-update-console"></a>

Puoi utilizzare la CodeBuild console per modificare i tag associati a un gruppo di CodeBuild report. 

1. Apri la CodeBuild console all'indirizzo [https://console.aws.amazon.com/codebuild/](https://console.aws.amazon.com/codebuild/).

1. In **Gruppi di report**, scegliere il nome del gruppo di report in cui si desidera modificare i tag.

1. Nel pannello di navigazione scegli **Impostazioni**.

1. Scegli **Modifica**.

1. Esegui una delle seguenti operazioni:
   + Per modificare il tag, immettere un nuovo nome in **Key (Chiave)**. La modifica del nome del tag equivale alla sostituzione del tag esistente con un nuovo tag che ha un nuovo nome chiave.
   + Per modificare il valore di un tag, immettere un nuovo valore. Se si desidera modificare il valore in un valore vuoto, eliminare il valore corrente e lasciare il campo vuoto.

1. Al termine delle modifiche dei tag, scegliere **Submit (Inoltra)**.

## Modifica tag per un gruppo di report (AWS CLI)
<a name="how-to-tag-report-group-update-cli"></a>

 Per aggiungere, modificare o eliminare tag da un gruppo di report, vedere [Aggiornamento di un gruppo di report (CLI)](report-group-export-settings.md#update-report-group-cli). Aggiorna i tag in `UpdateReportGroupInput.json`. 

# Rimuovere i tag da un gruppo di report
<a name="how-to-tag-report-group-delete"></a>

È possibile rimuovere uno o più tag associati a un gruppo di report. La rimozione di un tag non elimina il tag dalle altre AWS risorse ad esso associate.

**Importante**  
La rimozione di tag per un gruppo di report può influire sull'accesso a tale gruppo di report. Prima di rimuovere un tag da un gruppo di report, assicurati di esaminare eventuali policy IAM che potrebbero utilizzare la chiave o il valore di un tag per controllare l'accesso a risorse come i gruppi di report. Per esempi di policy di accesso basate su tag, consulta [Utilizzo dei tag per controllare l'accesso alle AWS CodeBuild risorse](auth-and-access-control-using-tags.md).

## Rimuovere un tag da un gruppo di report (console)
<a name="how-to-tag-report-group-delete-console"></a>

Puoi utilizzare la CodeBuild console per rimuovere l'associazione tra un tag e un gruppo di CodeBuild report. 

1. Apri la CodeBuild console all'indirizzo [https://console.aws.amazon.com/codebuild/](https://console.aws.amazon.com/codebuild/).

1. In **Gruppi di report**, scegliere il nome del gruppo di report in cui si desidera rimuovere i tag.

1. Nel pannello di navigazione scegli **Impostazioni**.

1. Scegli **Modifica**.

1. Cercare il tag da rimuovere, quindi scegliere **Remove tag (Rimuovi tag)**.

1. Una volta terminata la rimozione di tag, scegliere **Submit (Inoltra)**.

## Rimuovere un tag da un gruppo di report (AWS CLI)
<a name="how-to-tag-report-group-delete-cli"></a>

Segui questi passaggi per AWS CLI rimuovere un tag da un gruppo di CodeBuild report. La rimozione di un tag non lo elimina completamente, ma rimuove semplicemente l'associazione tra il tag e il gruppo di report. 

**Nota**  
Se elimini un gruppo di CodeBuild report, tutte le associazioni di tag vengono rimosse dal gruppo di report eliminato. Non è necessario rimuovere i tag prima di eliminare un gruppo di report.

 Per eliminare uno o più tag da un gruppo di report, vedere [Modifica tag per un gruppo di report (AWS CLI)](how-to-tag-report-group-update.md#how-to-tag-report-group-update-cli). Aggiornare la sezione `tags` nei dati formattati JSON con un elenco aggiornato di tag che non contiene quelli che si desidera eliminare. Se si desidera eliminare tutti i tag, aggiornare la sezione `tags` per:

```
"tags: []"
```

# Aggiornamento di un gruppo di report
<a name="report-group-export-settings"></a>

 Quando aggiorni un gruppo di report, puoi specificare se esportare i dati non elaborati dei risultati del test in file in un bucket Amazon S3. Se si opta per l'esportazione in un bucket S3, è necessario specificare quanto segue per il gruppo di report: 
+ L'eventuale compressione in un file ZIP dei file con i risultati dei test non elaborati.
+ L'eventuale crittografia dei file con i risultati dei test non elaborati. È possibile definire la crittografia con una delle seguenti opzioni:
  + E Chiave gestita da AWS per Amazon S3. 
  + Una chiave gestita dal cliente che puoi creare e configurare.

Per ulteriori informazioni, consulta [Crittografia dei dati](security-encryption.md). 

Se utilizzi il AWS CLI per aggiornare un gruppo di report, puoi anche aggiornare o aggiungere tag. Per ulteriori informazioni, consulta [Aggiungi tag a un gruppo di report in AWS CodeBuildApplicazione di un tag a un gruppo di report](how-to-tag-report-group.md).

**Nota**  
Il ruolo CodeBuild di servizio specificato nel progetto viene utilizzato per le autorizzazioni al caricamento nel bucket S3.

**Topics**
+ [Aggiornamento di un gruppo di report (console)](#update-report-group-console)
+ [Aggiornamento di un gruppo di report (CLI)](#update-report-group-cli)

## Aggiornamento di un gruppo di report (console)
<a name="update-report-group-console"></a>

Utilizza la seguente procedura per aggiornare un gruppo di report utilizzando. Console di gestione AWS

**Per aggiornare un gruppo di report**

1. Apri la AWS CodeBuild console su [https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home).

1.  Nel riquadro di navigazione, scegliere **Report groups (Gruppi di report)**. 

1. Scegliere il gruppo di report da aggiornare. 

1. Scegli **Modifica**.

1. Seleziona o deseleziona **Backup su Amazon S3**. Con questa opzione selezionata, occorre specificare le impostazioni di esportazione:

   1. Immettere il nome del proprio bucket S3 in **S3 bucket name (Nome bucket S3)**. 

   1. Per **Path prefix (Prefisso percorso)**, immettere il percorso di caricamento dei risultati del test nel bucket S3. 

   1. Per comprimere i file di dati non elaborati con i risultati del test, selezionare **Compress test result data in a zip file (Comprimi risultati test in file zip)**. 

   1. Per visualizzare le opzioni di crittografia, espandere **Additional configuration (Configurazione aggiuntiva)**. Seleziona una delle seguenti opzioni: 
      + **Chiave AWS gestita predefinita** da utilizzare Chiave gestita da AWS per Amazon S3. Per ulteriori informazioni, consulta [Customer managed CMKs](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#customer-cmk) in the *AWS Key Management Service User Guide*. Questa è l'opzione di crittografia predefinita.
      + **Scegli una chiave personalizzata** per utilizzare una chiave gestita dal cliente che crei e configuri. In **AWS KMS encryption key (Chiave di crittografia )**, immettere l'ARN della chiave di crittografia. Il formato è: ` arn:aws:kms:<region-id>: <aws-account-id>:key/<key-id> `. Per ulteriori informazioni, consulta [Creazione di chiavi KMS](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) nella *Guida per l'utente di AWS Key Management Service *. 
      + **Disable artifact encryption (Disabilita crittografia artefatti)** consente di disabilitare la crittografia. Bisogna scegliere questa opzione se si desidera condividere i risultati dei test o pubblicarli su un sito Web statico. (Un sito Web dinamico può eseguire codice per decrittare i risultati dei test.)

## Aggiornamento di un gruppo di report (CLI)
<a name="update-report-group-cli"></a>

Utilizzare la procedura seguente per aggiornare un gruppo di report utilizzando AWS CLI.

**Per aggiornare un gruppo di report**

1. Crea un file denominato `UpdateReportGroupInput.json`.

1. Copiare quanto segue in `UpdateReportGroupInput.json`. 

   ```
   {
       "arn": "",
       "exportConfig": {
           "exportConfigType": "S3",
           "s3Destination": {
               "bucket": "bucket-name", 
               "path": "path", 
               "packaging": "NONE | ZIP",
               "encryptionDisabled": "false",
               "encryptionKey": "your-key"
            }
        },
        "tags": [
           {
               "key": "tag-key",
               "value": "tag-value"
           }
        ]
   }
   ```

1. Immettere l'ARN del gruppo di report nella riga `arn` (ad esempio, `"arn":"arn:aws:codebuild:region:123456789012:report-group/report-group-1")`) 

1. Aggiornare `UpdateReportGroupInput.json` con gli aggiornamenti che si desidera applicare al gruppo di report. 
   + Se si desidera aggiornare il gruppo di report per esportare i file dei risultati del test grezzi in un bucket S3, aggiornare la sezione `exportConfig`. Sostituiscilo `bucket-name` con il nome del bucket S3 e `path` con il percorso nel bucket S3 in cui desideri esportare i file. Se si desidera comprimere i file esportati, in `packaging` specificare `ZIP`. In caso contrario, specificare `NONE`. Utilizzare `encryptionDisabled` per stabilire se crittografare i file esportati. Se crittografi i file esportati, inserisci la chiave gestita dal cliente.
   + Se si desidera aggiornare il gruppo di report in modo che non esporti i file dei risultati dei test non elaborati in un bucket S3, aggiornare la sezione `exportConfig` con il seguente JSON: 

     ```
     { 
       "exportConfig": {
           "exportConfigType": "NO_EXPORT"
       }
     }
     ```
   + Se si desidera aggiornare i tag del gruppo di report, aggiornare la sezione `tags`. È possibile modificare, aggiungere o rimuovere tag. Se si desidera rimuovere tutti i tag, aggiornarlo con il seguente JSON: 

     ```
     "tags": []
     ```

1.  Esegui il comando seguente: 

   ```
   aws codebuild update-report-group \
   --cli-input-json file://UpdateReportGroupInput.json
   ```