Muy buenas, me llamo Miguel y en esta ocasión les traigo un post.
Índice
Contenedores de Docker para probar sus scripts ETL de encendido de pegamento localmente sin incurrir en ningún costo adicional y sin usar Dev Endpoints
Con la creciente cantidad de datos en el mundo actual, la necesidad de servicios que manejen big data es muy exigente. Cuando pensamos en big data, hay muy pocos marcos que sean utilizados por la mayoría de los ingenieros de datos. Apache Spark es uno de ellos.
Apache Spark es un motor de procesamiento distribuido que r equires un racimo grande para ejecutar cualquier tipo de analytics o simplemente realizar ETL en el conjunto de datos. Para usar Apache Spark, necesitamos configurar grandes clústeres propios que son muy costosos o podemos aprovecharlos en la nube. Aquí, discutiremos los servicios proporcionados por AWS. Por lo tanto, para procesar grandes conjuntos de datos y realizar análisis sobre ellos mediante Spark, AWS proporciona dos servicios principales
- AWS EMR (reducción de mapa elástico)
- AWS Glue
AWS EMR nos proporciona un clúster para realizar nuestro procesamiento y son muy costosos, por lo que debemos tener cuidado para identificar durante cuánto tiempo necesitamos los clústeres y cómo optimizar nuestros trabajos correctamente. No cubriremos EMR en esta publicación, ya que es un tema muy extenso para discutir.
AWS Glue es un servicio ETL completamente administrado proporcionado por los servicios web de Amazon para manejar una gran cantidad de datos. La mejor parte de AWS Glue es que viene bajo el paraguas sin servidor de AWS donde no debemos preocuparnos por administrar todos esos clústeres y el costo asociado con ellos. En el paradigma sin servidor, pagamos por lo que usamos, por lo que si nuestro trabajo usa solo 25 DPU para procesar nuestros datos y se ejecuta durante 20 minutos, terminamos pagando solo el costo de aprovechar 25 DPU durante 20 minutos y ni un solo centavo. extra.
AWS Glue tiene una gran demanda hoy en día para crear trabajos de procesamiento de chispa basados en python o scala. Para desarrollar trabajos en AWS Glue, tenemos tres opciones. Discutámoslos uno por uno.
Cree el trabajo directamente en el editor de pegamento y ejecute el trabajo
Si es un desarrollador de Spark y no está tan familiarizado con las bibliotecas de pegamento y su generación de diagramas, evite usar este editor a toda costa. Esto es para aquellos que están muy seguros de lo que están escribiendo y sabían de corazón que su trabajo se ejecutará en la primera ejecución. Esto no se recomienda en absoluto y solo se puede considerar cuando necesitemos hacer algunos cambios en el trabajo existente. Usar el editor de trabajos directamente es bueno cuando usa bibliotecas de pegamento en su código, ya que genera el diagrama de linaje a medida que escribe el código. Antes de optar por esta opción, recomendaría consultar las bibliotecas de pegamentos aquí .
Cree un punto final de Glue Dev
Puede configurar un punto final de desarrollo de pegamento y vincularlo a cuadernos zeppelin oa su IDE de pycharm o incluso puede conectar cuadernos jupyter locales. Esta es una mejor opción si desea probar sus trabajos mientras los está desarrollando. Para configurar el punto final de Glue Dev, puede seguir la documentación oficial de AWS aquí . El único problema con este punto final de desarrollo de pegamento es su costo. Se le cobrará por el tiempo de ejecución, por lo que básicamente hace girar un clúster de EMR con la capacidad deseada y las bibliotecas de pegamento instaladas en el clúster. Esta es una de las mejores opciones si el costo no es un problema con su desarrollo y se puede considerar.
Utilice las bibliotecas de AWS Glue y ejecútelas en el contenedor Docker de forma local
Esta es, con mucho, la mejor opción teniendo en cuenta el desarrollo de los trabajos y la prueba de los trabajos en conjuntos de datos relativamente pequeños y, una vez que el trabajo está listo, ejecutarlos utilizando la propia consola de trabajos de cola. Con esta opción, obtiene la flexibilidad de usar bibliotecas de pegamento en su máquina o puede activar instancias EC2 de acuerdo con el tamaño de su conjunto de datos e iniciar el contenedor de la ventana acoplable en estos EC2, ya que esta será una opción relativamente más barata y la más adecuada. para ejecutar sus trabajos.
Para configurar AWS Glue de forma local, puede seguir la documentación de AWS aquí. Pero esto parece no estar funcionando y lo discutiremos en detalle. Así que he creado una imagen de Docker y explicaré lo que estamos haciendo.
FROM centos LABEL maintainer="Shubham Jain <shubhamakachamp@gmail.com>" ENV MAVEN=https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-common/apache-maven-3.6.0-bin.tar.gz ENV SPARK=https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-1.0/spark-2.4.3-bin-hadoop2.8.tgz ENV GLUE=https://github.com/awslabs/aws-glue-libs.git RUN mkdir glue RUN yum install -y python3 java-1.8.0-openjdk java-1.8.0-openjdk-devel tar git wget zip RUN ln -s /usr/bin/python3 /usr/bin/python RUN ln -s /usr/bin/pip3 /usr/bin/pip RUN pip install pandas RUN pip install boto3 RUN pip install pynt WORKDIR ./glue RUN git clone -b glue-1.0 $GLUE RUN wget $SPARK RUN wget $MAVEN RUN tar zxfv apache-maven-3.6.0-bin.tar.gz RUN tar zxfv spark-2.4.3-bin-hadoop2.8.tgz RUN rm spark-2.4.3-bin-hadoop2.8.tgz RUN rm apache-maven-3.6.0-bin.tar.gz RUN mv $(rpm -q -l java-1.8.0-openjdk-devel | grep "/bin$" | rev | cut -d"/" -f2- |rev) /usr/lib/jvm/jdk ENV SPARK_HOME /glue/spark-2.4.3-bin-spark-2.4.3-bin-hadoop2.8 ENV MAVEN_HOME /glue/apache-maven-3.6.0 ENV JAVA_HOME /usr/lib/jvm/jdk ENV GLUE_HOME /glue/aws-glue-libs ENV PATH $PATH:$MAVEN_HOME/bin:$SPARK_HOME/bin:$JAVA_HOME/bin:$GLUE_HOME/bin RUN sh /glue/aws-glue-libs/bin/glue-setup.sh RUN sed -i '/mvn -f/a rm /glue/aws-glue-libs/jarsv1/netty-*' /glue/aws-glue-libs/bin/glue-setup.sh RUN sed -i '/mvn -f/a rm /glue/aws-glue-libs/jarsv1/javax.servlet-3.*' /glue/aws-glue-libs/bin/glue-setup.sh RUN yum clean all RUN rm -rf /var/cache/yum CMD ["bash"]
Estoy tomando centos como imagen base y luego configurando estas variables env, lo necesitaremos para descargar las bibliotecas más adelante
ENV MAVEN=https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-common/apache-maven-3.6.0-bin.tar.gz ENV SPARK=https://aws-glue-etl-artifacts.s3.amazonaws.com/glue-1.0/spark-2.4.3-bin-hadoop2.8.tgz ENV GLUE=https://github.com/awslabs/aws-glue-libs.git
Luego crearemos un directorio pegado e instalaremos las bibliotecas requeridas como paquetes Java, Python, wget, tar y python y configuraremos nuestro directorio de trabajo para pegar
RUN mkdir glue RUN yum install -y python3 java-1.8.0-openjdk java-1.8.0-openjdk-devel tar git wget zip RUN ln -s /usr/bin/python3 /usr/bin/python RUN ln -s /usr/bin/pip3 /usr/bin/pip RUN pip install pandas RUN pip install boto3 RUN pip install pynt WORKDIR ./glue
Ahora en este directorio descargaré maven, spark y pegar las librerías y descomprimirlas. Luego actualizaremos la variable de ruta y agregaremos las variables SPARK_HOME, JAVA_HOME, MAVEN_HOME y GLUE_HOME.
#To get the latest aws libraries RUN git clone -b glue-1.0 $GLUE#To get latest spark version RUN wget $SPARK#To install Maven for dependencies RUN wget $MAVENRUN tar zxfv apache-maven-3.6.0-bin.tar.gz RUN tar zxfv spark-2.4.3-bin-hadoop2.8.tgz#Removing zip files inorder to reduce the final docker image size RUN rm spark-2.4.3-bin-hadoop2.8.tgz RUN rm apache-maven-3.6.0-bin.tar.gz#Setting up env variables RUN mv $(rpm -q -l java-1.8.0-openjdk-devel | grep "/bin$" | rev | cut -d"/" -f2- |rev) /usr/lib/jvm/jdk ENV SPARK_HOME /glue/spark-2.4.3-bin-spark-2.4.3-bin-hadoop2.8 ENV MAVEN_HOME /glue/apache-maven-3.6.0 ENV JAVA_HOME /usr/lib/jvm/jdk ENV GLUE_HOME /glue/aws-glue-libs ENV PATH $PATH:$MAVEN_HOME/bin:$SPARK_HOME/bin:$JAVA_HOME/bin:$GLUE_HOME/bin
Aquí hay un problema conocido importante en el que se eliminarán algunas de las bibliotecas https://github.com/awslabs/aws-glue-libs/issues/25.
RUN sed -i '/mvn -f/a rm /glue/aws-glue-libs/jarsv1/netty-*' /glue/aws-glue-libs/bin/glue-setup.shRUN sed -i '/mvn -f/a rm /glue/aws-glue-libs/jarsv1/javax.servlet-3.*' /glue/aws-glue-libs/bin/glue-setup.sh
Ahora compilaremos todas las dependencias usando maven. Este script de shell ejecuta el comando de compilación de maven y obtiene todas las dependencias necesarias.
Ejecutamos esto una vez para que nuestra imagen de la ventana acoplable contenga las bibliotecas de antemano y ahorre tiempo para ejecutar trabajos de chispa más adelante.
RUN sh /glue/aws-glue-libs/bin/glue-setup.sh
Por fin limpiaremos todos los directorios tmp y usaremos bash como nuestro punto de entrada a nuestro contenedor.
RUN yum clean all RUN rm -rf /var/cache/yum CMD ["bash"]
Ahora, use el archivo de la ventana acoplable y cree su contenedor para comenzar a desarrollar sus trabajos de encendido de pegamento.
Cree una imagen de Docker a partir de Dockerfile
Para crear la imagen a partir de este Dockerfile, ejecute el siguiente comando:
docker build -t jnshubham/glue_etl_local .
Extraiga la imagen existente de DockerHub
Para usar la imagen existente para iniciar su contenedor, simplemente extraiga la imagen de Docker Hub y ejecute los comandos proporcionados para enviar trabajos.
Para extraer la imagen, ejecute el siguiente comando:
docker pull jnshubham/glue_etl_local:latest
Verifique la imagen descargada ejecutando
docker images
Ejecuta el contenedor de Docker
Para ejecutar el contenedor y entrar en el shell de respuesta:
docker run jnshubham/glue_etl_local "gluepyspark"
Para ingresar a la terminal y enviar una ejecución de trabajo de chispa
docker run -it jnshubham/glue_etl_localgluesparksubmit script.py --JOB_NAME script
De esta manera, podrá probar su trabajo en su máquina local o también puede usar esto en cualquier instancia EC2 según el tamaño de sus datos.
Gracias por leer este artículo.
Añadir comentario