Simplifique y acelere las aplicaciones de Apache Spark en los datos de Amazon Redshift con la integración de Amazon Redshift para Apache Spark

Reeditado por Platón

seguidores: 0

Clientes usan Desplazamiento al rojo de Amazon para ejecutar sus análisis críticos para el negocio en petabytes de datos estructurados y semiestructurados. Apache Spark es un marco popular que puede usar para crear aplicaciones para casos de uso como ETL (extracción, transformación y carga), análisis interactivo y aprendizaje automático (ML). Apache Spark le permite crear aplicaciones en una variedad de lenguajes, como Java, Scala y Python, accediendo a los datos en su almacén de datos de Amazon Redshift.

La integración de Amazon Redshift para Apache Spark ayuda a los desarrolladores a crear y ejecutar sin problemas aplicaciones Apache Spark en datos de Amazon Redshift. Los desarrolladores pueden utilizar los servicios de análisis y aprendizaje automático de AWS, como EMR de Amazon, Pegamento AWSy Amazon SageMaker para crear sin esfuerzo aplicaciones Apache Spark que lean y escriban en su almacén de datos de Amazon Redshift. Puede hacerlo sin comprometer el rendimiento de sus aplicaciones o la consistencia transaccional de sus datos.

En esta publicación, analizamos por qué la integración de Amazon Redshift para Apache Spark es fundamental y eficiente para el análisis y el aprendizaje automático. Además, analizamos casos de uso que usan la integración de Amazon Redshift con Apache Spark para impulsar el impacto comercial. Finalmente, lo guiaremos a través de ejemplos paso a paso de cómo usar este conector oficial de AWS en una aplicación Apache Spark.

Integración de Amazon Redshift para Apache Spark

La integración de Amazon Redshift para Apache Spark minimiza el proceso engorroso y, a menudo, manual de configurar un conector Spark-Redshift (versión comunitaria) y acorta el tiempo necesario para prepararse para las tareas de análisis y aprendizaje automático. Solo necesita especificar la conexión a su almacén de datos y puede comenzar a trabajar con datos de Amazon Redshift desde sus aplicaciones basadas en Apache Spark en cuestión de minutos.

Puede utilizar varias funciones de inserción para operaciones como ordenar, agregar, limitar, unir y funciones escalares, de modo que solo los datos relevantes se muevan desde su almacén de datos de Amazon Redshift a la aplicación Apache Spark consumidora. Esto le permite mejorar el rendimiento de sus aplicaciones. Los administradores de Amazon Redshift pueden identificar fácilmente el SQL generado a partir de aplicaciones basadas en Spark. En esta publicación, mostramos cómo puede averiguar el SQL generado por el trabajo de Apache Spark.

Además, la integración de Amazon Redshift para Apache Spark utiliza el formato de archivo Parquet cuando almacena los datos en un directorio temporal. Amazon Redshift utiliza la instrucción UNLOAD SQL para almacenar estos datos temporales en Servicio de almacenamiento simple de Amazon (Amazon S3). La aplicación Apache Spark recupera los resultados del directorio temporal (almacenado en formato de archivo Parquet), lo que mejora el rendimiento.

También puede ayudar a que sus aplicaciones sean más seguras utilizando Gestión de identidades y accesos de AWS (IAM) credenciales para conectarse a Amazon Redshift.

La integración de Amazon Redshift para Apache Spark se basa en el conector spark-redshift (versión comunitaria) y lo mejora en cuanto a rendimiento y seguridad, ayudándole a obtener un rendimiento de las aplicaciones hasta 10 veces más rápido.

Casos de uso para la integración de Amazon Redshift con Apache Spark

Para nuestro caso de uso, el liderazgo de la empresa basada en productos desea conocer las ventas de cada producto en múltiples mercados. Dado que las ventas de la empresa fluctúan dinámicamente, se ha convertido en un desafío para el liderazgo realizar un seguimiento de las ventas en múltiples mercados. Sin embargo, las ventas generales están disminuyendo y el liderazgo de la empresa quiere saber qué mercados no están funcionando para poder orientar las campañas de promoción a estos mercados.

