Comment utiliser les carnets de notes dans Ilum

This page demonstrates identical example notebooks implemented in both Jupyter (compatible with JupyterLab et JupyterHub ) and Zeppelin , allowing you to quickly compare how typical workflows map between these environments.

Each notebook is organized into four logical sections:

1. Narrative (Markdown) – Rich text with images introducing the task.
2. Generate Test Data – Python (or Scala) code creating a small synthetic dataset.
3. Transform Data – Spark code that cleans or aggregates the data.
4. Graphique dynamique – An interactive visualization, refreshable after each run.

Guide for Jupyter Notebooks (Lab & Hub)​

Aperçu ​

In Ilum, Jupyter notebooks are accessible via both JupyterLab et JupyterHub . For end users, the experience is functionally identical in both, especially when working with Spark and Ilum integrations.

By default, Python code cells execute locally on the Jupyter server. To leverage Spark on a remote cluster, you need to use Spark Magic—a Jupyter extension that enables code execution on a Spark cluster through the Livy API. In Ilum, the default Livy API is replaced with Ilum Livy Proxy , which ensures seamless integration with Ilum’s storage, metastore, lineage, and monitoring features.

Jupyter (both Lab and Hub) provides four primary kernels:

Python Kernel: The default Jupyter kernel, which runs Python code on the Jupyter server. PySpark Kernel: A Spark kernel that runs your Python code on a remote Spark cluster. Spark Kernel: A Scala kernel that runs your Scala code on a remote Spark cluster.

1. Noyau Python – The default Jupyter kernel, which runs Python code on the Jupyter server.
2. PySpark Kernel – A Spark kernel that runs your Python code on a remote Spark cluster.
3. Spark Kernel – A Scala kernel that runs your Scala code on a remote Spark cluster.

Spark Session Management​

To use a remote Spark cluster from a standard Python kernel, first load Spark Magic:

% load_ext sparkmagic. magics

Next, open the Spark session management panel:

% manage_spark

Using this panel, you can perform the following tasks:​

Gérer les sessions ​

Le Gérer les sessions tab displays all available Spark sessions. Here you can see the session's name, ID, kernel type (e.g., pyspark for Python), and its current state. You can also delete sessions you no longer need.

Create Session​

Le Create Session tab allows you to launch a new Spark session. To create a session, provide a name for your session, select a language (Scala or Python), and specify Spark parameters. Finally, click Create Session.
[Full details on session creation and available parameters can be found ici .]

Add Endpoint​

Dans le Add Endpoint tab, you can register additional Livy endpoints. Choose the authentication type (e.g., Kerberos) and provide the Livy server address, then click Add endpoint. This is useful if you need to connect to a custom Livy deployment instead of the preconfigured Ilum-Livy-Proxy endpoint.

Gérer les points de terminaison ​

Le Gérer les points de terminaison tab lists all configured Livy endpoints, along with all active or historical Spark sessions associated with them. You can view session details, including session IDs, Spark UI links, and driver logs. You can also remove endpoints or clean up old sessions directly from this panel.

Ilum Workloads Page​

After creating a session, you can track your active code services on the Ilum Workloads page. Services created via Spark Magic sessions are named with the prefix ilum-livy-proxy-session and can be monitored, paused, or deleted just like any other Ilum service.

Creating a Spark Session​

To create a new Spark session, open the management panel and select Create Session.
You will be asked to fill in a form with the following parameters:

Basic Settings:

• Endpoint
  The Livy endpoint address used to connect to the Spark cluster. This field is configured automatically, but if needed, you can add an endpoint to your own Livy service.

• Grappe
  The name of the Kubernetes cluster where the session will run.

• Session Name
  A custom name for your Spark session, used for identification.

• Langue
  The programming language for the Spark session: pythonou scala.

• Spark Image
  The Docker image that defines the Spark runtime environment (e.g., ilum/spark:3.5.6-delta).
  You can also use your own custom images, but for full compatibility we recommend building them on top of the official Spark base images published by ILUM on Docker Hub.

