Descripción general

En este lab, aprenderás a migrar código de Apache Spark a Cloud Dataproc. Seguirás la secuencia de pasos que aparece a continuación, la cual te permitirá mover progresivamente más componentes del trabajo a los servicios de Google Cloud:

• Ejecución de código original de Spark en Cloud Dataproc (lift-and-shift)
• Reemplazo de HDFS con Cloud Storage (nativo de la nube)
• Automatización total para que se ejecute en clústeres específicos del trabajo (optimizado para la nube)

Qué aprenderás

En este lab, aprenderás a realizar lo siguiente:

• Migrar trabajos de Spark existentes a Cloud Dataproc
• Modificar trabajos de Spark para usar Cloud Storage en lugar de HDFS
• Optimizar trabajos de Spark para que se ejecuten en clústeres específicos del trabajo

Qué necesitarás

• Cloud Dataproc
• Apache Spark

Configuración y requisitos

En cada lab, recibirá un proyecto de Google Cloud y un conjunto de recursos nuevos por tiempo limitado y sin costo adicional.

1. Accede a Qwiklabs desde una ventana de incógnito.

2. Ten en cuenta el tiempo de acceso del lab (por ejemplo, 1:15:00) y asegúrate de finalizarlo en el plazo asignado.
   No existe una función de pausa. Si lo necesita, puede reiniciar el lab, pero deberá hacerlo desde el comienzo.

3. Cuando esté listo, haga clic en Comenzar lab.

4. Anote las credenciales del lab (el nombre de usuario y la contraseña). Las usarás para acceder a la consola de Google Cloud.

5. Haga clic en Abrir Google Console.

6. Haga clic en Usar otra cuenta, copie las credenciales para este lab y péguelas en el mensaje emergente que aparece.
   Si usa otras credenciales, se generarán errores o incurrirá en cargos.

7. Acepta las condiciones y omite la página de recursos de recuperación.

Activa Google Cloud Shell

Google Cloud Shell es una máquina virtual que cuenta con herramientas para desarrolladores. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud.

Google Cloud Shell proporciona acceso de línea de comandos a tus recursos de Google Cloud.

1. En la consola de Cloud, en la barra de herramientas superior derecha, haz clic en el botón Abrir Cloud Shell.

   

2. Haz clic en Continuar.

El aprovisionamiento y la conexión al entorno demorarán unos minutos. Cuando te conectes, habrás completado la autenticación, y el proyecto estará configurado con tu PROJECT_ID. Por ejemplo:

gcloud es la herramienta de línea de comandos de Google Cloud. Viene preinstalada en Cloud Shell y es compatible con el completado de línea de comando.

• Puedes solicitar el nombre de la cuenta activa con este comando:

gcloud auth list

Resultado:

Credentialed accounts: - @.com (active)

Resultado de ejemplo:

Credentialed accounts: - google1623327_student@qwiklabs.net

• Puedes solicitar el ID del proyecto con este comando:

gcloud config list project

Resultado:

[core] project =

Resultado de ejemplo:

[core] project = qwiklabs-gcp-44776a13dea667a6 Nota: La documentación completa de gcloud está disponible en la guía de descripción general de gcloud CLI .

Verifica los permisos del proyecto

Antes de comenzar a trabajar en Google Cloud, asegúrate de que tu proyecto tenga los permisos correctos en Identity and Access Management (IAM).

1. En la consola de Google Cloud, en el Menú de navegación (), selecciona IAM y administración > IAM.

2. Confirma que aparezca la cuenta de servicio predeterminada de Compute {número-del-proyecto}-compute@developer.gserviceaccount.com, y que tenga asignado el rol Editor. El prefijo de la cuenta es el número del proyecto, que puedes encontrar en el Menú de navegación > Descripción general de Cloud > Panel.

Nota: Si la cuenta no aparece en IAM o no tiene asignado el rol Editor, sigue los pasos que se indican a continuación para asignar el rol necesario.

