Commandes Apache Spark Essentielles avec Exemples Pratiques

Introduction

Apache Spark est un moteur unifié d'analyse de données pour le traitement de données à grande échelle. Maîtriser ses commandes fondamentales est essentiel pour toute personne exploitant des clusters Spark ou développant des pipelines de données. Ce guide propose un parcours pratique, axé sur les commandes, des opérations courantes avec Spark : vérifier les versions, inspecter votre environnement, effectuer des changements de configuration sécurisés, vérifier la santé du cluster et gérer les pannes. Chaque section comprend des commandes spécifiques, des sorties attendues et des conseils pour vous aider à passer d'un problème à une solution vérifiée.

Que vous soyez développeur, ingénieur DevOps ou membre d'une équipe technique de startup, cet article sert à la fois de tutoriel et de référence pratique — une antisèche pour les opérations quotidiennes de Spark. Nous donnons la priorité à la sécurité opérationnelle : observer avant de modifier, minimiser l'impact de toute modification, utiliser des espaces réservés au lieu de véritables identifiants et toujours définir une voie de récupération.

Inventaire de la version et de l'environnement

Avant d'exécuter une tâche Spark ou de modifier les paramètres, sachez exactement avec quoi vous travaillez. Cette phase d'inventaire est purement observationnelle — aucune modification n'est apportée. Capturez la version, le mode de déploiement et les ressources disponibles.

Vérification de la version de Spark

La commande la plus élémentaire consiste à vérifier la version de Spark. Exécutez :

spark-submit --version

La sortie attendue inclut des lignes telles que :