• Extra Packages
  Additional Python packages to install in the session.
  Exemple: numpy;pandas

• Enable autopause
  Automatically pauses the session when it is idle. After the configured idle time, the session remains available, but the first request will start the pod(s) and executors before executing your code, resulting in a slightly longer waiting time for the first command.
  The autopause settings are managed globally via Helm values:

  • --set ilum-core.job.autoPause.idleTime=3600 controls the idle time (in seconds) after which the group is paused,
  • --set ilum-core.job.autoPause.period=180 controls how often (in seconds) the idle state is checked.

Executor Settings:

• Executor Memory
  Amount of RAM allocated to each Spark executor (e.g., 2G).
  Supported units: M (megabytes), G (gigabytes), T (terabytes).

• Executor Cores
  Number of CPU cores for each executor.

• Number of Executors
  Total number of executors to start in the session.

Driver Settings:

• Driver Memory
  Amount of RAM allocated to the Spark driver process (e.g., 1G).
  Supported units: M (megabytes), G (gigabytes), T (terabytes).

• Driver Cores
  Number of CPU cores for the Spark driver.

More Advanced Options:

• Custom Spark Config
  Additional Spark configuration as a JSON object.
  This field is equivalent to the properties field in the old Sparkmagic version.
  Important: Any parameter provided in this field will override the corresponding Spark property from the other fields, so use it with caution.
  Exemple: { "spark.sql.shuffle.partitions": "200" }

• SQL Extension
  The Spark SQL extension class name, often required for Delta Lake, Hudi, Nessie etc.
  Exemple: io.delta.sql.DeltaSparkSessionExtension

• Driver Extra Java Options
  Extra Java options passed to the Spark driver process.
  Exemple: -Divy.cache.dir=/tmp -Divy.home=/tmp

• Executor Extra Java Options
  Extra Java options passed to Spark executors.
  Exemple: -Dconfig=value

• Dynamic Allocation
  Enables Spark dynamic resource allocation for executors.
  Note: All options below are only applied if dynamic allocation is enabled.

  • Min Executors
    Minimum number of executors.

  • Initial Executors
    Initial number of executors to launch at session start.

  • Max Executors
    Maximum number of executors allowed during dynamic allocation.

  • Shuffle Partitions
    Number of partitions used for shuffle operations in Spark SQL.

Sessions are isolated per notebook, which means that each open notebook has its own independent computational environment. When running a Spark cell in the Python kernel and having multiple sessions active, you must specify which Spark session to use.

Using Ilum Code Services instead of local pyspark kernel offers several advantages. Ilum automatically preconfigures all Jupyter sessions to integrate seamlessly with your infrastructure modules. For example, sessions are preconfigured to access all storage linked to the default cluster. If the corresponding components are enabled, Spark sessions will:

• Accédez au Metastore Hive.
• Envoyez des données à Ilum Lineage.
• Envoyez les données au serveur d’historique pour surveillance.
• Tirez parti des fonctionnalités supplémentaires fournies par Ilum.

Et vous n’aurez pas besoin d’écrire des configurations pour cela manuellement.

Working with Jupyter​

Après la configuration, pour exécuter votre code dans le service Ilum Code, vous devez utiliser la commande %%étincelle commande magique. Cette commande magique vous permet d’exécuter votre code dans l’environnement Spark distant géré par Ilum.

% % étincelle 

# Example data
# ... 

Dans cet environnement, vous pouvez accéder à toutes les variables qui y sont créées, ainsi qu’aux contextes Spark suivants :

• sc (SparkContext)
• sqlContext (HiveContext)
• étincelle (SparkSession)

Cette configuration garantit une interaction transparente avec les ressources Spark et toutes les configurations fournies par la plateforme Ilum.

Exemple Python :

% % étincelle 