Para las ventas en varios mercados, los datos de ventas de productos, como pedidos, transacciones y datos de envío, están disponibles en Amazon S3 en el lago de datos. El equipo de ingeniería de datos puede usar Apache Spark con Amazon EMR o AWS Glue para analizar estos datos en Amazon S3.

Los datos de inventario están disponibles en Amazon Redshift. De manera similar, el equipo de ingeniería de datos puede analizar estos datos con Apache Spark usando Amazon EMR o un trabajo de AWS Glue usando la integración de Amazon Redshift para que Apache Spark realice agregaciones y transformaciones. El conjunto de datos agregado y transformado se puede volver a almacenar en Amazon Redshift mediante la integración de Amazon Redshift para Apache Spark.

El uso de un marco distribuido como Apache Spark con la integración de Amazon Redshift para Apache Spark puede proporcionar visibilidad en todo el lago de datos y el almacén de datos para generar información de ventas. Estos conocimientos pueden estar disponibles para las partes interesadas del negocio y los usuarios de la línea de negocios en Amazon Redshift para tomar decisiones informadas para ejecutar promociones específicas para los segmentos de mercado de bajos ingresos.

Además, podemos usar la integración de Amazon Redshift con Apache Spark en los siguientes casos de uso:

Un cliente de Amazon EMR o AWS Glue que ejecuta trabajos de Apache Spark desea transformar datos y escribirlos en Amazon Redshift como parte de su canalización de ETL
Un cliente de ML usa Apache Spark con SageMaker para la ingeniería de funciones para acceder y transformar datos en Amazon Redshift
Un cliente de Amazon EMR, AWS Glue o SageMaker utiliza Apache Spark para el análisis de datos interactivo con datos en Amazon Redshift desde cuadernos

Ejemplos de integración de Amazon Redshift para Apache Spark en una aplicación Apache Spark

En esta publicación, mostramos los pasos para conectar Amazon Redshift desde Amazon EMR en Nube informática elástica de Amazon (Amazon EC2), Amazon EMR sin servidory AWS Glue mediante un script común. En el siguiente código de ejemplo, generamos un informe que muestra las ventas trimestrales del año 2008. Para hacerlo, unimos dos tablas de Amazon Redshift mediante un Apache Spark DataFrame, ejecutamos una inserción de predicado, agregamos y ordenamos los datos, y escribimos los datos transformados. datos de vuelta a Amazon Redshift. El script usa PySpark

El script usa Autenticación basada en IAM para Amazon Redshift. Los roles de IAM utilizados por Amazon EMR y AWS Glue deben tener los permisos adecuados para autenticar Amazon Redshift y acceder a un depósito S3 para el almacenamiento temporal de datos.

La siguiente política de ejemplo permite que el rol de IAM llame al GetClusterCredentials operaciones:

{ "Version": "2012-10-17", "Statement": { "Effect": "Allow", "Action": "redshift:GetClusterCredentials", "Resource": "arn:aws:redshift:<aws_region_name>:xxxxxxxxxxxx:dbuser:*/temp_*" }
}

La siguiente política de ejemplo permite el acceso a un depósito S3 para el almacenamiento temporal de datos:

{ "Version": "2012-10-17", "Statement": [ { "Sid": "VisualEditor0", "Effect": "Allow", "Action": [ "s3:PutObject", "s3:GetObject", "s3:ListBucket" ], "Resource": "arn:aws:s3:::<s3_bucket_name>" } ]
}

El guión completo es el siguiente:

