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 XML 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 di dati XML, questo documento presenta le funzionalità disponibili per l'utilizzo dei dati in AWS Glue.
AWS Glue supporta l'utilizzo del formato XML. Questo formato rappresenta strutture dati altamente configurabili e rigidamente definite che non sono basate su righe o colonne. XML è altamente standardizzato. Per un'introduzione al formato da parte dell'autorità di standard, consulta [Informazioni essenziali su XML](https://www.w3.org/standards/xml/core).
Puoi usare AWS Glue per leggere file XML da Amazon S3 `bzip` e `gzip` archivi contenenti file XML. 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.
La tabella seguente mostra quali funzioni comuni di AWS Glue supportano l'opzione di formato XML.
| Lettura | Scrittura | Lettura in streaming | Gruppo di file piccoli | Segnalibri di processo |
| --- | --- | --- | --- | --- |
| Supportata | Non supportato. | Non supportato. | Supportata | Supportata |
## Esempio: lettura di XML da S3
Il reader XML assume un nome di tag XML. Esamina gli elementi con quel tag all'interno del relativo input per dedurre uno schema e compila un DynamicFrame con i valori corrispondenti. La funzionalità AWS Glue XML si comporta in modo simile alla [sorgente dati XML per Apache](https://github.com/databricks/spark-xml) Spark. Potresti essere in grado di ottenere informazioni sul comportamento di base confrontando questo reader con la documentazione di quel progetto.
**Prerequisiti:** avrai bisogno dei percorsi S3 (`s3path`) nei file XML o nelle cartelle che desideri leggere e di alcune informazioni sul file XML. Avrai bisogno anche del tag per l'elemento XML che desideri leggere, `xmlTag`.
**Configurazione:** nelle opzioni della funzione, specifica `format="xml"`. In `connection_options`, utilizza la chiave `paths` per specificare `s3path`. Puoi configurare il modo in cui il reader interagisce con S3 in `connection_options`. Per i dettagli, vedi Tipi di connessione e opzioni per ETL in AWS Glue:[Parametri di connessione di S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). In `format_options`, utilizza la chiave `rowTag` per specificare `xmlTag`. Puoi configurare il modo in cui il reader interpreta i file XML nel tuo `format_options`. Per maggiori dettagli, consulta [Riferimento alla configurazione XML](#aws-glue-programming-etl-format-xml-reference).
Il seguente script ETL di AWS Glue mostra il processo di lettura di file o cartelle XML da S3.
------
#### [ Python ]
Per questo esempio, utilizza 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 XML from S3
# Set the rowTag option to configure the reader.
from awsglue.context import GlueContext
from pyspark.context import SparkContext
sc = SparkContext.getOrCreate()
glueContext = GlueContext(sc)
dynamicFrame = glueContext.create_dynamic_frame.from_options(
connection_type="s3",
connection_options={"paths": ["s3://s3path"]},
format="xml",
format_options={"rowTag": "xmlTag"},
)
```
Puoi anche usare DataFrames in uno script (`pyspark.sql.DataFrame`).
```
dataFrame = spark.read\
.format("xml")\
.option("rowTag", "xmlTag")\
.load("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 XML from S3
// Set the rowTag option to configure the reader.
import com.amazonaws.services.glue.util.JsonOptions
import com.amazonaws.services.glue.GlueContext
import org.apache.spark.sql.SparkSession
val glueContext = new GlueContext(SparkContext.getOrCreate())
val sparkSession: SparkSession = glueContext.getSparkSession
object GlueApp {
def main(sysArgs: Array[String]): Unit = {
val dynamicFrame = glueContext.getSourceWithFormat(
formatOptions=JsonOptions("""{"rowTag": "xmlTag"}"""),
connectionType="s3",
format="xml",
options=JsonOptions("""{"paths": ["s3://s3path"], "recurse": true}""")
).getDynamicFrame()
}
```
È inoltre possibile utilizzare DataFrames in uno script (`org.apache.spark.sql.DataFrame`).
```
val dataFrame = spark.read
.option("rowTag", "xmlTag")
.format("xml")
.load("s3://s3path“)
```
------
## Riferimento alla configurazione XML
Puoi usare quanto segue `format_options` ovunque le librerie AWS Glue lo specifichino`format="xml"`:
+ `rowTag`: specifica il tag XML nel file da trattare come riga. I tag di riga non possono essere con chiusura automatica.
+ **Tipo:** testo, **obbligatorio**
+ `encoding`: specifica la codifica dei caratteri. Può essere il nome o l'alias di un [Charset](https://docs.oracle.com/javase/8/docs/api/java/nio/charset/Charset.html) supportato dal nostro ambiente di runtime. Non forniamo garanzie specifiche sul supporto della codifica, ma le codifiche principali dovrebbero funzionare.
+ **Tipo:** testo, **Valore predefinito:** `"UTF-8"`
+ `excludeAttribute`: specifica se escludere o meno gli attributi negli elementi.
+ **Tipo:** booleano, **Valore predefinito:** `false`
+ `treatEmptyValuesAsNulls`: specifica se trattare uno spazio vuoto come valore null.
+ **Tipo:** booleano, **Valore predefinito:** `false`
+ `attributePrefix`: un prefisso per gli attributi, per differenziarli dal testo degli elementi figlio. Questo prefisso viene usato per i nomi di campi.
+ **Tipo:** testo, **Valore predefinito:** `"_"`
+ `valueTag`: il tag usato per un valore quando ci sono attributi nell'elemento che non hanno elementi figlio.
+ **Tipo:** testo, **Valore predefinito:** `"_VALUE"`
+ `ignoreSurroundingSpaces`: specifica se lo spazio vuoto intorno ai valori deve essere ignorato.
+ **Tipo:** booleano, **Valore predefinito:** `false`
+ `withSchema`: contiene lo schema previsto, in situazioni in cui si desidera sovrascrivere lo schema dedotto. Se non utilizzi questa opzione, AWS Glue deduce lo schema dai dati XML.
+ **Tipo:** testo, **Valore predefinito:** non applicabile
+ Il valore deve essere un oggetto JSON che rappresenta un `StructType`.
## Specifica manuale dello schema XML
**Esempio di schema XML manuale**
Questo è un esempio dell'utilizzo di `withSchema` per specificare lo schema per i dati XML.
```
from awsglue.gluetypes import *
schema = StructType([
Field("id", IntegerType()),
Field("name", StringType()),
Field("nested", StructType([
Field("x", IntegerType()),
Field("y", StringType()),
Field("z", ChoiceType([IntegerType(), StringType()]))
]))
])
datasource0 = create_dynamic_frame_from_options(
connection_type,
connection_options={"paths": ["s3://xml_bucket/someprefix"]},
format="xml",
format_options={"withSchema": json.dumps(schema.jsonValue())},
transformation_ctx = ""
)
```