Présentation

Dans cet atelier, vous allez apprendre à migrer du code Apache Spark vers Cloud Dataproc. Vous allez effectuer une série d'étapes pour transférer progressivement des composants de jobs vers des services Google Cloud :

• Exécuter le code Spark d'origine sur Cloud Dataproc (Lift and Shift)
• Remplacer HDFS par Cloud Storage (cloud natif)
• Automatiser le processus pour que les jobs s'exécutent sur des clusters adaptés (optimisés pour le cloud)

Points abordés

Dans cet atelier, vous allez apprendre à effectuer les tâches suivantes :

• Migrer des jobs Spark existants vers Cloud Dataproc
• Modifier des jobs Spark afin qu'ils utilisent Cloud Storage au lieu de HDFS
• Optimiser des jobs Spark pour une exécution sur des clusters adaptés

Outils utilisés

• Cloud Dataproc
• Apache Spark

Préparation

Pour chaque atelier, nous vous attribuons un nouveau projet Google Cloud et un nouvel ensemble de ressources pour une durée déterminée, sans frais.

1. Connectez-vous à Qwiklabs dans une fenêtre de navigation privée.

2. Vérifiez le temps imparti pour l'atelier (par exemple : 01:15:00) : vous devez pouvoir le terminer dans ce délai.
   Une fois l'atelier lancé, vous ne pouvez pas le mettre en pause. Si nécessaire, vous pourrez le redémarrer, mais vous devrez tout reprendre depuis le début.

3. Lorsque vous êtes prêt, cliquez sur Démarrer l'atelier.

4. Notez vos identifiants pour l'atelier (Nom d'utilisateur et Mot de passe). Ils vous serviront à vous connecter à Google Cloud Console.

5. Cliquez sur Ouvrir la console Google.

6. Cliquez sur Utiliser un autre compte, puis copiez-collez les identifiants de cet atelier lorsque vous y êtes invité.
   Si vous utilisez d'autres identifiants, des messages d'erreur s'afficheront ou des frais seront appliqués.

7. Acceptez les conditions d'utilisation et ignorez la page concernant les ressources de récupération des données.

Activer Google Cloud Shell

Google Cloud Shell est une machine virtuelle qui contient de nombreux outils pour les développeurs. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud.

Google Cloud Shell vous permet d'accéder à vos ressources Google Cloud grâce à une ligne de commande.

1. Dans la barre d'outils située en haut à droite dans la console Cloud, cliquez sur le bouton "Ouvrir Cloud Shell".

   

2. Cliquez sur Continuer.

Le provisionnement et la connexion à l'environnement prennent quelques instants. Une fois connecté, vous êtes en principe authentifié et le projet est défini sur votre ID_PROJET. Par exemple :

gcloud est l'outil de ligne de commande pour Google Cloud. Il est préinstallé sur Cloud Shell et permet la complétion par tabulation.

• Vous pouvez lister les noms des comptes actifs à l'aide de cette commande :

gcloud auth list

Résultat :

Credentialed accounts: - @.com (active)

Exemple de résultat :

Credentialed accounts: - google1623327_student@qwiklabs.net

• Vous pouvez lister les ID de projet à l'aide de cette commande :

gcloud config list project

Résultat :

[core] project =

Exemple de résultat :

[core] project = qwiklabs-gcp-44776a13dea667a6 Remarque : Pour consulter la documentation complète sur gcloud, accédez au guide de présentation de la gcloud CLI.

Vérifier les autorisations du projet

Avant de commencer à travailler dans Google Cloud, vous devez vous assurer de disposer des autorisations adéquates pour votre projet dans IAM (Identity and Access Management).

1. Dans la console Google Cloud, accédez au menu de navigation (), puis sélectionnez IAM et administration > IAM.

2. Vérifiez que le compte de service Compute par défaut {project-number}-compute@developer.gserviceaccount.com existe et qu'il est associé au rôle editor (éditeur). Le préfixe du compte correspond au numéro du projet, disponible sur cette page : Menu de navigation > Présentation du cloud > Tableau de bord.