from pyspark.sql import SparkSession
from pyspark.sql.functions import col # Initiate Apache Spark session
spark = SparkSession .builder .appName("SparkRedshiftConnector") .enableHiveSupport() .getOrCreate() # Set connection options for Amazon Redshift
jdbc_iam_url = "jdbc:redshift:iam://redshift-spark-connector-1.xxxxxxxxxxx.<aws_region_name>.redshift.amazonaws.com:5439/sample_data_dev"
temp_dir = 's3://<s3_bucket_name>/redshift-temp-dir/'
aws_role = 'arn:aws:iam::xxxxxxxxxxxx:role/redshift-s3' # Set query group for the query. More details on Amazon Redshift WLM https://docs.aws.amazon.com/redshift/latest/dg/cm-c-executing-queries.html
queryGroup = "emr-redshift"
jdbc_iam_url_withQueryGroup = jdbc_iam_url+'?queryGroup='+queryGroup # Set User name for the query
userName = 'awsuser'
jdbc_iam_url_withUserName = jdbc_iam_url_withQueryGroup+';user='+userName # Define the Amazon Redshift context
redshiftOptions = { "url": jdbc_iam_url_withUserName, "tempdir": temp_dir, "aws_iam_role" : aws_role
} # Create the sales DataFrame from Amazon Redshift table using io.github.spark_redshift_community.spark.redshift class
sales_df = ( spark.read .format("io.github.spark_redshift_community.spark.redshift") .options(**redshiftOptions) .option("dbtable", "tickit.sales") .load()
) # Create the date Data Frame from Amazon Redshift table
date_df = ( spark.read .format("io.github.spark_redshift_community.spark.redshift") .options(**redshiftOptions) .option("dbtable", "tickit.date") .load()
) # Assign a Data Frame to the above output which will be written back to Amazon Redshift
output_df= sales_df.join(date_df, sales_df.dateid == date_df.dateid, 'inner').where( col("year") == 2008).groupBy("qtr").sum("qtysold").select( col("qtr"), col("sum(qtysold)")).sort(["qtr"], ascending=[1]).withColumnRenamed("sum(qtysold)","total_quantity_sold") # Display the output
output_df.show() ## Lets drop the queryGroup for easy validation of push down queries
# Set User name for the query
userName = 'awsuser'
jdbc_iam_url_withUserName = jdbc_iam_url+'?user='+userName # Define the Amazon Redshift context
redshiftWriteOptions = { "url": jdbc_iam_url_withUserName, "tempdir": temp_dir, "aws_iam_role" : aws_role
} # Write the Data Frame back to Amazon Redshift
output_df.write .format("io.github.spark_redshift_community.spark.redshift") .mode("overwrite") .options(**redshiftWriteOptions) .option("dbtable", "tickit.test") .save()

Si planea usar el script anterior en su entorno, asegúrese de reemplazar los valores de las siguientes variables con los valores apropiados para su entorno: jdbc_iam_url, temp_diry aws_role.

En la siguiente sección, repasamos los pasos para ejecutar este script para agregar un conjunto de datos de muestra que está disponible en Amazon Redshift.

Requisitos previos

Antes de comenzar, asegúrese de que se cumplan los siguientes requisitos previos:

Implemente recursos con AWS CloudFormation

Complete los siguientes pasos para implementar la pila de CloudFormation:

Inicia sesión en el Consola de administración de AWS, luego inicie la pila de CloudFormation:

También puede descargar la plantilla de CloudFormation para crear los recursos mencionados en esta publicación a través de infraestructura como código (IaC). Utilice esta plantilla cuando lance una nueva pila de CloudFormation.

Desplácese hacia abajo hasta la parte inferior de la página para seleccionar Reconozco que AWS CloudFormation podría crear recursos de IAM bajo Capacidades, A continuación, elija Crear pila.

El proceso de creación de la pila tarda entre 15 y 20 minutos en completarse. La plantilla de CloudFormation crea los siguientes recursos:

- Una VPC de Amazon con las subredes, las tablas de rutas y la puerta de enlace NAT necesarias
- Un depósito S3 con el nombre redshift-spark-databucket-xxxxxxx (tenga en cuenta que xxxxxxx es una cadena aleatoria para que el nombre del depósito sea único)
- Un clúster de Amazon Redshift con datos de muestra cargados dentro de la base de datos dev y el usuario principal redshiftmasteruser. Para el propósito de esta publicación de blog, redshiftmasteruser con permisos administrativos se utiliza. Sin embargo, se recomienda utilizar un usuario con un control de acceso detallado en el entorno de producción.
- Un rol de IAM que se usará para Amazon Redshift con la capacidad de solicitar credenciales temporales de la base de datos de desarrollo del clúster de Amazon Redshift
- Estudio de Amazon EMR con los roles de IAM necesarios
- Amazon EMR lanza la versión 6.9.0 en un clúster EC2 con los roles de IAM necesarios
- Versión 6.9.0 de una aplicación sin servidor de Amazon EMR
- Una conexión de AWS Glue y un trabajo de AWS Glue versión 4.0
- A Cuaderno Jupyter para ejecutar con Amazon EMR Studio con Amazon EMR en un clúster EC2
- Un script de PySpark para ejecutar con Amazon EMR Studio y Amazon EMR Serverless

