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à. # Utilizzo del formato JSON in AWS Glue AWS Glue recupera i dati dalle fonti e li scrive su destinazioni archiviate e trasportate in vari formati di dati. Se i dati vengono archiviati o trasportati nel formato dati JSON, questo documento presenta le funzionalità disponibili per l'utilizzo dei dati in Glue. AWS AWS Glue supporta l'utilizzo del formato JSON. Questo formato rappresenta strutture di dati con forma coerente ma contenuti flessibili, che non sono basate su righe o colonne. JSON è definito tramite standard paralleli emessi da diverse autorità, una delle quali è ECMA-404. Per un'introduzione al formato da una fonte di riferimento comune, consulta [Introduzione a JSON](https://www.json.org/). Puoi usare AWS Glue per leggere file JSON da Amazon S3 `gzip` e file JSON compressi. `bzip` Puoi configurare il comportamento di compressione sul [Parametri di connessione di S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) invece che nella configurazione discussa in questa pagina. | Lettura | Scrittura | Lettura in streaming | Gruppo di file piccoli | Segnalibri di processo | | --- | --- | --- | --- | --- | | Supportata | Supportato | Supportato | Supportato | Supportata | ## Esempio: lettura di cartelle o file JSON da S3 **Prerequisiti:** occorrono i percorsi S3 (`s3path`) nelle cartelle o nei file JSON da leggere. **Configurazione:** nelle opzioni della funzione, specifica `format="json"`. Nelle tue `connection_options`, utilizza la chiave `paths` per specificare `s3path`. Puoi modificare ulteriormente la modalità con cui l'operazione di lettura attraversa s3 nelle opzioni di connessione; consulta [Indicazioni di riferimento alle opzioni di connessione ad Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) per dettagli. Puoi configurare la modalità con cui il reader interpreta i file JSON in `format_options`. Per i dettagli, consulta la [Documentazione di riferimento della configurazione JSON](#aws-glue-programming-etl-format-json-reference). Il seguente script AWS Glue ETL mostra il processo di lettura di file o cartelle JSON da S3: ------ #### [ Python ] Per questo esempio, utilizzare il metodo [create\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-create_dynamic_frame_from_options). ``` # Example: Read JSON from S3 # For show, we handle a nested JSON file that we can limit with the JsonPath parameter # For show, we also handle a JSON where a single entry spans multiple lines # Consider whether optimizePerformance is right for your workflow. from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) spark = glueContext.spark_session dynamicFrame = glueContext.create_dynamic_frame.from_options( connection_type="s3", connection_options={"paths": ["s3://s3path"]}, format="json", format_options={ "jsonPath": "$.id", "multiline": True, # "optimizePerformance": True, -> not compatible with jsonPath, multiline } ) ``` Puoi anche usarlo DataFrames in uno script (). `pyspark.sql.DataFrame` ``` dataFrame = spark.read\ .option("multiline", "true")\ .json("s3://s3path") ``` ------ #### [ Scala ] Per questo esempio, utilizzate l'operazione [getSourceWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSourceWithFormat). ``` // Example: Read JSON from S3 // For show, we handle a nested JSON file that we can limit with the JsonPath parameter // For show, we also handle a JSON where a single entry spans multiple lines // Consider whether optimizePerformance is right for your workflow. import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.{DynamicFrame, GlueContext} import org.apache.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) val dynamicFrame = glueContext.getSourceWithFormat( formatOptions=JsonOptions("""{"jsonPath": "$.id", "multiline": true, "optimizePerformance":false}"""), connectionType="s3", format="json", options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""") ).getDynamicFrame() } } ``` È inoltre possibile utilizzare DataFrames in uno script (`pyspark.sql.DataFrame`). ``` val dataFrame = spark.read .option("multiline", "true") .json("s3://s3path") ``` ------ ## Esempio: scrittura di file e cartelle JSON su S3 **Prerequisiti:** è necessario un DataFrame (`dataFrame`) o DynamicFrame (`dynamicFrame`) inizializzato. È necessario anche del tuo percorso di output S3 previsto, `s3path`. **Configurazione:** nelle opzioni della funzione, specifica `format="json"`. In `connection_options`, utilizzare la chiave `paths` per specificare `s3path`. È possibile modificare ulteriormente il modo in cui il writer interagisce con S3 nelle `connection_options`. Per i dettagli, vedi Opzioni di formato dei dati per ingressi e uscite ETL in AWS Glue:. [Indicazioni di riferimento alle opzioni di connessione ad Amazon S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) È possibile configurare la modalità con cui il writer interpreta i file JSON in `format_options`. Per i dettagli, consultare la [Documentazione di riferimento della configurazione JSON](#aws-glue-programming-etl-format-json-reference). Il seguente script AWS Glue ETL mostra il processo di scrittura di file o cartelle JSON da S3: ------ #### [ Python ] Per questo esempio, utilizza il metodo [write\$1dynamic\$1frame.from\$1options](aws-glue-api-crawler-pyspark-extensions-glue-context.md#aws-glue-api-crawler-pyspark-extensions-glue-context-write_dynamic_frame_from_options). ``` # Example: Write JSON to S3 from pyspark.context import SparkContext from awsglue.context import GlueContext sc = SparkContext.getOrCreate() glueContext = GlueContext(sc) glueContext.write_dynamic_frame.from_options( frame=dynamicFrame, connection_type="s3", connection_options={"path": "s3://s3path"}, format="json" ) ``` Puoi anche usarlo DataFrames in uno script (). `pyspark.sql.DataFrame` ``` df.write.json("s3://s3path/") ``` ------ #### [ Scala ] Per questo esempio, utilizzate il metodo [getSinkWithFormat](glue-etl-scala-apis-glue-gluecontext.md#glue-etl-scala-apis-glue-gluecontext-defs-getSinkWithFormat). ``` // Example: Write JSON to S3 import com.amazonaws.services.glue.util.JsonOptions import com.amazonaws.services.glue.{DynamicFrame, GlueContext} import org.apache.spark.SparkContext object GlueApp { def main(sysArgs: Array[String]): Unit = { val spark: SparkContext = new SparkContext() val glueContext: GlueContext = new GlueContext(spark) glueContext.getSinkWithFormat( connectionType="s3", options=JsonOptions("""{"path": "s3://s3path"}"""), format="json" ).writeDynamicFrame(dynamicFrame) } } ``` È inoltre possibile utilizzare DataFrames in uno script (`pyspark.sql.DataFrame`). ``` df.write.json("s3://s3path") ``` ------ ## Documentazione di riferimento della configurazione JSON È possibile usare i valori di `format_options` seguenti con `format="json"`: + `jsonPath`— Un'[JsonPath](https://github.com/json-path/JsonPath)espressione che identifica un oggetto da leggere nei record. È particolarmente utile quando un file contiene registri annidati in una matrice esterna. Ad esempio, l' JsonPath espressione seguente si rivolge al `id` campo di un oggetto JSON. ``` format="json", format_options={"jsonPath": "$.id"} ``` + `multiline`: un valore booleano che specifica se un singolo registro può estendersi su più righe. Ciò può accadere quando un campo contiene un carattere di nuova riga tra virgolette. Imposta questa opzione su `"true"` se i registri si estendono su più righe. Il valore di default è `"false"`, che consente una divisione dei file più netta durante l'analisi. + `optimizePerformance`: valore booleano che specifica se utilizzare il lettore JSON SIMD avanzato insieme ai formati di memoria colonnare basati su Apache Arrow. Disponibile solo in AWS Glue 3.0. Non compatibile con `multiline` o `jsonPath`. Fornendo una di queste opzioni, AWS Glue tornerà al lettore standard. + `withSchema`: un valore di stringa che specifica uno schema di tabella nel formato descritto in [Specifica manuale dello schema XML](aws-glue-programming-etl-format-xml-home.md#aws-glue-programming-etl-format-xml-withschema). Utilizzato solo con `optimizePerformance` durante la lettura da connessioni non di catalogo. ## Utilizzo del lettore JSON SIMD vettorizzato con formato colonnare Apache Arrow La versione AWS Glue 3.0 aggiunge un lettore vettorizzato per i dati JSON. Funziona 2 volte più velocemente in determinate condizioni, rispetto al lettore standard. Questo lettore presenta alcune limitazioni di cui gli utenti dovrebbero essere consapevoli prima dell'uso, documentate in questa sezione. Per utilizzare il lettore ottimizzato, impostare `"optimizePerformance"` a True nella `format_options` o nella proprietà della tabella. È necessario anche fornire `withSchema` a meno che non venga letto dal catalogo. `withSchema` prevede un input come descritto nel [Specifica manuale dello schema XML](aws-glue-programming-etl-format-xml-home.md#aws-glue-programming-etl-format-xml-withschema) ``` // Read from S3 data source glueContext.create_dynamic_frame.from_options( connection_type = "s3", connection_options = {"paths": ["s3://s3path"]}, format = "json", format_options={ "optimizePerformance": True, "withSchema": SchemaString }) // Read from catalog table glueContext.create_dynamic_frame.from_catalog( database = database, table_name = table, additional_options = { // The vectorized reader for JSON can read your schema from a catalog table property. "optimizePerformance": True, }) ``` Per ulteriori informazioni sull'edificio a *SchemaString* nella libreria AWS Glue, vedere[PySpark tipi di estensione](aws-glue-api-crawler-pyspark-extensions-types.md). **Limitazioni per il lettore CSV vettorizzato** Nota i seguenti limiti: + Gli elementi JSON con oggetti nidificati o valori di array non sono supportati. Se fornito, AWS Glue tornerà al lettore standard. + È necessario fornire uno schema, dal catalogo o con `withSchema`. + Non compatibile con `multiline` o `jsonPath`. Fornendo una di queste opzioni, AWS Glue tornerà al lettore standard. + Fornire registri di input che non corrispondono allo schema di input provocherà il fallimento del lettore. + I [registri di errori](https://docs.aws.amazon.com/glue/latest/dg/glue-etl-scala-apis-glue-dynamicframe-class.html#glue-etl-scala-apis-glue-dynamicframe-class-defs-errorsAsDynamicFrame) non verranno creati. + Non supporta file JSON con caratteri multibyte (come caratteri giapponesi o cinesi).