Remarque : Si le compte n'est pas disponible dans IAM ou n'est pas associé au rôle editor (éditeur), procédez comme suit pour lui attribuer le rôle approprié.

1. Dans la console Google Cloud, accédez au menu de navigation et cliquez sur Présentation du cloud > Tableau de bord.
2. Copiez le numéro du projet (par exemple, 729328892908).
3. Dans le menu de navigation, sélectionnez IAM et administration > IAM.
4. Sous Afficher par compte principal, en haut de la table des rôles, cliquez sur Accorder l'accès.
5. Dans le champ Nouveaux comptes principaux, saisissez :

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

6. Remplacez {project-number} par le numéro de votre projet.
7. Dans le champ Rôle, sélectionnez Projet (ou Basique) > Éditeur.
8. Cliquez sur Enregistrer.

Scénario

Vous allez transférer une charge de travail Spark vers Cloud Dataproc, puis modifier progressivement le code Spark afin d'utiliser les fonctionnalités et services natifs de Google Cloud.

Tâche 1 : Migration Lift and Shift

Migrer des jobs Spark existants vers Cloud Dataproc

Vous allez créer un cluster Cloud Dataproc, puis vous exécuterez un notebook Jupyter qui utilise le système de fichiers HDFS (Hadoop Distributed File System) local pour stocker les données source. Vous traiterez ensuite ces données exactement comme vous le feriez sur n'importe quel cluster Hadoop à l'aide de Spark. Ceci montre que pour un grand nombre de charges de travail analytiques existantes telles que les notebooks Jupyter contenant du code Spark, la migration vers un environnement Cloud Dataproc ne nécessite aucune modification.

Configurer et démarrer un cluster Cloud Dataproc

1. Dans la console Google Cloud, accédez au menu de navigation et, dans la section Analyse, cliquez sur Dataproc.

2. Cliquez sur Créer un cluster.

3. Cliquez sur Créer à côté de l'élément Cluster sur Compute Engine.

4. Dans le champ Nom du cluster, saisissez sparktodp.

5. Définissez la région sur et la zone sur .

6. Dans la section Gestion des versions, cliquez sur Modifier, puis choisissez 2.1 (Debian 11, Hadoop 3.3, Spark 3.3).

Cette version inclut Python3, dont nous avons besoin pour l'exemple de code utilisé dans cet atelier.

7. Cliquez sur Sélectionner.

8. Accédez à Composants > Passerelle des composants, puis sélectionnez Activer la passerelle des composants.

9. Choisissez l'option Jupyter Notebook sous Composants facultatifs.

10. Dans la liste de gauche, sous Configurer le cluster, cliquez sur Configurer les nœuds (facultatif).

11. Sous Nœud du gestionnaire, choisissez E2 pourSérie et e2-standard-2 (2 vCPU, 8 Go de mémoire) pour Type de machine, puis définissez Taille du disque principal sur 30.

12. Sous Nœuds de calcul, choisissez E2 pour Série et e2-standard-2 (2 vCPU, 8 Go de mémoire) pour Type de machine, puis définissez Taille du disque principal sur 30.

13. Cliquez sur Créer.

Le cluster devrait démarrer dans quelques minutes. Veuillez attendre que le cluster Cloud Dataproc soit entièrement déployé avant de passer à la prochaine étape.

Cloner le dépôt source associé à cet atelier

Dans Cloud Shell, vous allez cloner le dépôt Git de cet atelier, puis copier les fichiers de notebook requis dans le bucket Cloud Storage utilisé par Cloud Dataproc en tant que répertoire d'accueil pour les notebooks Jupyter.

1. Pour cloner le dépôt Git associé à cet atelier, saisissez la commande suivante dans Cloud Shell :

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

2. Pour localiser le bucket Cloud Storage par défaut utilisé par Cloud Dataproc, saisissez la commande suivante dans Cloud Shell :

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

3. Pour copier les exemples de notebook dans le dossier de travail Jupyter, saisissez la commande suivante dans Cloud Shell :

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

Se connecter au notebook Jupyter

