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 la migrazione da CSE-KMS a SSE-KMS
<a name="migrating-csekms-ssekms"></a>

È possibile specificare la crittografia CSE-KMS in due modi: durante la configurazione della crittografia dei risultati delle query del gruppo di lavoro e nelle impostazioni lato client. Per ulteriori informazioni, consulta [Crittografare i risultati di query Athena archiviati in Amazon S3](encrypting-query-results-stored-in-s3.md). Durante il processo di migrazione, è importante controllare i flussi di lavoro esistenti che leggono e scrivono i dati CSE-KMS, identificare i gruppi di lavoro in cui è configurato CSE-KMS e individuare le istanze in cui CSE-KMS è impostato tramite parametri lato client.

## Aggiorna le impostazioni di crittografia dei risultati delle interrogazioni del gruppo di lavoro
<a name="migrating-updating-workgroup-query-results-encryption"></a>

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

**Per aggiornare le impostazioni di crittografia nella console Athena**

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

1. Nel pannello di navigazione della console Athena, scegli **Workgroups** (Gruppi di lavoro).

1. Nella pagina **Workgroups** (Gruppi di lavoro), seleziona il gruppo di lavoro da modificare. 

1. Scegli **Actions (Operazioni)**, **Edit (Modifica)**.

1. Aprire **Query result configuration** e scegliere **Encrypt query results**.

1. Per la sezione **Encryption typea**, scegliere l’opzione di crittografia **SSE\$1KMS**.

1. Inserisci la tua chiave KMS in **Choose a different AWS KMS key (advanced)**.

1. Scegli **Save changes** (Salva modifiche). Il gruppo di lavoro aggiornato viene visualizzato nell'elenco nella pagina **Workgroups** (Gruppi di lavoro).

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

Eseguire questo comando per aggiornare la configurazione della crittografia dei risultati della query a SSE-KMS nel proprio gruppo di lavoro.

```
aws athena update-work-group \
    --work-group "my-workgroup" \
    --configuration-updates '{
        "ResultConfigurationUpdates": {
            "EncryptionConfiguration": {
                "EncryptionOption": "SSE_KMS",
                "KmsKey": "<my-kms-key>"
            }
        }
    }'
```

------

## Aggiornare le impostazioni di crittografia dei risultati delle query sul lato client
<a name="migrating-updating-clientside-query-results-encryption"></a>

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

Per aggiornare le impostazioni lato client per la crittografia dei risultati delle query da CSE-KMS a SSE-KMS, vedere [Crittografare i risultati di query Athena archiviati in Amazon S3](encrypting-query-results-stored-in-s3.md).

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

È possibile specificare la configurazione della crittografia dei risultati delle query solo nelle impostazioni lato client con il comando `start-query-execution`. Se esegui questo comando CLI e sovrascrivi la configurazione di crittografia dei risultati delle query specificata nel tuo gruppo di lavoro con CSE-KMS, modifica il comando per crittografare i risultati delle query utilizzando quanto segue `SSE_KMS`.

```
aws athena start-query-execution \
    --query-string "SELECT * FROM <my-table>;" \
    --query-execution-context "Database=<my-database>,Catalog=<my-catalog>" \
    --result-configuration '{
        "EncryptionConfiguration": {
            "EncryptionOption": "SSE_KMS",
            "KmsKey": "<my-kms-key>"
        }
    }' \
    --work-group "<my-workgroup>"
```

------

**Nota**  
Dopo aver aggiornato le impostazioni sul gruppo di lavoro o sul lato client, tutti i nuovi dati inseriti tramite query di scrittura utilizzano la crittografia SSE-KMS anziché CSE-KMS. Questo perché le configurazioni di crittografia dei risultati delle query si applicano anche ai dati della tabella appena inseriti. Anche i risultati delle query, i metadati e i file manifesto di Athena sono crittografati con SSE-KMS.
Athena è ancora in grado di leggere le tabelle con la proprietà della tabella `has_encrypted_data` anche in presenza di una combinazione di oggetti crittografati CSE-KMS e SSE-S3/SSE-KMS.

# Converti i dati della tabella CSE-KMS in SSE-KMS
<a name="convert-csekms-table-ssekms"></a>

Se i propri flussi di lavoro attualmente utilizzano CSE-KMS per la crittografia dei dati delle tabelle, passa a SSE-KMS con i seguenti passaggi.

## Prerequisito
<a name="convert-csekms-table-ssekms-preq"></a>

Se continui a scrivere dati utilizzando un gruppo di lavoro CSE-KMS o impostazioni lato client, segui i passaggi indicati in [Esegui la migrazione da CSE-KMS a SSE-KMS](migrating-csekms-ssekms.md) per aggiornarli a SSE-KMS. Ciò impedisce l’aggiunta di nuovi dati crittografati CSE-KMS durante il processo di migrazione da qualsiasi altro flusso di lavoro che potrebbe scrivere nelle tabelle.

## Migrazione dei dati
<a name="convert-csekms-table-ssekms-migrat"></a>