données =  [ 
    ( 1 ,  « N1-STANDARD-1 » ,  20.5 ,  32.1 ,  15.0 ) , 
    ( 2 ,  « N1-STANDARD-1 » ,  30.0 ,  64.3 ,  20.0 ) , 
    ( 3 ,  « N1-Standard-2 » ,  30.2 ,  16.0 ,  22.0 ) , 
    ( 4 ,  « N1-Standard-2 » ,  45.1 ,  128.5 ,  40.2 ) , 
    ( 5 ,  « E2-Moyen » ,  25.4 ,  8.0 ,  18.3 ) , 
    ( 6 ,  « E2-Moyen » ,  25.3 ,  12.0 ,  10.2 ) , 
    ( 7 ,  « E2-Standard-2 » ,  29.8 ,  24.5 ,  14.7 ) , 
    ( 8 ,  « E2-Standard-2 » ,  35.0 ,  24.5 ,  20.5 ) , 
    ( 9 ,  « n2-highcpu-4 » ,  50.2 ,  64.0 ,  30.4 ) , 
    ( 10 ,  « n2-highcpu-4 » ,  55.1 ,  16.0 ,  35.4 ) , 
    ( 11 ,  « N1-Standard-8 » ,  80.5 ,  32.0 ,  45.6 ) , 
    ( 12 ,  « N1-NORME-16 » ,  95.1 ,  128.0 ,  60.0 ) , 
    ( 13 ,  « N1-Standard-8 » ,  85.0 ,  256.0 ,  90.0 ) , 
    ( 14 ,  « n1-highmem-2 » ,  40.1 ,  128.0 ,  50.0 ) , 
    ( 15 ,  « T2A-Standard-1 » ,  15.2 ,  2.0 ,  5.5 ) , 
    ( 16 ,  « T2A-Standard-2 » ,  25.5 ,  4.0 ,  7.3 ) , 
    ( 17 ,  « n1-highmem-2 » ,  60.5 ,  256.0 ,  100.0 ) , 
    ( 18 ,  « C2-Standard-16 » ,  99.9 ,  6240.0 ,  120.5 ) , 
    ( 19 ,  « A2-HighGPU-1G » ,  89.2 ,  256.0 ,  95.4 ) , 
    ( 20 ,  « A2-HighGPU-1G » ,  100.0 ,  40.0 ,  110.0 ) , 
] 

#using contexte de l’étincelle 
rdd = Sc . paralléliser ( données ) 

chemin d’accès aux données =  « s3a ://ilum-files/data/performance » 
rdd . saveAsTextFile ( chemin d’accès aux données ) 