Una vez completada la creación de la pila, elija el nombre de la pila redshift-spark y navegar a la Salidas

Utilizaremos estos valores de salida más adelante en esta publicación.

En las siguientes secciones, mostramos los pasos para la integración de Amazon Redshift para Apache Spark de Amazon EMR en Amazon EC2, Amazon EMR Serverless y AWS Glue.

Utilice la integración de Amazon Redshift con Apache Spark en Amazon EMR en EC2

A partir de la versión 6.9.0 y posteriores de Amazon EMR, el conector que utiliza la integración de Amazon Redshift para Apache Spark y el controlador JDBC de Amazon Redshift están disponibles localmente en Amazon EMR. Estos archivos se encuentran bajo el /usr/share/aws/redshift/ directorio. Sin embargo, en las versiones anteriores de Amazon EMR, el vibrante e inclusiva versión de la spark-redshift conector está disponible.

El siguiente ejemplo muestra cómo conectar Amazon Redshift usando un kernel PySpark a través de un Estudio de Amazon EMR computadora portátil. La pila de CloudFormation creó Amazon EMR Studio, Amazon EMR en un clúster EC2 y un cuaderno Jupyter disponible para ejecutar. Para ir a través de este ejemplo, complete los siguientes pasos:

Descargue el cuaderno Jupyter Notebook disponible en el depósito S3 para usted:
- En los resultados de la pila de CloudFormation, busque el valor de EMRStudioNotebook, que debe apuntar a la redshift-spark-emr.ipynb notebook disponible en el cubo S3.
- Elija el enlace o ábralo en una nueva pestaña copiando la URL del cuaderno.
- Después de abrir el enlace, descargue el cuaderno eligiendo Descargar, que guardará el archivo localmente en su computadora.

Acceda a Amazon EMR Studio eligiendo o copiando el enlace proporcionado en los resultados de la pila de CloudFormation para la clave EMRStudioURL.
En el panel de navegación, elija Espacios de trabajo.
Elige Crear espacio de trabajo.
Proporcione un nombre para el espacio de trabajo, por ejemplo redshift-spark.
Ampliar la opción Configuracion avanzada sección y seleccione Asociar Workspace a un clúster de EMR.
under Adjuntar a un clúster de EMR, elija el clúster de EMR con el nombre emrCluster-Redshift-Spark.
Elige Crear espacio de trabajo.
Una vez creado el espacio de trabajo de Amazon EMR Studio y en estado Adjunto, puede acceder al espacio de trabajo eligiendo el nombre del espacio de trabajo.

Esto debería abrir el espacio de trabajo en una nueva pestaña. Tenga en cuenta que si tiene un bloqueador de ventanas emergentes, es posible que deba permitir que Workspace abra o deshabilite el bloqueador de ventanas emergentes.

En el espacio de trabajo de Amazon EMR Studio, ahora cargamos el cuaderno Jupyter que descargamos anteriormente.

Elige Subir para explorar su sistema de archivos local y cargar el cuaderno Jupyter (redshift-spark-emr.ipynb).
Elija (doble clic) el redshift-spark-emr.ipynb libreta dentro del espacio de trabajo para abrir la libreta.

El cuaderno proporciona los detalles de las diferentes tareas que realiza. Tenga en cuenta que en la sección Defina las variables para conectarse al clúster de Amazon Redshift, no necesita actualizar los valores para jdbc_iam_url, temp_diry aws_role porque AWS CloudFormation los actualiza automáticamente. AWS CloudFormation también ha realizado los pasos mencionados en el Requisitos previos sección del cuaderno.

Ahora puede comenzar a ejecutar el cuaderno.

Ejecute las celdas individuales seleccionándolas y luego eligiendo Jugar.

También puede utilizar la combinación de teclas de Shift + Enter or Mayús+Retorno. Alternativamente, puede ejecutar todas las celdas eligiendo Ejecutar todas las celdas en Ejecutar .