Dès que le démarrage du cluster est terminé, vous pouvez vous connecter aux interfaces Web. Cliquez sur le bouton "Actualiser" pour vérifier, car il est possible que le déploiement soit déjà terminé à ce stade.

1. Sur la page "Dataproc Clusters" (Clusters Dataproc), attendez la fin du démarrage du cluster, puis cliquez sur son nom pour ouvrir la page Cluster details (Détails du cluster).

2. Cliquez sur Web Interfaces (Interfaces Web).

3. Cliquez sur le lien Jupyter pour ouvrir un nouvel onglet Jupyter dans le navigateur.

La page d'accueil de Jupyter s'ouvre. Vous pouvez voir sur cette page le contenu du répertoire /notebooks/jupyter créé dans Cloud Storage, qui comprend désormais les exemples de notebook Jupyter utilisés dans cet atelier.

4. Sous l'onglet Fichiers, cliquez sur le dossier GCS, puis sur le nom de notebook 01_spark.ipynb pour l'ouvrir.

5. Cliquez sur Cellule, puis sur Tout exécuter pour exécuter toutes les cellules du notebook.

6. Faites défiler la page jusqu'en haut du notebook et continuez à faire défiler, car à mesure que chaque cellule est exécutée par le notebook, le résultat s'affiche en dessous.

Vous pouvez maintenant faire défiler les cellules vers le bas et suivre le traitement du code pour observer l'activité du notebook. Notez en particulier l'emplacement dans lequel les données sont enregistrées et à partir duquel elles sont traitées.

• La première cellule de code récupère le fichier des données source, qui est un extrait de la KDD Cup Competition de la conférence Knowledge, Discovery, and Data (KDD) de 1999. Ces données concernent des événements de détection d'intrusion dans des systèmes informatiques.

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

• Dans la deuxième cellule de code, les données source sont copiées dans le système de fichiers Hadoop (local) par défaut.

!hadoop fs -put kddcup* /

• Dans la troisième cellule de code, la commande liste le contenu du répertoire par défaut dans le système de fichiers HDFS du cluster.

!hadoop fs -ls /

Lecture des données

Les données sont des fichiers CSV compressés avec gzip. Dans Spark, ces fichiers peuvent être lus directement à l'aide de la méthode textFile, puis analysés en fractionnant chaque ligne après chaque virgule.

Le code Python Spark commence dans la cellule In[4].

• Dans cette cellule, Spark SQL est initialisé. Spark est utilisé pour lire les données source comme du texte, puis renvoie les cinq premières lignes.

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)

• Dans la cellule In [5], chaque ligne est fractionnée au niveau de la virgule ( ,), qui est utilisée comme délimiteur. Ensuite, chaque ligne est analysée à l'aide d'un schéma préparé intégré dans le code.

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)

Analyse Spark

Dans la cellule In [6], un contexte SQL Spark est généré, et un DataFrame Spark utilisant ce contexte est créé à l'aide des données d'entrée analysées à l'étape précédente.

1. Sélectionnez et affichez les données de ligne à l'aide de la méthode .show() du DataFrame pour récupérer en sortie une vue récapitulant le nombre de champs sélectionnés :

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

La méthode .show() produit une table de sortie semblable à celle-ci :

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

SparkSQL permet également d'interroger les données analysées stockées dans le Dataframe.

2. La cellule In [7] contient une table temporaire (connections) enregistrée, qui est ensuite référencée dans l'instruction de requête SQL SparkSQL suivante :

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()

Lorsque la requête est terminée, vous devez voir un résultat semblable à cet exemple (lequel est volontairement tronqué) :

+-------------+---------+----------+--------------+-- |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| +-------------+---------+----------+--------------+--

Notez que vous pouvez aussi afficher ces données sous forme de graphiques à barres.

3. La dernière cellule, In [8], utilise la fonction magique de Jupyter %matplotlib inline pour rediriger matplotlib afin de rendre une figure graphique intégrée dans le notebook, au lieu de seulement insérer les données dans une variable. Cette cellule affiche un graphique à barres reposant sur la requête attack_stats utilisée dans l'étape précédente.

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