1. En la consola de Google Cloud, en el Menú de navegación, haz clic en Descripción general de Cloud > Panel.
2. Copia el número del proyecto (p. ej., 729328892908).
3. En el Menú de navegación, selecciona IAM y administración > IAM.
4. En la parte superior de la tabla de funciones, debajo de Ver por principales, haz clic en Otorgar acceso.
5. En Principales nuevas, escribe lo siguiente:

{project-number}-compute@developer.gserviceaccount.com

6. Reemplaza {número-del-proyecto} por el número de tu proyecto.
7. En Rol, selecciona Proyecto (o Básico) > Editor.
8. Haz clic en Guardar.

Situación

Migrarás una carga de trabajo existente de Spark a Cloud Dataproc y, luego, modificarás progresivamente el código de Spark para usar funciones y servicios nativos de Google Cloud.

Tarea 1. Lift-and-shift

Migra trabajos de Spark existentes a Cloud Dataproc

Crearás un nuevo clúster de Cloud Dataproc. Luego, ejecutarás un notebook de Jupyter importado que use el sistema de archivos distribuido de Hadoop (HDFS) local y predeterminado del clúster para almacenar datos de origen y, finalmente, procesarás los datos como lo harías en cualquier clúster de Hadoop con Spark. Esto demuestra la cantidad de cargas de trabajo de estadísticas existentes, como los notebooks de Jupyter que contienen código de Spark, que no requieren cambios cuando se migran a un entorno de Cloud Dataproc.

Cómo configurar e iniciar un clúster de Cloud Dataproc

1. En la consola de Google Cloud, en el menú de navegación que aparece en la sección Estadísticas, haz clic en Dataproc.

2. Haz clic en Crear clúster.

3. Haz clic en Crear del elemento Clúster en Compute Engine.

4. Ingresa sparktodp en Nombre del clúster.

5. Establece la región en y la zona en .

6. En la sección Control de versiones, haz clic en Cambiar y selecciona 2.1 (Debian 11, Hadoop 3.3, Spark 3.3).

Esta versión incluye Python3, que se requiere para el código de muestra que se usa en este lab.

7. Haz clic en Seleccionar.

8. En la sección Componentes > Puerta de enlace del componente, selecciona Habilitar puerta de enlace de componentes.

9. En Componentes opcionales, selecciona Jupyter Notebook.

10. En Configura el clúster, en la lista del lado izquierdo, haz clic en Configura los nodos (opcional).

11. En Nodo de administrador, cambia Serie a E2 y Tipo de máquina a e2-standard-2 (2 CPU virtuales, 8 GB de memoria) y establece el Tamaño del disco principal en 30.

12. En Nodos trabajadores cambia Serie a E2 y Tipo de máquina a e2-standard-2 (2 CPU virtuales, 8 GB de memoria) y configura el Tamaño del disco principal en 30.

13. Haz clic en Crear.

El clúster debería iniciarse en unos minutos. Espera hasta que el clúster de Cloud Dataproc esté completamente implementado para continuar con el siguiente paso.

Clona el repositorio de código fuente para el lab

En Cloud Shell, clona el repositorio de Git para el lab y copia los archivos del notebook necesarios para el bucket de Cloud Storage que usa Cloud Dataproc como directorio principal para notebooks de Jupyter.

1. Para clonar el repositorio de Git que necesitas en el lab, ingresa el siguiente comando en Cloud Shell:

git -C ~ clone https://github.com/GoogleCloudPlatform/training-data-analyst

2. Para buscar el bucket de Cloud Storage predeterminado que usa Cloud Dataproc, ingresa el siguiente comando en Cloud Shell:

export DP_STORAGE="gs://$(gcloud dataproc clusters describe sparktodp --region={{{project_0.default_region | REGION }}} --format=json | jq -r '.config.configBucket')"

3. Para copiar los notebooks de muestra en la carpeta de trabajo de Jupyter, ingresa el siguiente comando en Cloud Shell:

gcloud storage cp ~/training-data-analyst/quests/sparktobq/*.ipynb $DP_STORAGE/notebooks/jupyter

Accede al notebook de Jupyter

En cuanto el clúster se haya iniciado por completo, podrás conectarte a las interfaces web. Haz clic en el botón de actualización para comprobarlo, ya que tal vez esté implementado por completo cuando llegues a esta etapa.

1. En la página de clústeres de Dataproc, espera a que el clúster termine de iniciarse y haz clic en el nombre de tu clúster para abrir la página Detalles del clúster.

2. Haz clic en Interfaces web.

3. Haz clic en el vínculo de Jupyter para abrir una nueva pestaña de Jupyter en tu navegador.

Se abrirá la página principal de Jupyter. Allí podrás ver el contenido del directorio /notebooks/jupyter en Cloud Storage, que ahora incluye los notebooks de muestra de Jupyter que se usan en este lab.

4. En la pestaña Archivos, haz clic en la carpeta de GCS y, luego, haz clic en el notebook 01_spark.ipynb para abrirlo.

5. Haz clic en Cell y, luego, en Run all para ejecutar todas las celdas del notebook.

6. Desplázate hacia arriba hasta la parte superior del notebook y sigue el proceso hasta que el notebook haya terminado de ejecutar cada celda y aparezca el resultado debajo.

Ahora puedes recorrer las celdas y examinar el código mientras se procesa para poder ver qué está haciendo el notebook. Presta especial atención al lugar donde se guardan y se procesan los datos.

• La primera celda de código recupera el archivo de datos de origen, que es un extracto de la competencia KDD Cup de la conferencia Knowledge, Discovery, and Data (KDD) realizada en 1999. Los datos están relacionados con eventos de detección de intrusiones en computadoras.

!wget https://storage.googleapis.com/cloud-training/dataengineering/lab_assets/sparklab/kddcup.data_10_percent.gz

• En la segunda celda de código, los datos de origen se copian en el sistema de archivos de Hadoop predeterminado (local).

!hadoop fs -put kddcup* /

• En la tercera celda de código, el comando muestra el contenido del directorio predeterminado del sistema de archivos HDFS del clúster.

!hadoop fs -ls /

Lectura de datos

Los datos se comprimen con gzip en archivos CSV. En Spark, se pueden leer directamente con el método textFile y, luego, se pueden analizar dividiendo cada fila con comas.

El código de Spark de Python comienza en la celda In[4].

• En esa celda, se inicializa Spark SQL y se usa Spark para leer los datos de origen como texto. Luego, muestra las primeras 5 filas.

from pyspark.sql import SparkSession, SQLContext, Row spark = SparkSession.builder.appName("kdd").getOrCreate() sc = spark.sparkContext data_file = "hdfs:///kddcup.data_10_percent.gz" raw_rdd = sc.textFile(data_file).cache() raw_rdd.take(5)

• En la celda In [5], cada fila se divide con , como delimitador y se analiza con un esquema intercalado preparado en el código.

csv_rdd = raw_rdd.map(lambda row: row.split(",")) parsed_rdd = csv_rdd.map(lambda r: Row( duration=int(r[0]), protocol_type=r[1], service=r[2], flag=r[3], src_bytes=int(r[4]), dst_bytes=int(r[5]), wrong_fragment=int(r[7]), urgent=int(r[8]), hot=int(r[9]), num_failed_logins=int(r[10]), num_compromised=int(r[12]), su_attempted=r[14], num_root=int(r[15]), num_file_creations=int(r[16]), label=r[-1] ) ) parsed_rdd.take(5)

Análisis de Spark

En la celda In [6], se crea un contexto de Spark SQL y también se crea un DataFrame de Spark con ese contexto, para lo cual se usan los datos de entrada analizados de la etapa anterior.

1. Los datos de las filas se pueden seleccionar y mostrar con el método .show() del DataFrame para obtener una vista que resuma el recuento de los campos seleccionados:

sqlContext = SQLContext(sc) df = sqlContext.createDataFrame(parsed_rdd) connections_by_protocol = df.groupBy('protocol_type').count().orderBy('count', ascending=False) connections_by_protocol.show()

El método .show() produce una tabla con resultados similares a los siguientes:

+-------------+------+ |protocol_type| count| +-------------+------+ | icmp|283602| | tcp|190065| | udp| 20354| +-------------+------+

Spark SQL también se puede usar para consultar los datos analizados que están almacenados en el DataFrame.

2. En la celda In [7], se registra una tabla temporal (connections) a la que luego se hace referencia dentro de la sentencia de consulta en SQL posterior de Spark SQL.

df.registerTempTable("connections") attack_stats = sqlContext.sql(""" SELECT protocol_type, CASE label WHEN 'normal.' THEN 'no attack' ELSE 'attack' END AS state, COUNT(*) as total_freq, ROUND(AVG(src_bytes), 2) as mean_src_bytes, ROUND(AVG(dst_bytes), 2) as mean_dst_bytes, ROUND(AVG(duration), 2) as mean_duration, SUM(num_failed_logins) as total_failed_logins, SUM(num_compromised) as total_compromised, SUM(num_file_creations) as total_file_creations, SUM(su_attempted) as total_root_attempts, SUM(num_root) as total_root_acceses FROM connections GROUP BY protocol_type, state ORDER BY 3 DESC """) attack_stats.show()

Cuando la consulta haya finalizado, verás un resultado similar al siguiente ejemplo truncado:

+-------------+---------+----------+--------------+-- |protocol_type| state|total_freq|mean_src_bytes| +-------------+---------+----------+--------------+-- | icmp| attack| 282314| 932.14| | tcp| attack| 113252| 9880.38| | tcp|no attack| 76813| 1439.31| ... ... | udp| attack| 1177| 27.5| +-------------+---------+----------+--------------+--

También puedes usar gráficos de barras para mostrar los datos.

3. En la última celda, In [8], se usa la función mágica %matplotlib inline de Jupyter para redireccionar matplotlib para renderizar una figura gráfica intercalada en el notebook en lugar de solo volcar los datos en una variable. Esta celda muestra un gráfico de barras que se creó con la consulta attack_stats del paso anterior.

%matplotlib inline ax = attack_stats.toPandas().plot.bar(x='protocol_type', subplots=True, figsize=(10,25))

La primera parte del resultado debería verse como el siguiente gráfico una vez que todas las celdas del notebook se hayan ejecutado correctamente. Puedes desplazarte hacia abajo en tu notebook para ver el gráfico de resultados completo.

Tarea 2: Separa el procesamiento y el almacenamiento

Modifica trabajos de Spark para usar Cloud Storage en lugar de HDFS

Con el notebook original "Lift & Shift" de muestra, ahora crearás una copia que separe los requisitos de almacenamiento del trabajo de los requisitos de procesamiento. En este caso, solo tendrás que reemplazar las llamadas del sistema de archivos de Hadoop con llamadas de Cloud Storage. Para hacerlo, en el código, debes reemplazar las referencias de almacenamiento hdfs:// con referencias gs:// y ajustar los nombres de las carpetas según sea necesario.

Comenzarás usando Cloud Shell para colocar una copia de los datos de origen en un nuevo bucket de Cloud Storage.

1. En Cloud Shell, crea un nuevo bucket de almacenamiento para tus datos de origen:

export PROJECT_ID=$(gcloud info --format='value(config.project)') gcloud storage buckets create gs://$PROJECT_ID

2. Luego, copia los datos de origen en el bucket:

wget https://storage.googleapis.com/cloud-training/dataengineering/lab_assets/sparklab/kddcup.data_10_percent.gz gcloud storage cp kddcup.data_10_percent.gz gs://$PROJECT_ID/

Asegúrate de que se complete el último comando y de que el archivo se haya copiado en tu nuevo bucket de almacenamiento.

3. Vuelve a la pestaña del notebook de Jupyter 01_spark en tu navegador.

4. Haz clic en File y luego selecciona Make a copy.

5. Cuando la copia se abra, haz clic en el título 01_spark-Copy1 y cámbiale el nombre a De-couple-storage.

6. Abre la pestaña de Jupyter de 01_spark.

7. Haz clic en File y, luego, en Save and checkpoint para guardar el notebook.

8. Haz clic en Archivo y, luego, en Close and Halt para cerrar el notebook.

• Si se te solicita que confirmes si quieres cerrar el notebook, haz clic en Leave o Cancel.

9. Si es necesario, vuelve a la pestaña del notebook de Jupyter De-couple-storage en tu navegador.

Ya no necesitas las celdas que descargan y copian los datos en el sistema de archivos HDFS interno del clúster, por lo que serán las primeras que quitarás.

Si deseas borrar una celda, debes hacer clic en ella para seleccionarla y, luego, en el ícono para cortar las celdas seleccionadas (las tijeras) en la barra de herramientas del notebook.

10. Borra las celdas de comentarios iniciales y las primeras tres celdas de código (In [1], In [2] e In [3]) de manera que ahora el notebook comience con la sección Reading in Data.

Ahora cambiarás el código de la primera celda (que sigue llamándose In [4], a menos que hayas vuelto a ejecutar el notebook), que define la ubicación de origen del archivo de datos y lee los datos del origen. Actualmente, la celda contiene el siguiente código:

from pyspark.sql import SparkSession, SQLContext, Row spark = SparkSession.builder.appName("kdd").getOrCreate() sc = spark.sparkContext data_file = "hdfs:///kddcup.data_10_percent.gz" raw_rdd = sc.textFile(data_file).cache() raw_rdd.take(5)

11. Reemplaza el contenido de la celda In [4] por el siguiente código. El único cambio que se produce aquí es la creación de una variable para almacenar un nombre de bucket de Cloud Storage y, luego, apuntar data_file al bucket que usamos para almacenar los datos de origen en Cloud Storage:

from pyspark.sql import SparkSession, SQLContext, Row gcs_bucket='[Your-Bucket-Name]' spark = SparkSession.builder.appName("kdd").getOrCreate() sc = spark.sparkContext data_file = "gs://"+gcs_bucket+"//kddcup.data_10_percent.gz" raw_rdd = sc.textFile(data_file).cache() raw_rdd.take(5)

Cuando hayas reemplazado el código, la primera celda será similar a la siguiente, con el ID del proyecto de tu lab como nombre del bucket:

12. En la celda que actualizaste, reemplaza el marcador de posición [Your-Bucket-Name] por el nombre del bucket de almacenamiento que creaste en el primer paso de esta sección. Cuando creaste ese bucket, le asignaste como nombre el ID del proyecto, el cual se puede copiar aquí desde el panel de información de acceso al lab de Qwiklabs a la izquierda de esta pantalla. Reemplaza todo el texto del marcador de posición, incluidos los corchetes [].

13. Haz clic en Cell y, luego, en Run all para ejecutar todas las celdas del notebook.

Verás exactamente el mismo resultado que viste cuando se cargó y ejecutó el archivo desde el almacenamiento del clúster interno. Para mover los archivos de datos de origen a Cloud Storage, solo debes volver a apuntar la referencia de origen del almacenamiento de hdfs:// a gs://.

Tarea 3: Implementa trabajos de Spark

Optimiza trabajos de Spark para que se ejecuten en clústeres específicos del trabajo

Ahora crearás un archivo de Python independiente que se pueda implementar como trabajo de Cloud Dataproc y que realizará las mismas funciones que este notebook. Para hacerlo, agrega los comandos mágicos a las celdas de Python en una copia de este notebook con el objetivo de escribir el contenido de la celda en un archivo. También agregarás un controlador de parámetros de entrada para configurar la ubicación del bucket de almacenamiento cuando se llame a la secuencia de comandos de Python para que el código sea más portátil.

1. En el menú De-couple-storage del notebook de Jupyter, haz clic en Archivo y selecciona Crear una copia.

2. Cuando se abra la copia, haz clic en De-couple-storage-Copy1 y cámbiale el nombre a PySpark-analysis-file.

3. Abre la pestaña de Jupyter para De-couple-storage.

4. Haz clic en File y, luego, en Save and checkpoint para guardar el notebook.

5. Haz clic en Archivo y, luego, en Close and Halt para cerrar el notebook.

• Si se te solicita que confirmes si quieres cerrar el notebook, haz clic en Leave o Cancel.

6. Si es necesario, regresa a la pestaña del notebook de Jupyter PySpark-analysis-file en tu navegador.

7. Haz clic en la primera celda, en la parte superior del notebook.

8. Haz clic en Insert y selecciona Insert Cell Above.

9. Pega la siguiente importación de la biblioteca y el código de organización de parámetros en esta nueva primera celda de código, de la siguiente manera:

%%writefile spark_analysis.py import matplotlib matplotlib.use('agg') import argparse parser = argparse.ArgumentParser() parser.add_argument("--bucket", help="bucket for input and output") args = parser.parse_args() BUCKET = args.bucket

El comando mágico de Jupyter %%writefile spark_analysis.py crea un nuevo archivo de resultados que contiene tu secuencia de comandos de Python independiente. Agregarás una variación de esto a las celdas restantes para adjuntar el contenido de cada celda al archivo de secuencia de comandos independiente.

Este código también importa el módulo matplotlib y configura explícitamente el backend de trazado predeterminado mediante matplotlib.use('agg'), de manera que el código de trazado se ejecute fuera de un notebook de Jupyter.

10. En las celdas restantes, inserta %%writefile -a spark_analysis.py al inicio de cada celda de código de Python. Estas son las cinco celdas que contienen la etiqueta In [x].

%%writefile -a spark_analysis.py

Por ejemplo, la próxima celda debería verse de la siguiente manera:

%%writefile -a spark_analysis.py from pyspark.sql import SparkSession, SQLContext, Row spark = SparkSession.builder.appName("kdd").getOrCreate() sc = spark.sparkContext data_file = "gs://{}/kddcup.data_10_percent.gz".format(BUCKET) raw_rdd = sc.textFile(data_file).cache() #raw_rdd.take(5)

11. Repite este paso e inserta %%writefile -a spark_analysis.py al comienzo de cada celda de código hasta llegar al final.

12. En la última celda, donde se traza el gráfico de barras de Pandas, quita el comando mágico %matplotlib inline.

Nota: Debes quitar esta directiva mágica de matplotlib intercalada de Jupyter; de lo contrario, tu secuencia de comandos fallará cuando la ejecutes.

13. Asegúrate de haber seleccionado la última celda de código en el notebook. Luego, en la barra de menú, haz clic en Insert y selecciona Insert Cell Below.

14. Pega el siguiente código en la nueva celda:

%%writefile -a spark_analysis.py ax[0].get_figure().savefig('report.png');

15. Agrega otra celda nueva al final del notebook y pega lo siguiente:

%%writefile -a spark_analysis.py import google.cloud.storage as gcs bucket = gcs.Client().get_bucket(BUCKET) for blob in bucket.list_blobs(prefix='sparktodp/'): blob.delete() bucket.blob('sparktodp/report.png').upload_from_filename('report.png')

16. Agrega una nueva celda al final del notebook y pega lo siguiente:

%%writefile -a spark_analysis.py connections_by_protocol.write.format("csv").mode("overwrite").save( "gs://{}/sparktodp/connections_by_protocol".format(BUCKET))

Automatización de pruebas

Ahora, deberás probar que el código de PySpark se ejecute correctamente como archivo. Para ello, llama a la copia local desde dentro del notebook y pasa un parámetro para identificar el bucket de almacenamiento que creaste antes y que almacena los datos de entrada para este trabajo. El mismo bucket se usará para almacenar los archivos de datos de informes producidos por la secuencia de comandos.

1. En el notebook PySpark-analysis-file, agrega una nueva celda al final del notebook y pega lo siguiente:

BUCKET_list = !gcloud info --format='value(config.project)' BUCKET=BUCKET_list[0] print('Writing to {}'.format(BUCKET)) !/opt/conda/miniconda3/bin/python spark_analysis.py --bucket=$BUCKET

En este código, se supone que seguiste las instrucciones anteriores y que creaste un bucket de Cloud Storage con el ID del proyecto de tu lab como nombre del bucket. Si usaste un nombre diferente, modifica el código para definir la variable BUCKET con el nombre que usaste.

2. Agrega una nueva celda al final del notebook y pega lo siguiente:

!gcloud storage ls gs://$BUCKET/sparktodp/**

Esto enumera los archivos de resultados de la secuencia de comandos que se guardaron en tu bucket de Cloud Storage.

3. Para guardar una copia del archivo de Python en el almacenamiento persistente, agrega una nueva celda y pega lo siguiente:

!gcloud storage cp spark_analysis.py gs://$BUCKET/sparktodp/spark_analysis.py

4. Haz clic en Cell y, luego, en Run all para ejecutar todas las celdas del notebook.

Si el notebook crea y ejecuta correctamente el archivo de Python, deberías ver un resultado similar al siguiente para las últimas dos celdas. Esto indica que se completó la ejecución de la secuencia de comandos y se guardó el resultado en el bucket de Cloud Storage que creaste anteriormente en el lab.

Nota: Si se produce un error en esta etapa, es muy probable que se deba a que no quitaste la directiva de matplotlib en In [7]. Vuelve a comprobar que modificaste todas las celdas según las instrucciones anteriores y que no omitiste ningún paso.

Ejecuta el trabajo de análisis desde Cloud Shell

1. Vuelve a Cloud Shell y copia la secuencia de comandos de Python de Cloud Storage para ejecutarla como trabajo de Cloud Dataproc:

gcloud storage cp gs://$PROJECT_ID/sparktodp/spark_analysis.py spark_analysis.py

2. Crea una secuencia de comandos de inicio, de la siguiente manera:

nano submit_onejob.sh

3. Pega lo siguiente en la secuencia de comandos:

#!/bin/bash gcloud dataproc jobs submit pyspark \ --cluster sparktodp \ --region {{{project_0.default_region | REGION }}} \ spark_analysis.py \ -- --bucket=$1

4. Presiona CTRL + X, luego Y y, luego, Intro para salir y guardar los cambios.

5. Haz que la secuencia de comandos sea ejecutable:

chmod +x submit_onejob.sh

6. Inicia el trabajo de análisis de PySpark:

./submit_onejob.sh $PROJECT_ID

7. En la pestaña de la consola de Cloud, navega a la página Dataproc > Clústeres si aún no está abierta.

8. Haz clic en Trabajos.

9. Haz clic en el nombre del trabajo que aparece. Puedes supervisar el progreso desde aquí y desde Cloud Shell. Espera a que se complete el trabajo correctamente.

10. Ve a tu depósito de almacenamiento y observa que el informe de resultados, /sparktodp/report.png, tiene una marca de tiempo actualizada que indica que el trabajo independiente se completó correctamente.

El bucket de almacenamiento que usa este trabajo para el almacenamiento de datos de entrada y salida es el bucket que se usa para el nombre del ID de proyecto.

11. Navega nuevamente a la página Dataproc > Clústeres.

12. Selecciona el clúster sparktodp y haz clic en Borrar. Ya no lo necesitas.

13. Haz clic en CONFIRMAR.

14. Cierra las pestañas de Jupyter en tu navegador.

Finalice su lab

Cuando haya completado el lab, haga clic en Finalizar lab. Google Cloud Skills Boost quitará los recursos que usó y limpiará la cuenta.

Tendrá la oportunidad de calificar su experiencia en el lab. Seleccione la cantidad de estrellas que corresponda, ingrese un comentario y haga clic en Enviar.

La cantidad de estrellas indica lo siguiente:

• 1 estrella = Muy insatisfecho
• 2 estrellas = Insatisfecho
• 3 estrellas = Neutral
• 4 estrellas = Satisfecho
• 5 estrellas = Muy satisfecho

Puede cerrar el cuadro de diálogo si no desea proporcionar comentarios.

Para enviar comentarios, sugerencias o correcciones, use la pestaña Asistencia.

Copyright 2020 Google LLC. All rights reserved. Google y el logotipo de Google son marcas de Google LLC. Los demás nombres de productos y empresas pueden ser marcas de las respectivas empresas a las que estén asociados.