#using session Spark 
Df = étincelle . lire . Le CSV ( chemin d’accès aux données ) 
Df . createOrReplaceTempView ( « MachinesTemp » ) 
résultat = étincelle . SQL ( "Sélectionnez \ 
_c0 comme machine_id , \ 
_c1 comme machine_type , \ 
_c2 comme cpu_usage , \ 
_c3 comme memory_usage , \ 
_c4 comme time_spent \ 
De MachinesTemp" ) 

résultat . createOrReplaceTempView ( « Statistiques Machine » ) 

résultat . montrer ( ) 

Exemple Scala :

% % étincelle 
valdonnées =  Seq( 
  ( 1 ,  « N1-STANDARD-1 » ,  20.5 ,  32.1 ,  15.0 ) , 
  ( 2 ,  « N1-STANDARD-1 » ,  30.0 ,  64.3 ,  20.0 ) , 
  ( 3 ,  « N1-Standard-2 » ,  30.2 ,  16.0 ,  22.0 ) , 
  ( 4 ,  « N1-Standard-2 » ,  45.1 ,  128.5 ,  40.2 ) , 
  ( 5 ,  « E2-Moyen » ,  25.4 ,  8.0 ,  18.3 ) , 
  ( 6 ,  « E2-Moyen » ,  25.3 ,  12.0 ,  10.2 ) , 
  ( 7 ,  « E2-Standard-2 » ,  29.8 ,  24.5 ,  14.7 ) , 
  ( 8 ,  « E2-Standard-2 » ,  35.0 ,  24.5 ,  20.5 ) , 
  ( 9 ,  « n2-highcpu-4 » ,  50.2 ,  64.0 ,  30.4 ) , 
  ( 10 ,  « n2-highcpu-4 » ,  55.1 ,  16.0 ,  35.4 ) , 
  ( 11 ,  « N1-Standard-8 » ,  80.5 ,  32.0 ,  45.6 ) , 
  ( 12 ,  « N1-NORME-16 » ,  95.1 ,  128.0 ,  60.0 ) , 
  ( 13 ,  « N1-Standard-8 » ,  85.0 ,  256.0 ,  90.0 ) , 
  ( 14 ,  « n1-highmem-2 » ,  40.1 ,  128.0 ,  50.0 ) , 
  ( 15 ,  « T2A-Standard-1 » ,  15.2 ,  2.0 ,  5.5 ) , 
  ( 16 ,  « T2A-Standard-2 » ,  25.5 ,  4.0 ,  7.3 ) , 
  ( 17 ,  « n1-highmem-2 » ,  60.5 ,  256.0 ,  100.0 ) , 
  ( 18 ,  « C2-Standard-16 » ,  99.9 ,  6240.0 ,  120.5 ) , 
  ( 19 ,  « A2-HighGPU-1G » ,  89.2 ,  256.0 ,  95.4 ) , 
  ( 20 ,  « A2-HighGPU-1G » ,  100.0 ,  40.0 ,  110.0 ) 
) 

Utilisation du contexte Spark 
valrdd = étincelle . sparkContext . paralléliser ( données ) 

valchemin d’accès aux données =  « s3a ://ilum-files/data/performance » 
rdd . saveAsTextFile ( chemin d’accès aux données ) 

Utilisation de Spark Session 
valDf = étincelle . lire . option ( "header",  « faux » ) . Le CSV ( chemin d’accès aux données ) 

Df . createOrReplaceTempView ( « MachinesTemp » ) 

valrésultat = étincelle . SQL ( """
CHOISIR 
_c0 COMME machine_id, 
_c1 COMME machine_type, 
_c2 COMME cpu_usage, 
_c3 COMME memory_usage, 
_c4 COMME time_spent 
DEPUIS MachinesTemp 
""") 


résultat . createOrReplaceTempView ( « Statistiques Machine » ) 

résultat . montrer ( ) 

Vous pouvez interrupteur entre Sessions dans vos cellules à l’aide de -s et le nom de la session que vous souhaitez choisir.

% % étincelle - s SESSION_NAME 

#your code Spark Python 
# ... 

Par exemple, si vous avez cette liste de sessions :

Où mysession est de type Spark qui utilise le langage Scala. Cela signifie que si vous souhaitez utiliser cette session scala spark Vous devez choisir la séance comme ceci :

% % étincelle - s scalasession

pythonsessions est de type pyspark qui utilise le langage python. Cela signifie que si vous souhaitez utiliser la session python Spark Vous devez choisir la séance comme ceci

% % étincelle - s pythonsession 

Vous pouvez lancer Requêtes SQL dans votre catalogue Spark en utilisant %%étincelle magie avec -c sql :

% % étincelle - c SQL 
CHOISIR  *  DE MachinesStats 

Vous pouvez utiliser plusieurs indicateurs avec la commande SQL dans le Ilum Code Service environnement:

• -o : Spécifie la variable d’environnement locale qui stockera le résultat de la requête. Il s’agit de la meilleure solution pour passer des données entre les sessions.
• -n ou --maxrows : définit le nombre maximum de lignes à renvoyer à partir de la requête.
• -q ou --quiet : détermine s’il faut afficher la sortie dans le document. Si spécifié, le résultat ne sera pas affiché.
• -f ou --samplefraction : Définit la fraction du résultat à renvoyer lors de l’échantillonnage.
• -m ou --samplemethod : spécifie la méthode d’échantillonnage à utiliser, soit prélever ou échantillonner.

Ces indicateurs offrent une flexibilité dans la gestion des résultats des requêtes et le contrôle du comportement de sortie lors de l’utilisation de Spark dans l’environnement Ilum.

Par exemple:

% % étincelle - s pythonsession - c SQL  - o test_result - q --maxrows 10 
CHOISIR machine_type ,  Avg ( memory_usage )  comme avg_memory_usage De MachinesStats Groupe  par machine_type 

test_result 

Le résultat devrait ressembler à ceci :

Affichage des données ​

Les sessions PySpark et Spark rencontrent souvent des problèmes de compatibilité avec les packages de visualisation avancés. Une solution pratique consiste à transférer les données vers un noyau IPython local pour le traitement et la visualisation. Voici comment y parvenir :

1. Exporter les données vers le noyau local : utilisez la variable -o dans votre bloc-notes ou votre code pour transmettre les données de Spark au noyau IPython local.

% % étincelle - c SQL  - o machine_stats 
CHOISIR  *  DE MachinesStats 

2. Installez les packages de visualisation requis : installez toutes les bibliothèques de visualisation Python nécessaires à l’aide de la commande :

Paquet d’installation !pip 

Par exemple, affichons les données à l’aide de AutoVizWidget Widget :

De autovizwidget . widget . utilitaires importation display_dataframe 
display_dataframe ( machine_stats ) 

Il permet d’afficher les données sous la forme de l’un des graphiques ci-dessous :

• Bars
• Tarte
• Disperser
• Aire
• Table
• Ligne

4. Séances de nettoyage Vous pouvez nettoyer vos sessions Spark de deux manières :

• Via le panneau de gestion des sessions Spark : rendez-vous dans le Gérer les sessions , puis cliquez sur Supprimer à côté de la session que vous souhaitez supprimer.

• Via le panneau de gestion des sessions Spark Gérer les points de terminaison Section : accédez à la section Gérer les points de terminaison, puis cliquez sur l’icône Nettoyer en regard du point de terminaison du proxy Ilum Livy.

Ces options vous permettent de supprimer les sessions inutiles ou inactives de votre environnement.

Noyaux Spark et PySpark ​

Les noyaux Spark et PySpark exécutent votre code directement dans la session Spark. Dans Ilum, lorsque vous créez un nouveau document PySpark ou Spark, un document Python ou Spark correspondant Scala Code Service est également créé et affecté au document. Votre code s’exécutera au sein de ces services, Cela signifie que la session Spark est préconfigurée et entièrement intégrée à tous les composants du système.

Par exemple, si les modules suivants sont activés, votre session Spark :

• Avoir accès à la Ruche Metastore
• Avoir accès à la Stockages lié au cluster par défaut.
• Envoyez des données sur l’utilisation de la mémoire, l’utilisation du processeur et le schéma des étapes au schéma Serveur d’historique .
• Transférer les journaux vers Loki Utilisant Queue de promtail .
• Exposer ses métriques à Prométhée .

La principale différence entre les noyaux PySpark et Spark réside dans le langage de programmation :

• Noyau PySpark : Utilisations Python .
• Noyau Spark : Utilisations Scala .

Les commandes magiques que vous pouvez utiliser et le flux de travail global restent largement similaires entre les deux noyaux.

1. Création de session

Pour créer un document PySpark ou Spark, allez dans Jupyter, cliquez sur l’icône + dans le coin supérieur gauche et choisissez le noyau

Ensuite, créez une cellule, tapez-y quelque chose de simple et exécutez-la.

Par exemple:

imprimer ( « Bonjour » ) 

Après un certain temps, vous devriez voir le résultat suivant :

Si vous accédez à l’icône Charges , vous verrez un nouveau service de code créé dans le cluster par défaut. Ce service de code aura un nom préfixé par ilum-livy-proxy-session , indiquant qu’il est associé à la session Spark ou PySpark que vous venez de créer.

Notez que le code de la cellule a été exécuté en tant que demande à ce service de code.

2. Gestion de session

Les noyaux Spark et PySpark n’ont pas de panneau de gestion similaire à celui de sparkmagics. Cependant, vous pouvez utiliser des commandes magiques pour la même fonctionnalité.

Utiliser %%configure magique pour définir les paramètres d’étincelle de votre session à l’aide du format JSON

Par exemple, en tapant ce code dans votre cellule :

%%configure -f 
{ 
  « spark.sql.extensions » : « io.delta.sql.DeltaSparkSessionExtension » , 
  « spark.sql.catalog.catalog_spark_catalog » :  « org.apache.spark.sql.delta.catalog.DeltaCatalog » , 
  « spark.databricks.delta.catalog.update.enabled » :  vrai 
} 

activera Delta dans votre session Spark

Il est obligatoire d’utiliser -f car il force Ilum à redémarrer la session au cas où elle serait déjà en cours d’exécution

Utiliser %%info magique pour obtenir des informations sur les sessions actives d’étincelle dans Tite-Live.

Utiliser %%delete -f -s ID pour supprimer des sessions par leur ID. Vous ne pouvez pas supprimer la session du noyau actuel

Par exemple:

%%delete -f -s 16 

Utiliser %%nettoyage -f pour supprimer toute la session dans le point de terminaison actuel (dans le proxy Ilum Livy)

Utiliser %%journaux pour obtenir les journaux liés à la session Spark. Vous pouvez les utiliser pour le débogage.

3. Flux de travail

If you want to write a Spark program, you don’t need to use any magics. Simply type your code into a cell and execute it.

Pour dans le noyau PySpark (python) :

données =  [ 
    ( 1 ,  « N1-STANDARD-1 » ,  20.5 ,  32.1 ,  15.0 ) , 
    ( 2 ,  « N1-STANDARD-1 » ,  30.0 ,  64.3 ,  20.0 ) , 
    ( 3 ,  « N1-Standard-2 » ,  30.2 ,  16.0 ,  22.0 ) , 
    ( 4 ,  « N1-Standard-2 » ,  45.1 ,  128.5 ,  40.2 ) ,   
    ( 5 ,  « E2-Moyen » ,  25.4 ,  8.0 ,  18.3 ) , 
    ( 6 ,  « E2-Moyen » ,  25.3 ,  12.0 ,  10.2 ) ,   
    ( 7 ,  « E2-Standard-2 » ,  29.8 ,  24.5 ,  14.7 ) , 
    ( 8 ,  « E2-Standard-2 » ,  35.0 ,  24.5 ,  20.5 ) , 
    ( 9 ,  « n2-highcpu-4 » ,  50.2 ,  64.0 ,  30.4 ) , 
    ( 10 ,  « n2-highcpu-4 » ,  55.1 ,  16.0 ,  35.4 ) ,  
    ( 11 ,  « N1-Standard-8 » ,  80.5 ,  32.0 ,  45.6 ) , 
    ( 12 ,  « N1-NORME-16 » ,  95.1 ,  128.0 ,  60.0 ) , 
    ( 13 ,  « N1-Standard-8 » ,  85.0 ,  256.0 ,  90.0 ) ,  
    ( 14 ,  « n1-highmem-2 » ,  40.1 ,  128.0 ,  50.0 ) , 
    ( 15 ,  « T2A-Standard-1 » ,  15.2 ,  2.0 ,  5.5 ) , 
    ( 16 ,  « T2A-Standard-2 » ,  25.5 ,  4.0 ,  7.3 ) , 
    ( 17 ,  « n1-highmem-2 » ,  60.5 ,  256.0 ,  100.0 ) ,  
    ( 18 ,  « C2-Standard-16 » ,  99.9 ,  6240.0 ,  120.5 ) , 
    ( 19 ,  « A2-HighGPU-1G » ,  89.2 ,  256.0 ,  95.4 ) , 
    ( 20 ,  « A2-HighGPU-1G » ,  100.0 ,  40.0 ,  110.0 ) ,  
] 

#using contexte de l’étincelle 
rdd = Sc . paralléliser ( données ) 

chemin d’accès aux données =  « s3a ://ilum-files/data/performance » 
rdd . saveAsTextFile ( chemin d’accès aux données ) 


#using session Spark 
Df = étincelle . lire . Le CSV ( chemin d’accès aux données ) 
Df . createOrReplaceTempView ( « MachinesTemp » ) 
résultat = étincelle . SQL ( "Sélectionnez \ 
_c0 comme machine_id , \ 
_c1 comme machine_type , \ 
_c2 comme cpu_usage , \ 
_c3 comme memory_usage , \ 
_c4 comme time_spent \ 
De MachinesTemp" ) 

résultat . createOrReplaceTempView ( « Statistiques Machine » ) 

résultat . montrer ( ) 

Dans le noyau Spark (Scala) :

valdonnées =  Seq( 
  ( 1 ,  « N1-STANDARD-1 » ,  20.5 ,  32.1 ,  15.0 ) , 
  ( 2 ,  « N1-STANDARD-1 » ,  30.0 ,  64.3 ,  20.0 ) , 
  ( 3 ,  « N1-Standard-2 » ,  30.2 ,  16.0 ,  22.0 ) , 
  ( 4 ,  « N1-Standard-2 » ,  45.1 ,  128.5 ,  40.2 ) ,   
  ( 5 ,  « E2-Moyen » ,  25.4 ,  8.0 ,  18.3 ) , 
  ( 6 ,  « E2-Moyen » ,  25.3 ,  12.0 ,  10.2 ) ,   
  ( 7 ,  « E2-Standard-2 » ,  29.8 ,  24.5 ,  14.7 ) , 
  ( 8 ,  « E2-Standard-2 » ,  35.0 ,  24.5 ,  20.5 ) , 
  ( 9 ,  « n2-highcpu-4 » ,  50.2 ,  64.0 ,  30.4 ) , 
  ( 10 ,  « n2-highcpu-4 » ,  55.1 ,  16.0 ,  35.4 ) ,  
  ( 11 ,  « N1-Standard-8 » ,  80.5 ,  32.0 ,  45.6 ) , 
  ( 12 ,  « N1-NORME-16 » ,  95.1 ,  128.0 ,  60.0 ) , 
  ( 13 ,  « N1-Standard-8 » ,  85.0 ,  256.0 ,  90.0 ) ,  
  ( 14 ,  « n1-highmem-2 » ,  40.1 ,  128.0 ,  50.0 ) , 
  ( 15 ,  « T2A-Standard-1 » ,  15.2 ,  2.0 ,  5.5 ) , 
  ( 16 ,  « T2A-Standard-2 » ,  25.5 ,  4.0 ,  7.3 ) , 
  ( 17 ,  « n1-highmem-2 » ,  60.5 ,  256.0 ,  100.0 ) ,  
  ( 18 ,  « C2-Standard-16 » ,  99.9 ,  6240.0 ,  120.5 ) , 
  ( 19 ,  « A2-HighGPU-1G » ,  89.2 ,  256.0 ,  95.4 ) , 
  ( 20 ,  « A2-HighGPU-1G » ,  100.0 ,  40.0 ,  110.0 ) 
) 

valrdd = étincelle . sparkContext . paralléliser ( données ) 

valchemin d’accès aux données =  « s3a ://ilum-files/data/performance » 
rdd . saveAsTextFile ( chemin d’accès aux données ) 

valDf = étincelle . lire . option ( "header",  « faux » ) . Le CSV ( chemin d’accès aux données ) 

Df . createOrReplaceTempView ( « MachinesTemp » ) 

valrésultat = étincelle . SQL ( """
CHOISIR 
_c0 COMME machine_id, 
_c1 COMME machine_type, 
_c2 COMME cpu_usage, 
_c3 COMME memory_usage, 
_c4 COMME time_spent 
DEPUIS MachinesTemp 
""") 


résultat . createOrReplaceTempView ( « Statistiques Machine » ) 

résultat . montrer ( ) 

Utilisation Spark SQL , vous pouvez utiliser l’icône %%sql magic, qui fonctionne de la même manière que dans le noyau Python avec Spark magic.

Par exemple :

% % SQL 
CHOISIR  *  DE MachinesStats 

Vous pouvez également utiliser plusieurs drapeaux avec %%sql pour personnaliser son comportement :

• -o : Spécifie la variable d’environnement locale qui stockera le résultat de la requête.
• -n ou --maxrows : Définit le nombre maximal de lignes à renvoyer à partir de la requête.
• -q ou --tranquille : Contrôle si la sortie est affichée dans le document. Si spécifié, le résultat ne sera pas affiché.
• -f ou --samplefraction : Définit la fraction du jeu de résultats à renvoyer lors de l’échantillonnage.
• -m ou --samplemethod : Specifies the sampling method to use—either take or sample.

Par exemple:

% % SQL  - o test_result - q --maxrows 10 
CHOISIR machine_type ,  Avg ( memory_usage )  comme avg_memory_usage De MachinesStats Groupe  par machine_type 

Vous ne verrez aucun résultat lors de l’exécution de cette cellule, mais ils seront enregistrés dans le test_result disponible localement et peut être récupéré à l’aide de %%local magie:

%%local 
test_result 

Le %%local magic command is used to execute code in a local environment. This can be useful when you don’t want to occupy the Spark environment for tasks that don’t require its resources.

Si vous souhaitez utiliser une valeur de l’environnement local dans la session Spark, vous devez utiliser %%send_to_spark magie.

%%send_to_spark -i valeur -n nom -t type 

Ici, vous spécifiez la valeur que vous souhaitez envoyer, son type de données et le nom de la variable à laquelle elle sera affectée dans la session Spark.

Par exemple:

% % local 
s =  u"abc ሴ def"

%%send_to_spark -i s -n s -t str 

imprimer ( s ) 

L’exécution de ces 3 cellules devrait afficher le s corde.

4. Affichage des données

Dans les dataframes du noyau Spark et PySpark, les dataframes récupérés avec des commandes SQL ou pandas peuvent être affichés comme suit :

• table
• tarte
• Bars
• Graphique linéaire
• disperser
• aire

Par exemple:

Pour les trames de données Spark, vous pouvez utiliser %%jolie magique pour les afficher dans un format plus agréable :

%%jolie 
résultat.show() 

Guide for Zeppelin​

Dans Zeppelin, vous ne pouvez pas contrôler les sessions Spark, elles sont créées et gérées automatiquement. Par défaut pour chaque notebook Il y a un %livy.spark , un pour %livy.pyspark et un pour %livy.sql . Dans les configurations d’interpréteur Vous pouvez changer cela.

Create notebook with Livy engine​

Comme mentionné précédemment, Ilum utilise Ilum-Livy-Proxy pour lier la session Spark de Zeppelin avec le service Ilum. Par conséquent, vous devez choisir Moteurs Tite-Live lorsqu’ils travaillent avec des étincelles.

Write spark code in scala​

Utiliser %livy.spark

Write spark code in pyspark​

Utiliser %livy.pyspark

Write spark sql statements​

Utiliser %livy.sql

Make use of built-in visualisztions​

Lorsque vous exécutez des instructions sql qui renvoient des lignes, vous pouvez les visualiser

Manage sessions lifecycle​

Malheureusement, zeppelin n’est pas flexible dans la gestion des sessions. Cependant, vous pouvez :

1. Terminez manuellement le service ilum en blocs :

étincelle . arrêter ( ) 

2. Définissez le délai d’expiration pour les sessions inactives dans les configurations d’interpréteur :

zeppelin.livy.idle.timeout=300