La première partie de la sortie doit normalement ressembler au graphique suivant, une fois que toutes les cellules du notebook ont été correctement exécutées. Vous pouvez faire défiler le notebook vers le bas pour visualiser l'intégralité du graphique.

Tâche 2 : Séparation du calcul et du stockage

Modifier des jobs Spark afin qu'ils utilisent Cloud Storage au lieu de HDFS

À partir de cet exemple initial de notebook créé via une migration "Lift and Shift", vous allez maintenant créer une copie qui dissocie les exigences de stockage associées au job des exigences en termes de calcul. En l'espèce, il vous suffit de remplacer les appels de système de fichiers Hadoop par des appels Cloud Storage. Pour ce faire, substituez des références de stockage gs:// aux références de stockage hdfs:// dans le code, puis modifiez les noms de dossiers en conséquence.

Pour commencer, vous utiliserez Cloud Shell pour placer une copie des données source dans un nouveau bucket Cloud Storage.

1. Dans Cloud Shell, créez un bucket de stockage pour vos données source :

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

2. Dans Cloud Shell, copiez les données source dans le 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/

Assurez-vous que l'exécution de la dernière commande est terminée et que le fichier a été copié dans le nouveau bucket de stockage.

3. Dans le navigateur, revenez à l'onglet du notebook Jupyter 01_spark.

4. Cliquez sur File (Fichier), puis sélectionnez Make a Copy (Créer une copie).

5. Lorsque la copie s'ouvre, cliquez sur le titre 01_spark-Copy1 et renommez-le De-couple-storage.

6. Ouvrez l'onglet Jupyter pour 01_spark.

7. Cliquez sur File (Fichier), puis sur Save and checkpoint (Enregistrer et effectuer un point de contrôle) pour enregistrer le notebook.

8. Cliquez sur File (Fichier), puis sur Close and Halt (Fermer et interrompre) pour fermer le notebook.

• Si vous êtes invité à confirmer que vous voulez fermer le notebook, cliquez sur Leave (Quitter) ou Cancel (Annuler).

9. Si nécessaire, retournez dans l'onglet du notebook Jupyter De-couple-storage du navigateur.

Vous n'avez plus besoin des cellules qui téléchargent et copient les données dans le système de fichiers HDFS interne du cluster. Vous allez donc commencer par les supprimer.

Pour supprimer une cellule, cliquez dessus pour la sélectionner, puis cliquez sur l'icône Cut selected cells (Couper les cellules sélectionnées) sur la barre d'outils du notebook.

10. Supprimez les cellules de commentaires initiaux et les trois premières cellules de code (In [1], In [2] et In [3]) afin que le notebook commence maintenant par la section Reading in Data (Lecture des données).

Vous allez maintenant modifier le code dans la première cellule (encore appelée In[4] si vous n'avez pas réexécuté le notebook) qui définit l'emplacement source du fichier de données et lit dans les données source. Cette cellule contient actuellement le code suivant :

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. Remplacez le contenu de la cellule In [4] par le code suivant. La seule modification effectuée ici consiste à créer une variable pour stocker un nom de bucket Cloud Storage, puis à faire pointer le data_file vers le bucket que nous avons utilisé pour stocker les données source dans 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)

Une fois le code modifié, la première cellule ressemble à ce qui suit, votre ID de projet pour cet atelier étant utilisé comme nom du bucket :

12. Dans la cellule que vous venez de modifier, remplacez l'espace réservé [Your-Bucket-Name] par le nom du bucket de stockage que vous avez créé lors de la première étape de cette section. Vous avez créé ce bucket en utilisant comme nom l'ID du projet. Vous pouvez le copier ici à partir du panneau des informations de connexion de Qwiklabs, situé dans la partie gauche de cet écran. Remplacez la totalité du texte de l'espace réservé, y compris les crochets [].

13. Cliquez sur Cellule, puis sur Tout exécuter pour exécuter toutes les cellules du notebook.

