Horaire

Aperçu

L’horaire Ilum vous permet de configurer et de gérer sans effort les horaires pour des tâches individuelles grâce à une interface intuitive et conviviale. Il simplifie le processus de configuration des calendriers d’exécution en toute simplicité.

Cette fonctionnalité exploite les CronJobs Kubernetes, qui utilisent des expressions CRON pour définir précisément quand les tâches doivent s’exécuter. À l’heure prévue, le CronJob déclenche une requête au backend d’Ilum, qui orchestre la création d’une seule tâche.

Cas d’utilisation

Ingestion de données

Récupérez régulièrement des données à partir d’API externes ou d’autres sources et chargez-les dans une base de données ou un système de fichiers pour un traitement ou une analyse ultérieurs.

Orchestration du pipeline de données (ETL)

Automatisez les tâches ETL (Extract, Transform, Load) basées sur Spark qui extraient des données brutes de plusieurs sources, appliquent des transformations complexes et chargent le résultats dans un entrepôt de données

Préparation de rapports et agrégation de données pour l’analyse

Planifiez une tâche Spark pour agréger des jeux de données volumineux provenant de diverses sources (par exemple, des journaux, des données de vente, des interactions avec les utilisateurs) dans des tables récapitulatives qui sont utilisées dans tableaux de bord et rapports.

Nettoyage des données

Planifiez un travail Spark qui effectue le nettoyage des données, par exemple en supprimant les doublons, en corrigeant les entrées non valides ou en filtrant les données, dans un grand ensemble de données stocké dans un système distribué

Démarrer

Tâche Python planifiée

L’exemple ci-dessous est une tâche Spark simple en Python qui génère des données aléatoires et les écrit dans un compartiment S3. L’exécution de ce travail est planifiée à un intervalle de temps spécifié.

1. Rédiger une seule tâche

   De Pyspark.SQL importation SparkSession
   De Pyspark.SQL importation Trame de données
   De Pyspark.SQL importation Ramer
   importation aléatoire
   De DateHeure importation DateHeure
   
   
   Def generate_sample_data(n):
       rendre [Ramer(id=Je, nom=f"Name_{Je}", valeur=aléatoire.randrange(70, 100)) pour Je dans gamme(n)]
   
   
   si __nom__ == « __main__ »:
       étincelle = SparkSession.constructeur\
       .nomappli(« Mon travail d’étincelle ») \
       .getOrCreate()
   
       données = generate_sample_data(100)
       Df = étincelle.createDataFrame(données)
   
       current_datetime = DateHeure.Maintenant()
       current_timestamp = current_datetime.strftime(« %Y- %m- %d %H :%M :%S »)
   
       output_path = f"s3a ://ilum-files/generated_data/{current_timestamp}"
       Df.écrire.mode(« écraser »).parquet(output_path)
   
       étincelle.arrêter()

   Enregistrez le fichier sous .py

2. Créer un calendrier

   Lors de la création de votre planification, spécifiez les éléments suivants :

   • Onglet Général :
     • Nom: Nom de l’horaire
     • Grappe: Le cluster sur lequel le job va s’exécuter
     • Langue: Python dans ce cas
     • Classe: sans le .Py extension
   • Onglet de chronométrage :
     • Choisissez une valeur qui correspond à vos besoins. Une expression CRON personnalisée peut être utilisée si les options prédéfinies ne répondent pas à vos besoins.

       

   • Onglet Ressources :
     • PyFiles: Télécharger le script Python

3. Observer les journaux des tâches qui apparaissent

   Une fois que vous avez créé la planification, elle est déjà active et lancera des tâches en fonction des paramètres que vous avez spécifiés.

   Les tâches uniques lancées par le planning se comportent de la même manière que les tâches uniques Ilum normales : Par exemple, vous pouvez vous rendre sur le Emplois pour voir la liste des tâches qui ont été lancées par les planifications.

   

Tâche Scala planifiée

Cet exemple est le même que celui de Python, mais écrit en Scala.

1. Créer un projet sbt

   Lors de la création du projet, il est important d’inclure le spark-sql dépendance dans le build.sbt lime.

   libraryDependencies += « org.apache.spark » %% « spark-sql » % « 3.5.3 » % « fourni »

   Gardez à l’esprit que la version de la dépendance doit correspondre à la version de Spark exécutée sur le cluster.

