Uso del formato XML en AWS Glue - AWS Glue
Ejemplo: leer XMLReferencia de XMLEspecifique el esquema XML

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Uso del formato XML en AWS Glue

AWS Glue recupera datos de fuentes y escribe datos en destinos almacenados y transportados en varios formatos de datos. Si sus datos se almacenan o transportan en formato de datos XML, este documento presenta las funciones disponibles para usar sus datos en AWS Glue.

AWS Glue admite el uso del formato XML. Este formato representa estructuras de datos altamente configurables y rígidamente definidas que no están basadas en filas o columnas. XML es altamente estandarizado. Para obtener una introducción al formato de la autoridad de normalización, consulte Elementos esenciales de XML.

Puede usar AWS Glue para leer archivos XML desde Amazon S3, así como archivos bzip y gzip que contengan archivos XML. Debe configurar el comportamiento de compresión en el Parámetros de conexión S3 en lugar de en la configuración que se describe en esta página.

En la siguiente tabla se muestran las características comunes de AWS Glue que admiten la opción de formato XML.

Leer Escritura Lectura de streaming Grupo de archivos pequeños Marcadores de trabajo
Compatible No se admite No se admite Soportado Soportado

Ejemplo: leer XML desde S3

El lector de XML toma un nombre de etiqueta XML. Examina los elementos con esa etiqueta dentro de su entrada para inferir un esquema y rellena un DynamicFrame con los valores correspondientes. La funcionalidad XML de AWS Glue se comporta de forma similar al Origen de datos XML para Apache Spark. Es posible que pueda obtener información sobre el comportamiento básico comparando este lector con la documentación de ese proyecto.

Requisitos previos: necesitará las rutas de S3 (s3path) en las carpetas o archivos XML que desee leer, y cierta información sobre su archivo XML. También necesitará la etiqueta del elemento XML que desea leer, xmlTag.

Configuración: en las opciones de la función, especifique format="xml". En sus connection_options, utilice la clave paths para especificar s3path. Puede configurar aún más la forma en que el lector interactúa con S3 en la connection_options. Para obtener más información, consulte Tipos y opciones de conexión para ETL en AWS Glue: Parámetros de conexión S3. En sus format_options, utilice la clave rowTag para especificar xmlTag. Puede configurar aún más la forma en que el lector interpreta los archivos XML en sus format_options. Para obtener más información, consulte Referencia de configuración de XML.

El siguiente script de ETL de AWS Glue muestra el proceso de lectura de archivos o carpetas XML desde S3.

Python

Para este ejemplo, use el método 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"},
)

También puede usar DataFrames en un script (pyspark.sql.DataFrame).

dataFrame = spark.read\
    .format("xml")\
    .option("rowTag", "xmlTag")\
    .load("s3://s3path")
Scala

Para este ejemplo, use la operación 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()
}

También puede usar DataFrames en un script (org.apache.spark.sql.DataFrame).

val dataFrame = spark.read
  .option("rowTag", "xmlTag")
  .format("xml")
  .load("s3://s3path“)

Referencia de configuración de XML

Puede utilizar las siguientes format_options donde las bibliotecas de AWS Glue especifiquen format="xml":

  • rowTag: especifica la etiqueta XML en el archivo que se tratará como una fila. Las etiquetas de fila no pueden autocerrarse.

    • Tipo: Texto, Obligatorio

  • encoding: especifica la codificación de caracteres. Puede ser el nombre o alias de un Charset compatible con nuestro entorno de tiempo de ejecución. No ofrecemos garantías específicas en cuanto a la compatibilidad con la codificación, pero las codificaciones principales deberían funcionar.

    • Tipo: Texto, Valor predeterminado: "UTF-8"

  • excludeAttribute: especifica si desea excluir o no atributos en elementos.

    • Tipo: Booleano, Valor predeterminado: false

  • treatEmptyValuesAsNulls: especifica si los espacios en blanco se tratan como un valor nulo.

    • Tipo: Booleano, Valor predeterminado: false

  • attributePrefix: un prefijo de atributos para diferenciarlos del texto de elementos secundarios. Este prefijo se utiliza para los nombres de campo.

    • Tipo: Texto, Valor predeterminado: "_"

  • valueTag: la etiqueta que se utiliza para un valor cuando hay atributos en el elemento que no tienen elementos secundarios.

    • Tipo: Texto, Valor predeterminado: "_VALUE"

  • ignoreSurroundingSpaces: especifica si se deben ignorar los espacios en blanco alrededor de los valores.

    • Tipo: Booleano, Valor predeterminado: false

  • withSchema: contiene el esquema esperado, en situaciones en las que se desea anular el esquema inferido. Si no utiliza esta opción, AWS Glue infiere el esquema a partir de los datos XML.

    • Tipo: Texto, Valor predeterminado: no aplicable

    • El valor debe ser un objeto JSON que represente un StructType.

Especifique manualmente el esquema XML

Ejemplo del esquema XML manual

Este es un ejemplo de uso de la opción del formato withSchema para especificar el esquema para los datos 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 = ""
)