Encuentre la operación pushdown de predicado realizada en el clúster de Amazon Redshift por la integración de Amazon Redshift para Apache Spark.

También podemos ver los datos temporales almacenados en Amazon S3 en el formato Parquet optimizado. La salida se puede ver al ejecutar la celda en la sección Obtenga la última consulta ejecutada en Amazon Redshift.

Para validar la tabla creada por el trabajo de Amazon EMR en Amazon EC2, vaya a la consola de Amazon Redshift y elija el clúster redshift-spark-redshift-cluster en Panel de control de clústeres aprovisionados .
En los detalles del clúster, en la Consultar datos menú, seleccione Consulta en el editor de consultas v2.
Elija el clúster en el panel de navegación y conéctese al clúster de Amazon Redshift cuando solicite la autenticación.
Seleccione Credenciales temporales.
Base de datos, introduzca dev.
nombre de usuario, introduzca redshiftmasteruser.
Elige Guardar.
En el panel de navegación, expanda el clúster redshift-spark-redshift-cluster, expanda la base de datos de desarrollo, expanda tickity expandir Mesas para listar todas las tablas dentro del esquema tickit.

Deberías encontrar la mesa. test_emr.

Elija (clic derecho) la tabla test_emr, A continuación, elija Seleccionar tabla para consultar la tabla.
Elige Ejecutar para ejecutar la instrucción SQL.

Utilice la integración de Amazon Redshift con Apache Spark en Amazon EMR Serverless

La versión de lanzamiento de Amazon EMR 6.9.0 y superior proporciona la integración de Amazon Redshift para Apache Spark JAR (administrado por Amazon Redshift) y Amazon Redshift JDBC JAR localmente en Amazon EMR Serverless también. Estos archivos se encuentran bajo el /usr/share/aws/redshift/ directorio. En el siguiente ejemplo, usamos la secuencia de comandos de Python disponible en el depósito S3 por la pila de CloudFormation que creamos anteriormente.

En las salidas de la pila de CloudFormation, anote el valor de EMRServerlessExecutionScript, que es la ubicación del script de Python en el depósito de S3.
También tenga en cuenta el valor de EMRServerlessJobExecutionRole, que es el rol de IAM que se utilizará con la ejecución del trabajo sin servidor de Amazon EMR.
Acceda a Amazon EMR Studio eligiendo o copiando el enlace proporcionado en los resultados de la pila de CloudFormation para la clave EMRStudioURL.
Elige Aplicaciones bajo Sin servidor en el panel de navegación.

Encontrará una aplicación EMR creada por la pila de CloudFormation con el nombre emr-spark-redshift.

Elija el nombre de la aplicación para enviar un trabajo.
Elige Enviar trabajo.
under Detalles del trabajo, Para Nombre, introduzca un nombre identificable para el trabajo.
Rol de tiempo de ejecución, elija el rol de IAM que anotó en el resultado de la pila de CloudFormation anteriormente.
Ubicación del guión, proporcione la ruta a la secuencia de comandos de Python que anotó anteriormente en la salida de la pila de CloudFormation.
Ampliar la sección Propiedades de chispa Y elige la Editar en texto

Ingrese el siguiente valor en el cuadro de texto, que proporciona la ruta al redshift-connector, controlador JDBC de Amazon Redshift, spark-avro TARRO, y minimal-json Archivos JAR:

--jars /usr/share/aws/redshift/jdbc/RedshiftJDBC.jar,/usr/share/aws/redshift/spark-redshift/lib/spark-redshift.jar,/usr/share/aws/redshift/spark-redshift/lib/spark-avro.jar,/usr/share/aws/redshift/spark-redshift/lib/minimal-json.jar

Elige Enviar trabajo.
Espere a que se complete el trabajo y el estado de ejecución se muestre como éxito.
Navegue al editor de consultas de Amazon Redshift para ver si la tabla se creó correctamente.
Compruebe las consultas pushdown ejecutadas para el grupo de consultas de Amazon Redshift emr-serverless-redshift. Puede ejecutar la siguiente instrucción SQL en la base de datos dev:
```
SELECT query_text FROM SYS_QUERY_HISTORY WHERE query_label = 'emr-serverless-redshift' ORDER BY start_time DESC LIMIT 1
```