2. Écrire et compiler une seule tâche

   importation org.apache.étincelle.SQL.types.{IntegerType, StringType, StructField, StructType}
   importation org.apache.étincelle.SQL.{Ramer, SparkSession}
   
   importation java.time.LocalDateTime
   importation java.time.format.DateTimeFormatter
   importation scala.util.Random
   
   objet Principal {
     private Def generateSampleData(n: Int): Seq[Ramer] = {
       (0 until n).carte(Je => Ramer(Je, s"Name_$Je", Random.nextInt(30) + 70))
     }
   
     Def principal(args: Array[String]): Unit = {
       val étincelle = SparkSession.builder()
         .nomappli(« Mon travail d’étincelle »)
         .getOrCreate()
   
       val données = generateSampleData(100)
       val Df = étincelle.createDataFrame(
         étincelle.sparkContext.paralléliser(données),
         StructType(
           List(
             StructField(« Pièce d’identité », IntegerType, nullable = faux),
             StructField(« nom », StringType, nullable = faux),
             StructField("value", IntegerType, nullable = faux)
           )
         )
       )
   
       val currentDateTime = LocalDateTime.Maintenant()
       val currentTimestamp = currentDateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))
   
       val outputPath = s"s3a://ilum-files/generated_data/$currentTimestamp"
       Df.écrire.mode(« écraser »).parquet(outputPath)
   
       étincelle.arrêter()
     }
   }

   Le projet peut maintenant être compilé dans un fichier JAR. Alors que normalement vous voudriez un 'fat JAR' avec toutes les dépendances incluses, Ce travail est suffisamment simple pour être exécuté avec les dépendances fournies par le cluster.

   Pour empaqueter rapidement le projet, exécutez la commande Forfait SBT commander.

3. Créer un calendrier

   Lors de la création de votre planification, spécifiez les éléments suivants :

   • Onglet Général :
     • Nom: Nom de l’horaire
     • Grappe: Le cluster sur lequel le job va s’exécuter
     • Langue: Scala dans ce cas
     • Classe: Nom de la classe canonique. Dans notre cas, sbt doit mettre le fichier de classe à la racine du JAR, donc Principal devrait suffire.
   • Onglet de chronométrage :
     • Choisissez une valeur qui correspond à vos besoins. Une expression CRON personnalisée peut être utilisée si les options prédéfinies ne répondent pas à vos besoins.

       

   • Onglet Ressources :
     • Pots: Télécharger le fichier JAR

4. Observer les journaux des tâches qui apparaissent

   Une fois que vous avez créé la planification, elle est déjà active et lancera des tâches en fonction des paramètres que vous avez spécifiés.

   Les tâches uniques lancées par le planning se comportent de la même manière que les tâches uniques Ilum normales : Par exemple, vous pouvez vous rendre sur le Emplois pour afficher la liste des tâches qui ont été lancées par la planification.

   

Chargement d’un exemple de planification

Ilum fournit un exemple de planification pour aider les nouveaux utilisateurs à démarrer rapidement. Exemple de chargement programmé est activé par défaut. Cependant, vous pouvez le désactiver en utilisant --set ilum-core.examples.schedule=false.

Conseils

Exploitez toute la puissance des expressions CRON

Bien qu’Ilum soit livré avec des options prédéfinies pour la planification, vous pouvez également utiliser des expressions CRON personnalisées pour configurer des planifications plus complexes.

L’expression Cron se compose de 5 champs :
    

* - chaque unité de temps
? - n’importe quelle unité de temps ( ? dans le champ jour de la semaine donne l’ignoiring le jour de la semaine)
- - gamme (1-5)
, - valeurs : (1,5)
/ - incréments (5/15 dans le champ des minutes = 5, 20, 35, 50)

Exemples:

Chaque heure :
0 * * * *

Chaque dimanche à 3 h :
0 3 * * 0

Toutes les 15 minutes tous les jours :
0/15 0 * * ?

Toutes les cinq minutes, à partir de 13 h et jusqu’à 13 h 55, puis à partir de 18 h et jusqu’à 18 h 55, tous les jours :
0/5 13,18 * * ?

Si vous souhaitez en savoir plus, consultez la Documentation de la tâche Cron de Kubernetes.

Testez votre travail avant de le planifier

Les tâches planifiées sont lancées périodiquement, il est donc essentiel de s’assurer que la tâche fonctionne correctement. Étant donné que les tâches planifiées se comportent de la même manière que les tâches simples normales, Vous pouvez tester l’exécution en lançant une seule tâche avant de créer une planification.

Schedule lance Ilum pour les tâches uniques

Les tâches planifiées sont lancées en tant que tâches uniques Ilum. Cela signifie que toutes vos configurations, journaux, sorties et autres fonctionnalités disponibles pour les travaux uniques sont également disponibles pour les travaux planifiés.

Désactivez les horaires lorsque vous n’en avez pas besoin

Si vous n’avez pas besoin que la tâche soit lancée périodiquement, vous devez désactiver les planifications pour éviter le gaspillage de ressources. Pour ce faire, vous pouvez cliquer sur le bouton Pause dans le Horaires onglet.

Modifiez vos emplois du temps au lieu d’en créer un nouveau

Si vous souhaitez modifier les configurations d’un calendrier existant, cliquez sur Éditer dessus.