Welcome to
      ____              __
     / __/__  ___ _____/ /__
    _\ \/ _ \/ _ `/ __/  '_/
   /___/ .__/\_,_/_/ /_/\_\   version 3.5.1
      /_/

Si vous utilisez PySpark, vous pouvez également vérifier à partir d'un shell Python :

import pyspark
print(pyspark.__version__)

Inspection de la topologie de déploiement

Comprendre comment Spark est déployé (standalone, YARN, Kubernetes) affecte votre façon d'interagir avec lui. Utilisez l'interface Web Spark ou l'API REST. Pour obtenir des informations sur le cluster via REST, utilisez :

curl -s http://<hôte-maître>:8080/json/

Cette commande renvoie un JSON avec les workers, les applications, etc. Remplacez <hôte-maître> par l'adresse réelle de votre maître Spark. Si vous utilisez YARN, l'interface du gestionnaire de ressources est généralement sur le port 8088 et vous pouvez utiliser yarn node -list pour voir les nœuds.

Liste des ressources disponibles

Vérifiez combien de cœurs et de mémoire sont disponibles pour votre application. En mode standalone, utilisez l'interface Web Spark : http://<hôte-maître>:8080. Recherchez la section Workers. Pour une vérification en ligne de commande, utilisez spark-shell ou pyspark pour exécuter :

sc.statusTracker.getExecutorInfos

Cela montre les exécuteurs actifs, leurs cœurs et leur mémoire.

Prérequis et compatibilité

Assurez-vous que votre version de Java est compatible. Spark 3.x nécessite Java 8/11/17. Vérifiez avec java -version. Si vous utilisez Hadoop, vérifiez la compatibilité avec votre version de HDFS. Des versions incompatibles peuvent provoquer des erreurs cryptiques.

Parcours de configuration sécurisée

Modifier la configuration de Spark peut être risqué. Suivez toujours un parcours sécurisé : comprendre les paramètres actuels, commencer par une modification minimale et vérifier l'impact.

Affichage de la configuration actuelle

Pour voir tous les paramètres Spark actuels, utilisez l'interface Web Spark : http://<hôte-maître>:8080 et accédez à l'onglet Environnement pour une application en cours. Ou, à partir de la ligne de commande, utilisez :

spark-submit --help

Pour afficher des valeurs de configuration spécifiques, utilisez spark-submit avec --verbose (bien que cela n'en montre que quelques-unes). Sinon, utilisez un extrait Scala simple :

spark.conf.get("spark.executor.memory")

Effectuer une modification de configuration

Supposons que vous souhaitiez augmenter la mémoire de l'exécuteur pour une tâche. Le moyen le plus sûr est de la définir par tâche avec spark-submit :

spark-submit \
  --class com.example.MyApp \
  --master yarn \
  --executor-memory 4g \
  --num-executors 10 \
  monapp.jar

Évitez de modifier les valeurs par défaut à l'échelle du cluster, sauf en cas de nécessité. Si vous devez le faire, modifiez spark-defaults.conf dans $SPARK_HOME/conf. Sauvegardez d'abord le fichier :

cp spark-defaults.conf spark-defaults.conf.bak

Puis effectuez une seule modification, par exemple :

spark.executor.memory 4g

Vérification de la modification

Après avoir soumis une tâche avec le nouveau paramètre, confirmez qu'il a pris effet. Dans l'interface Web Spark, allez dans l'onglet Exécuteurs et vérifiez la colonne Mémoire. Ou, dans le journal de l'application, recherchez une ligne comme :

INFO MemoryStore: MemoryStore started with capacity 4.0 GB

Voie de récupération

Si la modification entraîne une dégradation des performances ou des échecs, annulez-la. Restaurez la sauvegarde :

cp spark-defaults.conf.bak spark-defaults.conf

Puis redémarrez les services concernés (s'il s'agit d'une configuration du maître ou du worker).

Vérification et diagnostics

Une fois que vous avez un cluster Spark, vous devez vérifier qu'il est sain et diagnostiquer les problèmes. Voici les commandes et outils clés.

Vérification de la santé du cluster

Pour le mode standalone, utilisez l'API REST pour voir tous les workers et leur état :

curl -s http://<hôte-maître>:8080/json/ | jq '.workers'

Recherchez state: ALIVE. Pour YARN, utilisez yarn node -list -all pour voir les nœuds actifs.

Exécution d'une tâche de test

Un moyen rapide de vérifier le cluster est d'exécuter un exemple simple de Spark. Spark inclut un exemple de calcul de Pi :

spark-submit \
  --class org.apache.spark.examples.SparkPi \
  --master yarn \
  --deploy-mode cluster \
  $SPARK_HOME/examples/jars/spark-examples_2.12-3.5.1.jar 10

La sortie attendue inclut des lignes comme :

Pi is roughly 3.141439

Cela confirme l'allocation des ressources et l'exécution des tâches.

Surveillance des applications

Utilisez l'interface Web Spark pour une surveillance en temps réel. Pour voir la liste des applications, allez sur http://<hôte-maître>:8080 et cliquez sur un ID d'application. Les indicateurs clés : les onglets Stages, Jobs, Storage et Environnement. Vous pouvez également utiliser l'API REST pour récupérer l'état des applications :

curl -s http://<hôte-maître>:8080/api/v1/applications

Journalisation et analyse des journaux

Les journaux sont cruciaux pour les diagnostics. Dans YARN, récupérez les journaux d'une application terminée avec :

yarn logs -applicationId <id-application>

Pour le mode standalone, les journaux se trouvent sur les workers dans $SPARK_HOME/logs. Recherchez des fichiers comme spark-<utilisateur>-org.apache.spark.deploy.worker-<hôte>.out. Utilisez grep pour rechercher les erreurs :

grep -i "error" worker.log

Commandes de diagnostic courantes

Vérifier la connectivité de Spark shell : spark-shell (ou pyspark) puis exécutez sc.version pour confirmer que le contexte est créé.
Vérifier la connectivité HDFS (si vous utilisez HDFS) : hdfs dfs -ls / pour voir si HDFS est accessible.
Tester le réseau pour le shuffle : utilisez curl -s http://<hôte-interface-spark>:8080 ou vérifiez la disponibilité du port avec nc -zv <hôte> 8080.

Modes de défaillance et récupération

Les défaillances surviennent. Connaître les modes de défaillance courants et savoir comment récupérer est essentiel.

Défaillances courantes et leurs symptômes

Dépassement de mémoire (OOM) : Symptôme : la tâche échoue avec java.lang.OutOfMemoryError ou les exécuteurs sont tués. Recherchez des journaux comme Container killed by YARN for exceeding memory limits.
Récupération : Augmentez la mémoire de l'exécuteur (--executor-memory) ou réduisez les données par partition (augmentez le parallélisme avec --conf spark.sql.shuffle.partitions=200).
Connexion refusée : Symptôme : java.net.ConnectException lors de la connexion au maître. Vérifiez que le processus maître est en cours d'exécution (jps devrait montrer Master et Worker).
Récupération : Redémarrez le maître et les workers. En mode standalone, exécutez sbin/start-master.sh et sbin/start-slaves.sh.
Erreurs de sérialisation : Symptôme : java.io.NotSerializableException. Cela se produit lors de l'utilisation de fonctions non sérialisables.
Récupération : Rendez la classe sérialisable ou utilisez foreachPartition avec un objet de connexion créé par partition.
Épuisement des ressources : Symptôme : l'application est bloquée à l'état WAITING. Vérifiez la disponibilité de la mémoire et des cœurs sur l'interface Web.
Récupération : Libérez des ressources, tuez les applications inactives ou réduisez le nombre d'exécuteurs demandés.

Exemple de commande de diagnostic

Pour une situation de dépassement de mémoire, vous pouvez exécuter :

yarn logs -applicationId <id-application> | grep -i "OutOfMemory"

Si vous voyez Container killed, vérifiez les journaux du conteneur :

curl -s http://<gestionnaire-ressources>:8088/proxy/<id-application>/logs

Voies de récupération

Redémarrez l'application avec plus de mémoire :

spark-submit --executor-memory 8g --num-executors 5 ...

Redémarrez le maître/les workers Spark si le cluster est instable :

$SPARK_HOME/sbin/stop-all.sh
$SPARK_HOME/sbin/start-all.sh

Vérifiez les problèmes HDFS : utilisez hdfs dfsadmin -report pour voir la santé.

Liste de contrôle des opérations

Utilisez cette liste de contrôle lors des opérations Spark.

Liste de contrôle avant modification

[ ] Enregistrez la version actuelle et la topologie de déploiement.
[ ] Notez la configuration actuelle du composant que vous modifiez.
[ ] Comprenez l'impact potentiel : quelles tâches et quels utilisateurs pourraient être affectés ?
[ ] Sauvegardez tous les fichiers de configuration.

Exécution de la modification

[ ] Effectuez la plus petite modification possible.
[ ] Utilisez des espaces réservés pour les identifiants et les ressources.
[ ] Appliquez la modification uniquement à la ressource cible (par exemple, une tâche, pas tout le cluster).

Vérification après modification

[ ] Exécutez une tâche de test pour vérifier que la modification fonctionne.
[ ] Vérifiez l'interface Web Spark pour l'utilisation des ressources et le succès.
[ ] Comparez la sortie avec les résultats attendus.

Liste de contrôle de récupération

[ ] Sachez comment annuler la modification (restaurer la sauvegarde, ajuster les paramètres).
[ ] Documentez la procédure de récupération avant un incident.
[ ] Communiquez aux membres de l'équipe ce qu'il faut surveiller.

Conclusion

Maîtriser les commandes de base de Spark est essentiel pour des opérations fluides. En vérifiant systématiquement les versions, en inspectant l'environnement, en effectuant des changements de configuration sécurisés, en vérifiant la santé du cluster et en comprenant les modes de défaillance, vous pouvez gérer Spark en toute confiance. Commencez toujours par l'observation, validez chaque modification et gardez un plan de récupération prêt. Utilisez les commandes et exemples de ce guide comme point de départ pour votre propre manuel opérationnel.

Pour la prochaine étape, choisissez une tâche de vérification à faible risque — comme vérifier la version ou exécuter une tâche Pi — et entraînez-vous. Enregistrez l'état actuel, exécutez la commande et comparez le résultat avec la sortie attendue. Cette pratique concrète construit la mémoire musculaire nécessaire pour des opérations Spark efficaces.

Rappelez-vous qu'un flux de travail fiable rend les défaillances visibles, protège les données sensibles, limite les modifications à la cible prévue et définit la récupération avant qu'un incident ne se produise.