Le résultat qui s'affiche est strictement identique à ce que vous avez pu observer lorsque le fichier a été chargé et exécuté à partir de l'espace de stockage interne du cluster. Pour transférer les fichiers de données source vers Cloud Storage, il vous suffit de remplacer la référence de votre source de stockage hdfs:// par gs://.

Tâche 3 : Déploiement de jobs Spark

Optimiser des jobs Spark pour une exécution sur des clusters adaptés

Vous allez maintenant créer un fichier Python autonome, pouvant être déployé en tant que job Cloud Dataproc, qui exécutera les mêmes fonctions que ce notebook. Pour ce faire, vous ajouterez des commandes magiques aux cellules Python dans une copie de ce notebook pour écrire le contenu des cellules dans un fichier. Vous allez également ajouter un gestionnaire de paramètres d'entrée pour définir l'emplacement du bucket de stockage lorsque le script Python est appelé afin d'améliorer la portabilité du code.

1. Dans le menu du notebook Jupyter De-couple-storage, cliquez sur Fichier, puis sélectionnez Créer une copie.

2. Lorsque la copie s'ouvre, cliquez sur De-couple-storage-Copy1 et renommez cet élément PySpark-analysis-file.

3. Ouvrez l'onglet du notebook Jupyter De-couple-storage.

4. Cliquez sur File (Fichier), puis sur Save and checkpoint (Enregistrer et effectuer un point de contrôle) pour enregistrer le notebook.

5. Cliquez sur File (Fichier), puis sur Close and Halt (Fermer et interrompre) pour fermer le notebook.

• Si vous êtes invité à confirmer que vous voulez fermer le notebook, cliquez sur Leave (Quitter) ou Cancel (Annuler).

6. Si nécessaire, retournez à l'onglet du notebook Jupyter PySpark-analysis-file du navigateur.

7. Cliquez sur la première cellule en haut du notebook.

8. Cliquez sur Insert (Insérer), puis sélectionnez Insert Cell Above (Insérer la cellule au-dessus).

9. Collez le code d'importation de bibliothèque et de gestion de paramètres suivant dans cette nouvelle première cellule de code :

%%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

La commande magique Jupyter %%writefile spark_analysis.py crée un fichier de sortie destiné à accueillir votre script Python autonome. Vous allez ajouter une variation de cette commande aux cellules restantes pour ajouter le contenu de chaque cellule au fichier de script autonome.

Ce code importe également le module matplotlib et définit explicitement le backend de traçage par défaut via matplotlib.use('agg') afin que le code de traçage s'exécute en dehors d'un notebook Jupyter.

10. Pour les cellules restantes, insérez %%writefile -a spark_analysis.py au début de chaque cellule de code Python. Voici les cinq cellules intitulées In [x].

%%writefile -a spark_analysis.py

La cellule suivante doit maintenant ressembler à ceci :

%%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. Répétez cette étape en insérant %%writefile -a spark_analysis.py au début de chaque cellule de code, jusqu'à la dernière.

12. Dans la dernière cellule, où est tracé le graphique à barres Pandas, supprimez la commande magique %matplotlib inline.

Remarque : L'exécution de votre script échouera si vous ne supprimez pas la directive magique Jupyter intégrée matplotlib.

13. Assurez-vous que vous avez sélectionné la dernière cellule de code dans le notebook, puis, dans la barre de menu, cliquez sur Insert (Insérer) et sélectionnez Insert Cell Below (Insérer la cellule au-dessus).

14. Collez le code suivant dans la nouvelle cellule :

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

15. Ajoutez une autre cellule à la fin du notebook, et collez-y le code suivant :

%%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. Ajoutez une nouvelle cellule à la fin du notebook, et collez-y le code suivant :

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

Automatisation des tests

Vous allez maintenant vérifier que le code PySpark s'exécute correctement en tant que fichier en appelant sa copie locale à partir du notebook, en transmettant un paramètre permettant d'identifier le bucket de stockage créé précédemment, dans lequel sont stockées les données d'entrée pour ce job. Le même bucket sera utilisé pour stocker les fichiers de données de rapport produites par ce script.

1. Dans le notebook PySpark-analysis-file, ajoutez une nouvelle cellule à la fin, et collez-y le code suivant :

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