1. Controllare se la proprietà `has_encrypted_data` della tabella è impostata su `true`. Questa proprietà specifica che la tabella potrebbe contenere dati crittografati CSE-KMS. Tuttavia, è importante notare che questa proprietà potrebbe essere presente anche su tabelle prive di dati crittografati CSE-KMS effettivi.

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

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

   1. Scegliere **Launch query editor**.

   1. Sul lato sinistro dell’editor, in **Database**, scegliere il nome del database su cui vuoi interrogare.

   1. Nell’editor Query esegui la query seguente per vedere il valore impostato sulla proprietà `has_encrypted_data table`.

      ```
      SHOW TBLPROPERTIES <table_name>('has_encrypted_data');
      ```

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

   Avvia una query Athena che mostra il valore della proprietà `has_encrypted_data` sulla tabella come mostrato nell’esempio seguente.

   ```
   aws athena start-query-execution \
       --query-string "SHOW TBLPROPERTIES <table-name>('has_encrypted_data');" \
       --work-group "<my-workgroup>"
   ```

   Recupera i risultati della query per verificare il valore della proprietà della tabella `has_encrypted_data` per la tabella, come mostrato nell’esempio seguente.

   ```
   aws athena get-query-results --query-execution-id <query-execution-id-from-previous-step>
   ```

------

1. Per ogni oggetto crittografato CSE-KMS nella tabella.

   1. Scaricare l’oggetto da S3 utilizzando il client di crittografia S3 e decriptarlo. Ecco un esempio con AWS Java SDK V2.

      **Importazioni**

      ```
      import software.amazon.awssdk.core.ResponseInputStream;
      import software.amazon.awssdk.services.s3.model.GetObjectRequest;
      import software.amazon.awssdk.services.s3.model.GetObjectResponse;
      import software.amazon.encryption.s3.S3EncryptionClient;
      import software.amazon.encryption.s3.materials.Keyring;
      import software.amazon.encryption.s3.materials.KmsDiscoveryKeyring;
      ```

      Codice

      ```
      final Keyring kmsDiscoveryKeyRing = KmsDiscoveryKeyring.builder()
              .enableLegacyWrappingAlgorithms(true)
              .build();
      final S3EncryptionClient s3EncryptionClient = S3EncryptionClient.builder()
              .enableLegacyUnauthenticatedModes(true)
              .keyring(kmsDiscoveryKeyRing)
              .build();
      
      GetObjectRequest getObjectRequest = GetObjectRequest.builder()
              .bucket("amzn-s3-demo-bucket")
              .key("<my-key>")
              .build();
      
      ResponseInputStream<GetObjectResponse> s3Object = s3EncryptionClient.getObject(getObjectRequest);
      ```

   1. Caricare l’oggetto su S3 con lo stesso nome e la crittografia SSE-KMS. Ecco un esempio con AWS Java SDK V2.

      **Importazioni**

      ```
      import software.amazon.awssdk.core.ResponseInputStream;
      import software.amazon.awssdk.core.sync.RequestBody;
      import software.amazon.awssdk.services.s3.S3Client;
      import software.amazon.awssdk.services.s3.model.PutObjectRequest;
      import software.amazon.awssdk.services.s3.model.ServerSideEncryption;
      ```

      **Codice**

      ```
      final S3Client s3Client = S3Client.builder()
              .build();
                  
      PutObjectRequest putObjectRequest = PutObjectRequest.builder()
              .bucket("amzn-s3-demo-bucket")
              .key("<my-key>")
              .serverSideEncryption(ServerSideEncryption.AWS_KMS)
              .ssekmsKeyId("<my-kms-key>")
              .build();
      
      s3Client.putObject(putObjectRequest, RequestBody.fromBytes(s3Object.readAllBytes()));
      ```

## Dopo la migrazione
<a name="convert-csekms-table-ssekms-post-migrat"></a>

Dopo aver ricrittografato correttamente tutti i file CSE-KMS nella tabella, effettuare le seguenti operazioni. 

1. Rimuovere la proprietà `has_encrypted_data` dalla tabella.

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

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

   1. Scegliere **Launch query editor**.

   1. Sul lato sinistro dell’editor, in **Database**, scegliere il nome del database su cui si vuole eseguire la query.

   1. Nell’editor di query, eseguire la seguente query per la propria tabella.

      ```
      ALTER TABLE <database-name>.<table-name> UNSET TBLPROPERTIES ('has_encrypted_data')
      ```

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

   Eseguire il seguente comando per rimuovere la proprietà dalla propria tabella `has_encrypted_data`:

   ```
   aws athena start-query-execution \
       --query-string "ALTER TABLE <database-name>.<table-name> UNSET TBLPROPERTIES ('has_encrypted_data');" \
       --work-group "<my-workgroup>"
   ```

------

1. Aggiornare i flussi di lavoro per utilizzare un client S3 di base anziché un client di crittografia S3, quindi specificare la crittografia SSE-KMS per le scritture dei dati.