Puede ver que la consulta pushdown y los resultados devueltos se almacenan en formato de archivo Parquet en Amazon S3.

Utilice la integración de Amazon Redshift con Apache Spark en AWS Glue

A partir de AWS Glue versión 4.0 y superior, los trabajos de Apache Spark que se conectan a Amazon Redshift pueden usar la integración de Amazon Redshift para Apache Spark y el controlador JDBC de Amazon Redshift. Los trabajos existentes de AWS Glue que ya utilizan Amazon Redshift como origen o destino se pueden actualizar a AWS Glue 4.0 para aprovechar este nuevo conector. La plantilla de CloudFormation proporcionada con esta publicación crea los siguientes recursos de AWS Glue:

Conexión de AWS Glue para Amazon Redshift – La conexión para establecer la conexión de AWS Glue a Amazon Redshift mediante la integración de Amazon Redshift para Apache Spark
Rol de IAM adjunto al trabajo de AWS Glue – El rol de IAM para administrar permisos para ejecutar el trabajo de AWS Glue
Trabajo AWS Glue – El script para el trabajo de AWS Glue que realiza transformaciones y agregaciones mediante la integración de Amazon Redshift para Apache Spark

El siguiente ejemplo utiliza la conexión de AWS Glue adjunta al trabajo de AWS Glue con PySpark e incluye los siguientes pasos:

En la consola de AWS Glue, elija Conexiones en el panel de navegación.
under Conexiones, elija la conexión de AWS Glue para Amazon Redshift creada por la plantilla de CloudFormation.
Verifique los detalles de la conexión.

Ahora puede reutilizar esta conexión dentro de un trabajo o en varios trabajos.

En Conectores página, elija el trabajo de AWS Glue creado por la pila de CloudFormation en Tus trabajoso acceda al trabajo de AWS Glue utilizando la URL proporcionada para la clave GlueJob en la salida de la pila de CloudFormation.
Acceda y verifique el script para el trabajo de AWS Glue.
En Detalles del trabajo pestaña, asegúrese de que Versión con pegamento se establece a Pegamento 4.0.

Esto asegura que el trabajo utiliza la última redshift-spark conector.

Expandir Propiedades avanzadas y en el Conexiones sección, verifique que la conexión creada por la pila de CloudFormation esté adjunta.
Verifique los parámetros de trabajo agregados para el trabajo de AWS Glue. Estos valores también están disponibles en la salida de la pila de CloudFormation.
Elige Guardar y luego Ejecutar.

Puede ver el estado de la ejecución del trabajo en la Ejecutar .

Una vez que la ejecución del trabajo se completa correctamente, puede verificar el resultado de la tabla test-glue creada por el trabajo de AWS Glue.
Verificamos las consultas pushdown ejecutadas para el grupo de consultas de Amazon Redshift glue-redshift. Puede ejecutar la siguiente instrucción SQL en la base de datos dev:
```
SELECT query_text FROM SYS_QUERY_HISTORY WHERE query_label = 'glue-redshift' ORDER BY start_time DESC LIMIT 1
```

Mejores prácticas

Tenga en cuenta las siguientes prácticas recomendadas:

Considere usar la integración de Amazon Redshift para Apache Spark de Amazon EMR en lugar de usar el redshift-spark conector (versión comunitaria) para sus nuevos trabajos de Apache Spark.
Si tiene trabajos existentes de Apache Spark que usan el redshift-spark conector (versión de la comunidad), considere actualizarlos para usar la integración de Amazon Redshift para Apache Spark
La integración de Amazon Redshift para Apache Spark aplica automáticamente la inserción de consultas y predicados para optimizar el rendimiento. Recomendamos usar funciones compatibles (autopushdown) en su consulta. La integración de Amazon Redshift para Apache Spark convertirá la función en una consulta SQL y ejecutará la consulta en Amazon Redshift. Esta optimización da como resultado la recuperación de los datos necesarios, por lo que Apache Spark puede procesar menos datos y tener un mejor rendimiento.
- Considere usar funciones pushdown agregadas como avg, count, max, miny sum para recuperar datos filtrados para el procesamiento de datos.
- Considere el uso de operadores booleanos pushdown como in, isnull, isnotnull, contains, endswithy startswith para recuperar datos filtrados para el procesamiento de datos.
- Considere el uso de operadores lógicos de inserción como and, ory not (o !) para recuperar datos filtrados para el procesamiento de datos.
Se recomienda pasar un rol de IAM usando el parámetro aws_iam_role para la autenticación de Amazon Redshift desde su aplicación Apache Spark en Amazon EMR o AWS Glue. El rol de IAM debe tener los permisos necesarios para recuperar las credenciales de IAM temporales para autenticarse en Amazon Redshift, como se muestra en la sección "Ejemplos de integración de Amazon Redshift para Apache Spark en una aplicación de Apache Spark" de este blog.
Con esta característica, no tiene que mantener su nombre de usuario y contraseña de Amazon Redshift en el administrador de secretos y la base de datos de Amazon Redshift.
Amazon Redshift utiliza la instrucción UNLOAD SQL para almacenar estos datos temporales en Amazon S3. La aplicación Apache Spark recupera los resultados del directorio temporal (almacenado en formato de archivo Parquet). Este directorio temporal en Amazon S3 no se limpia automáticamente y, por lo tanto, podría agregar un costo adicional. Recomendamos usar Políticas de ciclo de vida de Amazon S3 para definir las reglas de retención para el depósito S3.
Se recomienda encender Registro de auditoría de Amazon Redshift para registrar la información sobre las conexiones y las actividades de los usuarios en su base de datos.
Se recomienda encender Cifrado en reposo de Amazon Redshift para cifrar sus datos mientras Amazon Redshift los escribe en sus centros de datos y descifrarlos cuando acceda a ellos.
Se recomienda actualizar a AWS Glue v4.0 y superior para usar la integración de Amazon Redshift para Apache Spark, que está disponible de forma inmediata. La actualización a esta versión de AWS Glue utilizará automáticamente esta función.
Se recomienda actualizar a Amazon EMR v6.9.0 y superior para usar la integración de Amazon Redshift para Apache Spark. No tiene que administrar ningún controlador o archivo JAR de forma explícita.
Considere usar notebooks de Amazon EMR Studio para interactuar con sus datos de Amazon Redshift en su aplicación Apache Spark.
Considere usar AWS Glue Studio para crear trabajos de Apache Spark usando una interfaz visual. También puede cambiar a escribir código Apache Spark en Scala o PySpark dentro de AWS Glue Studio.

Limpiar

Complete los siguientes pasos para limpiar los recursos que se crean como parte de la plantilla de CloudFormation para asegurarse de que no se le facturen los recursos si ya no los usará:

Detenga la aplicación sin servidor de Amazon EMR:
- Acceda a Amazon EMR Studio eligiendo o copiando el enlace proporcionado en los resultados de la pila de CloudFormation para la clave EMRStudioURL.
- Elige Aplicaciones bajo Sin servidor en el panel de navegación.

Encontrará una aplicación EMR creada por la pila de CloudFormation con el nombre emr-spark-redshift.

- Si el estado de la aplicación se muestra como Detenido, puede pasar a los siguientes pasos. Sin embargo, si el estado de la aplicación es Iniciado, elija el nombre de la aplicación, luego elija Detener aplicación y Detener aplicación de nuevo para confirmar

Elimine el espacio de trabajo de Amazon EMR Studio:
- Acceda a Amazon EMR Studio eligiendo o copiando el enlace proporcionado en los resultados de la pila de CloudFormation para la clave EMRStudioURL.
- Elige Espacios de trabajo en el panel de navegación.
- Seleccione el espacio de trabajo que creó y elija Borrar, A continuación, elija Borrar de nuevo para confirmar
Elimine la pila de CloudFormation:

- En la consola de AWS CloudFormation, navegue hasta la pila que creó anteriormente.
- Elija el nombre de la pila y luego elija Borrar para eliminar la pila y eliminar los recursos creados como parte de esta publicación.
- En la pantalla de confirmación, seleccione Eliminar pila.

