Reduzca la cantidad de datos escaneados

Tamaño del archivo: recomendamos mantener el tamaño del archivo de entradas y salidas dentro de un rango moderado (por ejemplo, 128 MB). Los archivos demasiado pequeños y los archivos demasiado grandes pueden causar problemas.

Un gran número de archivos pequeños provoca los siguientes problemas:

Por otro lado, si el tipo de archivo no se puede dividir (por ejemplo, gzip) y los archivos son demasiado grandes, la aplicación Spark debe esperar a que una sola tarea termine de leer todo el archivo.

Para reducir el paralelismo excesivo que se produce al crear una tarea de Apache Spark para cada archivo pequeño, utilice la agrupación de archivos para. DynamicFrames Este enfoque reduce las posibilidades de que se produzca una OOM excepción por parte del controlador Spark. Para configurar la agrupación de archivos, defina los groupSize parámetros groupFiles y. En el siguiente ejemplo de código, se utiliza AWS Glue DynamicFrame API en un ETL script con estos parámetros.

dyf = glueContext.create_dynamic_frame_from_options("s3",
    {'paths': ["s3://input-s3-path/"],
    'recurse':True,
    'groupFiles': 'inPartition',
    'groupSize': '1048576'},
    format="json")

Compresión: si los objetos de S3 ocupan cientos de megabytes, considere comprimirlos. Existen varios formatos de compresión, que se pueden clasificar a grandes rasgos en dos tipos:

Para Spark (y otros motores de procesamiento distribuido comunes), dividirás el archivo de datos fuente en fragmentos que tu motor pueda procesar en paralelo. Estas unidades suelen denominarse divisiones. Una vez que los datos estén en un formato separable, los AWS Glue lectores optimizados pueden recuperar las divisiones de un objeto S3 al ofrecer la Range opción de GetObject API recuperar solo bloques específicos. Considera el siguiente diagrama para ver cómo funcionaría esto en la práctica.

Los datos comprimidos pueden acelerar considerablemente la aplicación, siempre que los archivos tengan un tamaño óptimo o se puedan dividir. Los tamaños de datos más pequeños reducen los datos escaneados desde Amazon S3 y el tráfico de red desde Amazon S3 a su clúster de Spark. Por otro lado, CPU se necesita más para comprimir y descomprimir los datos. La cantidad de cómputo requerida aumenta con la relación de compresión del algoritmo de compresión. Tenga en cuenta esta desventaja a la hora de elegir el formato de compresión separable.

Formato de archivo: utilice un formato de columnas. Apache Parquet y Apache ORC son formatos de datos en columnas populares. Comprima y ORC almacene los datos de manera eficiente mediante la compresión basada en columnas, codificando y comprimiendo cada columna en función de su tipo de datos. Para obtener más información sobre las codificaciones de Parquet, consulte Definiciones de codificación de Parquet. Los archivos de parquet también se pueden dividir.

Los formatos en columnas agrupan los valores por columnas y los almacenan juntos en bloques. Al usar formatos en columnas, puede omitir los bloques de datos que corresponden a columnas que no planea usar. Las aplicaciones de Spark solo pueden recuperar las columnas que necesitas. Por lo general, unas relaciones de compresión mejores o la omisión de bloques de datos implican leer menos bytes de Amazon S3, lo que se traduce en un mejor rendimiento. Ambos formatos también admiten los siguientes enfoques de compresión descendente para reducir la E/S:

Diseño de archivos: al almacenar los datos de S3 en objetos situados en diferentes rutas en función de cómo se vayan a utilizar los datos, podrá recuperar los datos relevantes de forma eficiente. Para obtener más información, consulte Organizar objetos mediante prefijos en la documentación de Amazon S3. AWS Glue admite almacenar claves y valores en prefijos de Amazon S3 en este formatokey=value, dividiendo los datos según la ruta de Amazon S3. Al particionar sus datos, puede restringir la cantidad de datos escaneados por cada aplicación de análisis posterior, lo que mejora el rendimiento y reduce los costos. Para obtener más información, consulte Administrar particiones para su ETL salida. AWS Glue

