Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Utilisation du format XML dans AWS Glue
AWS Glue récupère les données des sources et écrit les données sur des cibles stockées et transportées dans différents formats de données. Si vos données sont stockées ou transportées au format de données XML, ce document présente les fonctionnalités disponibles pour utiliser vos données dans AWS Glue.
AWS Glue prend en charge l'utilisation du format XML. Ce format représente des structures de données hautement configurables et définies de manière rigide qui ne sont pas basées sur des lignes ou des colonnes. Le XML est hautement standardisé. Pour accéder à une présentation du format par l'autorité standard, consultez [XML Essentials](https://www.w3.org/standards/xml/core) (Essentiels XML).
Vous pouvez utiliser AWS Glue pour lire des fichiers XML depuis Amazon S3, ainsi que `bzip` des `gzip` archives contenant des fichiers XML. Vous configurez le comportement de compression sur [Paramètres de connexion S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3) plutôt que dans la configuration décrite sur cette page.
Le tableau suivant indique les fonctionnalités courantes de AWS Glue compatibles avec l'option de format XML.
| Lecture | Écrire | Lecture en streaming | Groupement des petits fichiers | Signets de tâche |
| --- | --- | --- | --- | --- |
| Pris en charge | Non pris en charge | Non pris en charge | Pris en charge | Pris en charge |
## Exemple : lecture de XML depuis S3
Le lecteur XML prend un nom de balise XML. Il examine les éléments comportant cette balise dans son entrée pour en déduire un schéma et remplit un DynamicFrame avec les valeurs correspondantes. La fonctionnalité AWS Glue XML se comporte de la même manière que la [source de données XML pour Apache Spark](https://github.com/databricks/spark-xml). Vous pourriez être en mesure de mieux comprendre le comportement de base en comparant ce lecteur à la documentation de ce projet.
**Prérequis :**Vous aurez besoin des chemins S3 (`s3path`) vers les fichiers ou dossiers XML que vous souhaitez lire, ainsi qu'à certaines informations concernant votre fichier XML. Vous aurez également besoin de la balise pour l'élément XML que vous souhaitez lire, `xmlTag`.
**Configuration :** dans vos options de fonction, spécifiez `format="xml"`. Dans vos `connection_options`, utilisez la clé `paths` pour spécifier `s3path`. Vous pouvez configurer plus en détail la manière dont le lecteur interagit avec S3 dans le `connection_options`. Pour plus de détails, voir Types de connexion et options pour l'ETL dans AWS Glue :[Paramètres de connexion S3](aws-glue-programming-etl-connect-s3-home.md#aws-glue-programming-etl-connect-s3). Dans vos `format_options`, utilisez la clé `rowTag` pour spécifier `xmlTag`. Vous pouvez configurer plus en détail la façon dont le lecteur interprète les fichiers XML dans votre `format_options`. Pour plus d'informations, consultez .[XML Configuration Reference](#aws-glue-programming-etl-format-xml-reference) (Référence de configuration XML).
Le script AWS Glue ETL suvant montre le processus de lecture de fichiers ou dossiers XML à partir de S3.
------
#### [ Python ]
Pour cet exemple, utilisez la méthode [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"},
)
```
Vous pouvez également l'utiliser DataFrames dans un script (`pyspark.sql.DataFrame`).
```
dataFrame = spark.read\
.format("xml")\
.option("rowTag", "xmlTag")\
.load("s3://s3path")
```
------
#### [ Scala ]
Pour cet exemple, utilisez l'opération [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()
}
```
Vous pouvez également l'utiliser DataFrames dans un script (`org.apache.spark.sql.DataFrame`).
```
val dataFrame = spark.read
.option("rowTag", "xmlTag")
.format("xml")
.load("s3://s3path“)
```
------
## Référence de configurations XML
Vous pouvez utiliser ce qui suit `format_options` partout où les bibliothèques AWS Glue le spécifient `format="xml"` :
+ `rowTag` – spécifie la balise XML du fichier à traiter comme ligne. Les balises de ligne ne se ferment pas automatiquement.
+ **Type :** Texte, **Obligatoire**
+ `encoding` – spécifie le codage de caractère. Il peut s'agir du nom ou de l'alias d'un[Charset](https://docs.oracle.com/javase/8/docs/api/java/nio/charset/Charset.html)pris en charge par notre environnement d'exécution. Nous ne donnons pas de garanties spécifiques concernant la prise en charge de l'encodage, mais les principaux codages devraient fonctionner.
+ **Type :** texte, **Valeur par défaut :** `"UTF-8"`
+ `excludeAttribute` – spécifie si vous souhaitez ou pas exclure les attributs dans les éléments.
+ **Type :** Booléen, **Valeur par défaut :** `false`
+ `treatEmptyValuesAsNulls` – pécifie s'il convient de traiter un espace blanc comme valeur nulle.
+ **Type :** Booléen, **Valeur par défaut :** `false`
+ `attributePrefix` – Un préfixe des attributs pour les différencier des éléments. Ce préfixe est utilisé pour les noms de champs.
+ **Type :** texte, **Valeur par défaut :** `"_"`
+ `valueTag` – La balise utilisée pour une valeur lorsqu'il y a des attributs de l'élément qui n'ont pas d'enfant.
+ **Type :** texte, **Valeur par défaut :** `"_VALUE"`
+ `ignoreSurroundingSpaces` – spécifie si les espaces blancs qui entourent les valeurs doivent être ignorés.
+ **Type :** Booléen, **Valeur par défaut :** `false`
+ `withSchema` – Contient le schéma attendu, dans les cas où vous souhaitez remplacer le schéma déduit. Si vous n'utilisez pas cette option, AWS Glue déduit le schéma des données XML.
+ **Type :**Texte, **Par défaut:** Non applicable
+ La valeur doit être un objet JSON qui représente un `StructType`.
## Spécifier manuellement le schéma XML
**Exemple de schéma XML manuel**
Il s'agit d'un exemple d'utilisation de l'option format `withSchema` pour spécifier le schéma des données 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 = ""
)
```