Conclusión

En esta publicación, explicamos cómo puede usar la integración de Amazon Redshift para Apache Spark para crear e implementar aplicaciones con Amazon EMR en Amazon EC2, Amazon EMR Serverless y AWS Glue para aplicar automáticamente predicado y consulta pushdown para optimizar el rendimiento de la consulta de datos. en Amazon Redshift. Se recomienda encarecidamente utilizar la integración de Amazon Redshift para Apache Spark para una conexión segura y sin inconvenientes a Amazon Redshift desde su Amazon EMR o AWS Glue.

Esto es lo que algunos de nuestros clientes tienen que decir sobre la integración de Amazon Redshift para Apache Spark:

“Empoderamos a nuestros ingenieros para que construyan sus canalizaciones de datos y aplicaciones con Apache Spark usando Python y Scala. Queríamos una solución personalizada que simplificara las operaciones y se entregara de manera más rápida y eficiente para nuestros clientes, y eso es lo que obtuvimos con la nueva integración de Amazon Redshift para Apache Spark”.

—Consultoría Huron

“GE Aerospace utiliza el análisis de AWS y Amazon Redshift para habilitar conocimientos comerciales críticos que impulsan decisiones comerciales importantes. Con la compatibilidad con la copia automática de Amazon S3, podemos crear canalizaciones de datos más simples para mover datos de Amazon S3 a Amazon Redshift. Esto acelera la capacidad de nuestros equipos de productos de datos para acceder a los datos y brindar información a los usuarios finales. Dedicamos más tiempo a agregar valor a través de los datos y menos tiempo a las integraciones”.

—GE aeroespacial

“Nuestro enfoque es proporcionar acceso de autoservicio a los datos para todos nuestros usuarios en Goldman Sachs. A través de Legend, nuestra plataforma de gobierno y administración de datos de código abierto, permitimos a los usuarios desarrollar aplicaciones centradas en datos y obtener información basada en datos a medida que colaboramos en la industria de servicios financieros. Con la integración de Amazon Redshift para Apache Spark, nuestro equipo de plataforma de datos podrá acceder a los datos de Amazon Redshift con un mínimo de pasos manuales, lo que permitirá ETL de código cero que aumentará nuestra capacidad para facilitar que los ingenieros se concentren en perfeccionar su flujo de trabajo como recopilan información completa y oportuna. Esperamos ver una mejora en el rendimiento de las aplicaciones y una mayor seguridad, ya que nuestros usuarios ahora pueden acceder fácilmente a los datos más recientes en Amazon Redshift”.

-Goldman Sachs

Acerca de los autores

gagan brahmi es un arquitecto de soluciones especializado sénior centrado en el análisis de big data y la plataforma AI/ML en Amazon Web Services. Gagan tiene más de 18 años de experiencia en tecnología de la información. Ayuda a los clientes a diseñar y crear soluciones basadas en la nube altamente escalables, seguras y de alto rendimiento en AWS. En su tiempo libre, pasa tiempo con su familia y explora nuevos lugares.

vivek gautam es Arquitecto de Datos con especialización en lagos de datos en AWS Professional Services. Trabaja con clientes empresariales que crean productos de datos, plataformas de análisis y soluciones en AWS. Cuando no está construyendo y diseñando lagos de datos, Vivek es un entusiasta de la comida al que también le gusta explorar nuevos destinos de viaje y hacer caminatas.

Naresh Gautam es un líder de análisis de datos e inteligencia artificial/aprendizaje automático en AWS con 20 años de experiencia, que disfruta ayudando a los clientes a diseñar análisis de datos y soluciones de inteligencia artificial/aprendizaje automático altamente disponibles, de alto rendimiento y rentables para empoderar a los clientes con la toma de decisiones basada en datos . En su tiempo libre, disfruta de la meditación y la cocina.

Bella Sharifi es un ingeniero de desarrollo de software dentro del equipo de controladores de Amazon Redshift, donde lidera el desarrollo de la integración de Amazon Redshift con el conector Apache Spark. Tiene más de 20 años de experiencia en la creación de plataformas basadas en datos en múltiples industrias. En su tiempo libre, disfruta pasar tiempo con su familia y surfear.