La partición divide la tabla en diferentes partes y mantiene los datos relacionados en archivos agrupados en función de los valores de las columnas, como el año, el mes y el día, como se muestra en el siguiente ejemplo.

# Partitioning by /YYYY/MM/DD
s3://<YourBucket>/year=2023/month=03/day=31/0000.gz
s3://<YourBucket>/year=2023/month=03/day=01/0000.gz
s3://<YourBucket>/year=2023/month=03/day=02/0000.gz
s3://<YourBucket>/year=2023/month=03/day=03/0000.gz
...

Puede definir particiones para su conjunto de datos modelándolo con una tabla en. AWS Glue Data Catalog A continuación, puede restringir la cantidad de datos escaneados mediante la reducción de particiones de la siguiente manera:

Demasiadas particiones de Amazon S3: evite particionar los datos de Amazon S3 en columnas que contengan una amplia gama de valores, como una columna de ID con miles de valores. Esto puede aumentar considerablemente el número de particiones del bucket, ya que el número de particiones posibles es el producto de todos los campos por los que ha realizado la partición. Demasiadas particiones pueden provocar lo siguiente:

Por ejemplo, si estableces un tipo de fecha en partitionBy opartitionKeys, la partición a nivel de fecha yyyy/mm/dd es adecuada para muchos casos de uso. Sin embargo, yyyy/mm/dd/<ID> podría generar tantas particiones que afectaría negativamente al rendimiento en su conjunto.

Por otro lado, algunos casos de uso, como las aplicaciones de procesamiento en tiempo real, requieren muchas particiones, por ejemployyyy/mm/dd/hh. Si su caso de uso requiere particiones importantes, considere la posibilidad de utilizar índices de AWS Glue particiones para reducir la latencia a la hora de recuperar los metadatos de las particiones del catálogo de datos.

Para DynamicFrame, utilice la sampleQueryopción. Cuando create_dynamic_frame.from_catalog lo utilice, configure el additional_options argumento de la siguiente manera.

query = "SELECT * FROM <TableName> where id = 'XX' AND"
datasource0 = glueContext.create_dynamic_frame.from_catalog(
  database = db,
  table_name = table,
  additional_options={
      "sampleQuery": query,
      "hashexpression": key,
      "hashpartitions": 10,
      "enablePartitioningForSampleQuery": True
    },
  transformation_ctx = "datasource0"
)

Cuandousing create_dynamic_frame.from_options, configure el connection_options argumento de la siguiente manera.

query = "SELECT * FROM <TableName> where id = 'XX' AND"
datasource0 = glueContext.create_dynamic_frame.from_options(
    connection_type = connection, 
    connection_options={
        "url": url,
        "user": user,
        "password": password,
        "dbtable": table,
        "sampleQuery": query,
        "hashexpression": key,
        "hashpartitions": 10,
        "enablePartitioningForSampleQuery": True
    }
)

Para DataFrame, utilice la opción de consulta.

query = "SELECT * FROM <TableName> where id = 'XX'"
jdbcDF = spark.read \
.format('jdbc') \
.option('url', url) \
.option('user', user) \
.option('password', pwd) \
.option('query', query) \
.load()

En el caso de Amazon Redshift, utilice la AWS Glue versión 4.0 o una versión posterior para aprovechar la compatibilidad con pulsaciones descendentes del conector Amazon Redshift Spark.

dyf = glueContext.create_dynamic_frame.from_catalog(
    database = "redshift-dc-database-name", 
    table_name = "redshift-table-name", 
    redshift_tmp_dir = args["temp-s3-dir"], 
    additional_options = {"aws_iam_role": "arn:aws:iam::role-account-id:role/rs-role-name"}
)

Para otras bases de datos, consulte la documentación de esa base de datos.

Para evitar un análisis completo de todas las ejecuciones continuas de tareas y procesar solo los datos que no estaban presentes durante la última ejecución de la tarea, habilite los marcadores de tareas.

Para limitar la cantidad de datos de entrada que se van a procesar, habilite la ejecución limitada con marcadores de trabajos. Esto ayuda a reducir la cantidad de datos escaneados para cada ejecución de trabajo.