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

# Convertire il formato dei dati di input in Amazon Data Firehose
<a name="record-format-conversion"></a>

Amazon Data Firehose è in grado di convertire il formato dei dati di input da JSON ad [Apache Parquet o Apache](https://parquet.apache.org/) [ORC prima di archiviarli](https://orc.apache.org/) in Amazon S3. Parquet e ORC sono formati di dati colonnari che consentono di risparmiare spazio e consentono query più veloci rispetto ai formati orientati alle righe come JSON. Se desideri convertire un formato di input diverso da JSON, come valori separati da virgole (CSV) o testo strutturato, puoi prima trasformarlo in JSON. AWS Lambda Per ulteriori informazioni, consulta [Trasforma i dati di origine in Amazon Data Firehose](data-transformation.md).

Puoi convertire il formato dei tuoi dati anche se aggreghi i tuoi record prima di inviarli ad Amazon Data Firehose.

Amazon Data Firehose richiede i seguenti tre elementi per convertire il formato dei dati dei record: 

## Deserializer
<a name="record-format-conversion-deserializer"></a>

Amazon Data Firehose richiede un deserializzatore per leggere il codice JSON dei dati di input. Puoi scegliere uno dei seguenti due tipi di deserializzatore.

Quando combini più documenti JSON nello stesso record, assicurati che l'input sia comunque presentato nel formato JSON supportato. Una matrice di documenti JSON non è un input valido. 

Ad esempio, questo è l'input corretto: `{"a": 1}{"b": 1}` e questo è l'input errato:`[{"a":1}, {"a":2}]`.
+ [Apache Hive JSON SerDe](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL#LanguageManualDDL-JSON)
+ [OpenX JSON SerDe](https://github.com/rcongiu/Hive-JSON-Serde)

### Scegli il deserializzatore JSON
<a name="record-format-conversion-deserializers"></a>

Scegli [OpenX JSON SerDe se il tuo JSON](https://github.com/rcongiu/Hive-JSON-Serde) di input contiene timestamp nei seguenti formati:
+  yyyy-MM-dd'T'hh:mm:ss [.S] 'Z', dove la frazione può avere fino a 9 cifre, ad esempio. `2017-02-07T15:13:01.39256Z`
+  yyyy-[M]M-[d]d HH:mm:ss[.S], dove la frazione può avere fino a 9 cifre, ad esempio, `2017-02-07 15:13:01.14`.
+  Secondi epoch: ad esempio, `1518033528`.
+  Millisecondi epoch: ad esempio, `1518033528123`.
+  Secondi epoch a virgola mobile: ad esempio, `1518033528.123`.

OpenX JSON SerDe può convertire i punti (`.`) in caratteri di sottolineatura (). `_` Può anche convertire le chiavi JSON in minuscolo prima di deserializzarle. [Per ulteriori informazioni sulle opzioni disponibili con questo deserializzatore tramite Amazon Data Firehose, consulta Open. XJson SerDe](https://docs.aws.amazon.com/firehose/latest/APIReference/API_OpenXJsonSerDe.html)

Se non sei sicuro di quale deserializzatore scegliere, usa OpenX JSON SerDe, a meno che tu non abbia timestamp che non supporta.

[Se hai timestamp in formati diversi da quelli elencati in precedenza, usa Apache Hive JSON. SerDe](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL#LanguageManualDDL-JSON) Se scegli questo deserializzatore, puoi specificare i formati di timestamp da utilizzare. Per eseguire questa operazione, segui il modello di sintassi delle stringhe di formato `DateTimeFormat` Joda-Time. [Per ulteriori informazioni, consulta Class. DateTimeFormat](https://www.joda.org/joda-time/apidocs/org/joda/time/format/DateTimeFormat.html) 

Puoi anche utilizzare il valore speciale `millis` per analizzare timestamp in millisecondi Unix epoch. Se non specifichi un formato, Amazon Data Firehose lo utilizza `java.sql.Timestamp::valueOf` per impostazione predefinita.

Hive JSON SerDe non consente quanto segue:
+ Punti (`.`) nei nomi di colonna.
+ Campi il cui tipo è `uniontype`.
+ Campi che dispongono di tipi di numerici nello schema, ma che sono stringhe in JSON. Ad esempio, se lo schema è (un int) e il JSON lo è`{"a":"123"}`, Hive SerDe restituisce un errore.

Hive SerDe non converte JSON annidato in stringhe. Ad esempio, se hai `{"a":{"inner":1}}`, non tratta `{"inner":1}` come stringa.

## Schema
<a name="record-format-conversion-schema"></a>

Amazon Data Firehose richiede uno schema per determinare come interpretare tali dati. Usa [AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/what-is-glue.html) per creare uno schema in AWS Glue Data Catalog. Amazon Data Firehose fa quindi riferimento a tale schema e lo utilizza per interpretare i dati di input. Puoi utilizzare lo stesso schema per configurare sia Amazon Data Firehose che il tuo software di analisi. Per ulteriori informazioni, consulta [Populating the AWS Glue Data Catalog](https://docs.aws.amazon.com/glue/latest/dg/populate-data-catalog.html) nella *AWS Glue Developer Guide*.

**Nota**  
Lo schema creato in AWS Glue Data Catalog deve corrispondere alla struttura dei dati di input. In caso contrario, i dati convertiti non conterranno attributi non specificati nello schema. Se utilizzi il codice JSON nidificato, utilizza un tipo STRUCT nello schema che rispecchi la struttura dei tuoi dati JSON. Vedi [questo esempio](https://docs.aws.amazon.com/athena/latest/ug/openx-json-serde.html#nested-json-serde-example) su come gestire il codice JSON nidificato con un tipo STRUCT. 

**Importante**  
Per i tipi di dati che non specificano un limite di dimensione, esiste un limite pratico di 32 MBs per tutti i dati in una singola riga.  
Se si specifica length per `CHAR` o`VARCHAR`, Firehose tronca le stringhe alla lunghezza specificata quando legge i dati di input. Se la stringa di dati sottostante è più lunga, rimane invariata.

## Serializer
<a name="record-format-conversion-serializer"></a>

**Firehose richiede un serializzatore per convertire i dati nel formato di archiviazione colonnare di destinazione (Parquet o ORC)**: è possibile scegliere uno dei due tipi di serializzatori seguenti. 
+ [ORC SerDe](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+ORC)
+ [Parquet SerDe](https://cwiki.apache.org/confluence/display/Hive/Parquet)

### Scegli il serializzatore
<a name="record-format-conversion-serializers"></a>

Il serializzatore scelto dipende dalle esigenze aziendali. [https://cwiki.apache.org/confluence/display/Hive/LanguageManual+ORC](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+ORC)

# Abilita la conversione del formato di registrazione
<a name="enable-record-format-conversion"></a>

Se abiliti la conversione del formato di record, non puoi impostare la destinazione Amazon Data Firehose come Amazon OpenSearch Service, Amazon Redshift o Splunk. Con la conversione del formato abilitata, Amazon S3 è l'unica destinazione che puoi usare per il tuo stream Firehose. La sezione seguente mostra come abilitare la conversione del formato di registrazione dalle operazioni della console e dell'API Firehose. Per un esempio di come impostare la conversione del formato di record con CloudFormation, vedi [AWS:::DataFirehose: DeliveryStream](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-kinesisfirehose-deliverystream.html#aws-resource-kinesisfirehose-deliverystream--examples).

## Abilita la conversione del formato di registrazione dalla console
<a name="record-format-conversion-using-console"></a>

È possibile abilitare la conversione del formato dei dati sulla console quando si crea o si aggiorna uno stream Firehose. Con la conversione del formato dei dati abilitata, Amazon S3 è l'unica destinazione che puoi configurare per lo stream Firehose. Inoltre, la compressione Amazon S3 viene disabilitata quando abiliti la conversione del formato. Tuttavia, la compressione Snappy si verifica automaticamente come parte del processo di conversione. Il formato di framing per Snappy utilizzato da Amazon Data Firehose in questo caso è compatibile con Hadoop. Ciò significa che puoi utilizzare i risultati della compressione Snappy ed eseguire query su questi dati in Athena. [Per il formato di framing Snappy su cui si basa Hadoop, consulta .java. BlockCompressorStream](https://github.com/apache/hadoop/blob/f67237cbe7bc48a1b9088e990800b37529f1db2a/hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/io/compress/BlockCompressorStream.java)

**Per abilitare la conversione del formato dei dati per un flusso di dati Firehose**

1. Accedi a e apri Console di gestione AWS la console Amazon Data Firehose all'indirizzo. [https://console.aws.amazon.com/firehose/](https://console.aws.amazon.com/firehose/)

1. Scegli uno stream Firehose da aggiornare o crea un nuovo stream Firehose seguendo la procedura riportata di seguito. [Tutorial: Creare uno stream Firehose dalla console](basic-create.md)

1. In **Convert record format (Converti formato record)**, impostare **Record format conversion (Conversione formato record)** su **Enabled (Abilitata)**.

1. Scegliere il formato di output desiderato. Per ulteriori informazioni sulle due opzioni, consulta [Apache Parquet](https://parquet.apache.org/) e [Apache ORC](https://orc.apache.org/).

1. Scegliete una AWS Glue tabella per specificare uno schema per i record di origine. Impostare la regione, il database, la tabella e la versione della tabella.

## Gestione della conversione del formato di record dall'API Firehose
<a name="record-format-conversion-using-api"></a>

[Se desideri che Amazon Data Firehose converta il formato dei dati di input da JSON a Parquet o ORC, specifica l'[DataFormatConversionConfiguration](https://docs.aws.amazon.com/firehose/latest/APIReference/API_DataFormatConversionConfiguration.html)elemento opzionale in ExtendeDS3 o [DestinationConfigurationExtendeDS3](https://docs.aws.amazon.com/firehose/latest/APIReference/API_ExtendedS3DestinationConfiguration.html). DestinationUpdate](https://docs.aws.amazon.com/firehose/latest/APIReference/API_ExtendedS3DestinationUpdate.html) Se lo specifichi, si applicano le seguenti restrizioni. [DataFormatConversionConfiguration](https://docs.aws.amazon.com/firehose/latest/APIReference/API_DataFormatConversionConfiguration.html)
+ In [BufferingHints](https://docs.aws.amazon.com/firehose/latest/APIReference/API_BufferingHints.html), non è possibile impostare un valore inferiore `SizeInMBs` a 64 se si abilita la conversione del formato di record. Inoltre, se la conversione del formato non è abilitata, il valore predefinito è 5. Se la abiliti, il valore diventa 128.
+ [È necessario impostare `CompressionFormat` in [ExtendedS3 DestinationConfiguration o in ExtendeDS3](https://docs.aws.amazon.com/firehose/latest/APIReference/API_ExtendedS3DestinationConfiguration.html) su. DestinationUpdate](https://docs.aws.amazon.com/firehose/latest/APIReference/API_ExtendedS3DestinationUpdate.html) `UNCOMPRESSED` Il valore predefinito per `CompressionFormat` è `UNCOMPRESSED`. [Pertanto, puoi anche lasciarlo non specificato in ExtendeDS3. DestinationConfiguration](https://docs.aws.amazon.com/firehose/latest/APIReference/API_ExtendedS3DestinationConfiguration.html) I dati vengono ancora compressi come parte del processo di serializzazione, utilizzando la compressione Snappy per impostazione predefinita. Il formato di framing per Snappy utilizzato da Amazon Data Firehose in questo caso è compatibile con Hadoop. Ciò significa che puoi utilizzare i risultati della compressione Snappy ed eseguire query su questi dati in Athena. [Per il formato di framing Snappy su cui si basa Hadoop, consulta .java. BlockCompressorStream](https://github.com/apache/hadoop/blob/f67237cbe7bc48a1b9088e990800b37529f1db2a/hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/io/compress/BlockCompressorStream.java) Quando configuri il serializzatore, puoi scegliere altri tipi di compressione.

# Gestione degli errori per la conversione del formato dei dati
<a name="record-format-conversion-error-handling"></a>

Quando Amazon Data Firehose non è in grado di analizzare o deserializzare un record (ad esempio, quando i dati non corrispondono allo schema), lo scrive su Amazon S3 con un prefisso di errore. Se questa scrittura non riesce, Amazon Data Firehose riprova per sempre, bloccando l'ulteriore consegna. Per ogni record non riuscito, Amazon Data Firehose scrive un documento JSON con lo schema seguente:

```
{
  "attemptsMade": long,
  "arrivalTimestamp": long,
  "ErrorCode": string,
  "ErrorMessage": string,
  "attemptEndingTimestamp": long,
  "rawData": string,
  "sequenceNumber": string,
  "subSequenceNumber": long,
  "dataCatalogTable": {
    "catalogId": string,
    "databaseName": string,
    "tableName": string,
    "region": string,
    "versionId": string,
    "catalogArn": string
  }
}
```