Ce code suppose que vous avez suivi les instructions précédentes et créé un bucket Cloud Storage en utilisant l'ID du projet de cet atelier en tant que nom du bucket. Si vous avez utilisé un autre nom, modifiez ce code pour définir la variable BUCKET sur le nom que vous avez utilisé.

2. Ajoutez une nouvelle cellule à la fin du notebook, et collez-y le code suivant :

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

Cette commande liste les fichiers de sortie du script qui ont été enregistrés dans votre bucket Cloud Storage.

3. Pour enregistrer une copie du fichier Python sur le stockage persistant, ajoutez une nouvelle cellule, et collez-y le code suivant :

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

4. Cliquez sur Cellule, puis sur Tout exécuter pour exécuter toutes les cellules du notebook.

Si le notebook crée et exécute correctement le fichier Python, vous devriez obtenir un résultat semblable à celui-ci pour les deux dernières cellules. Ceci indique que le script a été exécuté intégralement et que le résultat de l'exécution a été enregistré dans le bucket Cloud Storage que vous avez créé précédemment dans cet atelier.

Remarque : La cause d'erreur la plus probable à ce stade est la non-suppression de la directive matplotlib dans In [7]. Vérifiez que vous avez bien modifié toutes les cellules en respectant les instructions ci-dessus, sans omettre aucune étape.

Exécuter la tâche d'analyse à partir de Cloud Shell

1. Repassez sur Cloud Shell et copiez le script Python à partir de Cloud Storage de façon à pouvoir l'exécuter en tant que job Cloud Dataproc :

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

2. Créez un script de lancement :

nano submit_onejob.sh

3. Collez le code suivant dans le script :

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

4. Appuyez sur CTRL+X, puis sur Y et sur Entrée pour quitter et enregistrer.

5. Rendez le script exécutable :

chmod +x submit_onejob.sh

6. Lancez le job d'analyse PySpark :

./submit_onejob.sh $PROJECT_ID

7. Dans l'onglet Cloud Console, accédez à la page Dataproc > Clusters si elle n'est pas déjà ouverte.

8. Cliquez sur Jobs (Tâches).

9. Cliquez sur nom de la tâche qui est répertoriée. Vous pouvez surveiller l'avancement sur cette page comme dans le Cloud Shell. Attendez que la tâche soit terminée.

10. Accédez au bucket de stockage et notez que le rapport de sortie /sparktodp/report.png comporte un horodatage mis à jour indiquant que la tâche autonome s'est effectuée correctement.

Le bucket de stockage utilisé par cette tâche pour le stockage des données d'entrée et de sortie est le bucket dont le nom correspond à l'ID de votre projet.

11. Accédez de nouveau à la page Dataproc > Clusters.

12. Sélectionnez le cluster sparktodp, puis cliquez sur Delete (Supprimer). Vous n'en avez plus besoin.

13. Cliquez sur CONFIRMER.

14. Fermez les onglets Jupyter de votre navigateur.

Terminer l'atelier

Une fois l'atelier terminé, cliquez sur Terminer l'atelier. Google Cloud Skills Boost supprime les ressources que vous avez utilisées, puis efface le compte.

Si vous le souhaitez, vous pouvez noter l'atelier. Sélectionnez un nombre d'étoiles, saisissez un commentaire, puis cliquez sur Envoyer.

Le nombre d'étoiles correspond à votre degré de satisfaction :

• 1 étoile = très insatisfait(e)
• 2 étoiles = insatisfait(e)
• 3 étoiles = ni insatisfait(e), ni satisfait(e)
• 4 étoiles = satisfait(e)
• 5 étoiles = très satisfait(e)

Si vous ne souhaitez pas donner votre avis, vous pouvez fermer la boîte de dialogue.

Pour soumettre des commentaires, suggestions ou corrections, veuillez accéder à l'onglet Assistance.

Copyright 2020 Google LLC Tous droits réservés. Google et le logo Google sont des marques de Google LLC. Tous les autres noms d'entreprises et de produits peuvent être des marques des entreprises auxquelles ils sont associés.