Production Deployment Guide

This comprehensive guide provides detailed instructions for deploying Ilum in production environments with enhanced security, namespace separation, and multiple configuration options to meet diverse operational requirements.

Table des matières ​

• Aperçu
• Conditions préalables à Kubernetes
• Architecture
• High Availability Configuration
• Failure Domains & Resilience
• Dynamic Resource Scaling
• Namespace Separation Strategy
• Security Configuration
• Dependency Deployment
• Pre-configured Stack Options
• Helm Values Configuration
• Installation Instructions
• Post-Installation Configuration
• Dépannage

Aperçu ​

For production environments, it's strongly recommended to deploy critical dependencies in separate namespaces to achieve:

• Enhanced Security: Namespace-level isolation and RBAC policies
• Resource Management: Independent resource quotas and limits
• Operational Excellence: Simplified maintenance and upgrades
• Compliance: Meeting organizational separation requirements
• Évolutivité : Independent scaling of components

Critical Components for Namespace Separation​

The following components should be deployed in separate namespaces for production:

• PostgreSQL : Primary metadata store for ilum-core and shared dependency for Marquez, Hive Metastore, Airflow, Superset, MLflow, and others
• MongoDB : Legacy metadata store, still supported for existing deployments
• Apache Kafka : Message broker and communication layer (required for ilum-core HA)
• MinIO : Object storage for Spark applications and data

Conditions préalables à Kubernetes ​

Ilum has been extensively tested across all leading Kubernetes environments, ensuring compatibility with a variety of deployment scenarios:

Supported Platforms​

• Lightweight Distributions: k3s, Rancher, MicroK8s
• Bare-metal Clusters: Self-managed Kubernetes installations
• Managed Services:
  • Moteur Google Kubernetes (GKE)
  • Amazon Elastic Kubernetes Service (EKS)
  • Azure Kubernetes Service (AKS)
  • DigitalOcean Kubernetes
  • Red Hat OpenShift

Minimum Suggested Requirements​

Air-gapped (Offline) Environments​

For air-gapped installations, refer to our comprehensive Air-gapped Installation Guide.

Testing vs Production​

Minikube is used throughout our documentation for demonstration purposes but is not suitable for production due to limitations in scalability, resource management, and high availability.

Architecture ​

Components and modules​

The Ilum platform consists of three core services and a curated set of optional modules:

• ilum-core : Main backend service. Hosts the public REST API, job and cluster orchestration, multi-engine SQL execution, security, and lineage capture.
• ilum-ui : React-based web frontend. Hosts the SQL Editor, Table Explorer, Lineage view, Workloads management, and the Modules registry.
• ilum-api: Module-management microservice. Drives Helm-based install, upgrade, and disable of optional Ilum modules at runtime via cluster-scoped RBAC. Future releases will extend ilum-apiavec Model Context Protocol (MCP) capabilities and open APIs for third-party extension.

Optional modules include execution engines (Trino, Apache Flink), additional catalogs (Project Nessie, Unity Catalog, DuckLake), notebooks (JupyterHub, Zeppelin), orchestration (Airflow, Kestra, Mage, n8n, NiFi), BI tools (Superset, Streamlit), AI and ML stacks (MLflow, LangFuse), and observability components (Kube Prometheus stack, Loki, Promtail).

PostgreSQL ​

PostgreSQL is the primary metadata storepour ilum-core (accessed via R2DBC with jOOQ-generated SQL DSL). It is also used by shared dependencies including Marquez, Hive Metastore, Airflow, Superset, MLflow, Hydra, Gitea, n8n, and Kestra to store their respective metadata.

PostgreSQL is Activé dans Ilum par défaut.

If you want to control whether PostgreSQL is enabled or not, you can use the helm value postgresql.enabled . For example, to disable it, you can add --set postgresql.enabled=false à votre commande d’installation.

MongoDB ​

MongoDB is supported as a legacy metadata storepour ilum-core . New deployments should use PostgreSQL; existing MongoDB-backed deployments remain fully supported. Ilum ships migration tooling (M001 through M009 scripts) for moving from MongoDB to PostgreSQL.

Ilum automatically creates all necessary databases and collections during the startup process when MongoDB is in use.

Apache Kafka ​

Apache Kafka sert de couche de communication d’Ilum, facilitant l’interaction entre les tâches Ilum-Core et Spark, ainsi que entre différentes instances Ilum-Core lorsqu’elles sont mises à l’échelle. Il est essentiel de s’assurer que les brokers Apache Kafka sont accessibles à la fois Tâches Ilum-Core et Spark, en particulier lorsque les tâches Spark sont lancées sur un autre cluster Kubernetes.

Ilum utilise Kafka pour mener à bien la communication à travers plusieurs sujets, tous créés lors du démarrage d’Ilum. Par conséquent, les utilisateurs Il n’est pas nécessaire de gérer ces rubriques manuellement.

MinIO ​

Ilum utilise MinIO comme couche de stockage pour les composants de l’application Spark. Tous les fichiers (y compris les jars, les configurations, les données fichiers) nécessaires au fonctionnement des composants Spark (pilote, exécuteurs) sont stockés et mis à disposition en téléchargement via MinIO.

MinIO implémente l’interface S3, qui lui permet également de stocker des données d’entrée/sortie.

Ilum-Livy-proxy ​

Le proxy Ilum-Livy est notre implémentation de l’API Livy, qui intègre le code Spark avec les groupes Ilum dans des services tels que Jupyter, Zeppelin, Airflow

Ilum Livy-proxy est activé dans Ilum par défaut.

Si vous souhaitez ajouter ou supprimer Ilum-Livy-proxy, vous pouvez utiliser ilum-livy-proxy.enabled helm pour le gérer. Par exemple: --set ilum-livy-proxy.enabled=false pour le désactiver.

En savoir plus sur Ilum-Livy-proxy ici

Jupyter ​

Jupyter est un environnement de développement sophistiqué qui vous permet d’avoir du code, des graphiques, des explications et plus encore dans un seul document exécutable.

Jupyter est activé dans Ilum par défaut.

Cependant, si vous souhaitez contrôler s’il est activé ou non, vous pouvez utiliser la valeur helm ilum-jupyter.enabled . Par exemple, vous pouvez ajouter --set ilum-jupyter.enabled=false à votre commande d’installation pour la désactiver.

Sachez que Jupyter utilise Ilum-Livy-proxy pour s’intégrer à Ilum Groups. Par conséquent, vous devez également l’activer : --set ilum-livy-proxy.enabled=vrai

Si vous souhaitez accéder à l’interface utilisateur de Jupyter, vous pouvez le faire en procédant comme suit :

• à l’aide de l’interface utilisateur Ilum : allez dans Modules > Jupyter
• Configuration d’une entrée
• Utilisation de la commande port-forward kubectl port-forward svc/ilum-jupyter 8888:8888

En savoir plus sur Jupyter ici

Apache Zeppelin ​

Zeppelin est un environnement de développement sophistiqué qui vous permet d’avoir du code, des graphiques, des explications et bien plus encore dans un seul document exécutable.

Veuillez noter que le bloc-notes Zeppelin n’est pas inclus dans le package ilum par défaut. Si vous souhaitez exécuter ce service, ajoutez --set ilum-zeppelin.enabled=vrai à votre commande d’installation.

Sachez que Zeppelin utilise Ilum-Livy-proxy pour s’intégrer à Ilum Groups. Par conséquent, vous devez également l’activer : --set ilum-livy-proxy.enabled=vrai

Si vous souhaitez accéder à l’interface utilisateur de Zeppelin, la meilleure façon de le faire est de configurer une entrée ou d’utiliser la commande port-forward kubectl port-forward svc/ilum-zeppelin 8080:8080

En savoir plus sur Zeppelin ici

Ruche Metastore ​

Hive Metastore is a metadata storage used to store your Spark catalogs (Spark tables, databases, views, and more) in a database instead of runtime memory. You can view these schemas later on the Explorateur de tables page.

ilum-core : 
  metastore : 
    Activé :  vrai 
    type : ruche 

ilum-hive-metastore: 
  Activé :  vrai 

Project Nessie​

Nessie is a transactional catalog for your data. It was inspired by Git and is designed to support a wide range of data-lake tooling. It works best with Apache Iceberg tables.

To learn more about Nessie, visit the Nessie documentation page.

ilum-core : 
  metastore : 
    Activé :  vrai 
    type :  nessie

nessie: 
  Activé :  vrai 

Ilum SQL (Kyuubi Gateway)​

Ilum SQL is the multi-engine SQL gateway built on Apache Kyuubi. It exposes a single JDBC and REST entry point for queries that route to Apache Spark , Trinitaire , DuckDB ou Apache Flink based on the engine selected for each query, or chosen by the automatic engine router.

To enable Ilum SQL, add --set ilum-sql.enabled=vrai pour activer l’hôte d’exécution SQL et --set ilum-core.sql.enabled=vrai to enable the SQL features inside Ilum itself.

Read more about the SQL Editor on the SQL Editor page.

Trinitaire ​

Note: Trino is not enabled in Ilum by default. To enable it, add --set trino.enabled=vrai to deploy a built-in Trino distribution.

Trino is a distributed SQL query engine well suited to interactive analytics on medium-to-large datasets and for federated queries across multiple data sources. It complements Spark for workloads that benefit from low-latency response times.

Once enabled, Trino is reachable through the Ilum SQL gateway and selectable from the Engine Selector in the SQL Editor. Read more on the SQL Editor page.

DuckDB and DuckLake​

DuckDB is enabled by default and provides single-node SQL execution for small-to-medium data, ad-hoc exploration, and DuckLake-managed tables. It runs in-process with ilum-core and is selectable from the Engine Selector in the SQL Editor.

DuckLake is the DuckDB-native catalog, enabled by default, with table data stored in MinIO (or any configured S3-compatible backend). No additional Helm values are required to use DuckDB or DuckLake.

Apache Flink​

Apache Flink support is available for Entreprise deployments as a Beta feature. Flink is exposed through the Kyuubi SQL gateway for low-latency stream processing. Contact Ilum for enablement details.

n8n ​

Note: n8n n’est pas activé dans Ilum par défaut. Pour l’activer, ajoutez --set ilum-n8n.enabled=vrai pour activer une distribution N8N intégrée.

n8n est une plateforme d’automatisation des flux de travail avec des capacités d’IA natives.

Pour en savoir plus, consultez le Page n8n .

Flux d’air Apache ​

Apache Airflow is a powerful platform for orchestrating and managing data workflows. To read more about Airflow in Ilum, visit the Airflow documentation page.

Once enabled, Airflow will appear in the Ilum UI under the Modules section.

Márquez ​

Marquez est un outil de gestion de métadonnées open-source qui se concentre sur la capture, l’agrégation, et la visualisation de la traçabilité des actifs de données au sein de l’écosystème de données d’une organisation. Il suit la façon dont les jeux de données sont produits et consommés par différents travaux et fournit une vue centrale de ces dépendances.

Veuillez noter que Marquez n’est pas inclus dans le package Ilum par défaut. Si vous souhaitez exécuter ce service, ajouter --set global.lineage.enabled=vrai à votre commande d’installation.

Tenez compte du fait que Márquez utilise Base de données PostgreSQL pour stocker les métadonnées. Vous pouvez lire à ce sujet sous .

De plus, si vous souhaitez utiliser le client Web de Marquez au lieu de l’interface utilisateur d’Ilum, activez le client Web par défaut avec --set ilum-marquez.web.enabled=vrai et configurez l’une des méthodes d’accès :

• Utilisation de la commande port-forward kubectl port-forward svc/ilum-marquez-web 9444:9444
• Configurer une entrée

En savoir plus sur la lignée Marquez et Ilum ici

Kestra ​

Kestra est un open-source Plateforme d’orchestration de données conçue pour l’orchestration et l’automatisation des données pipelines et flux de travail métier. Vous pouvez lire à ce sujet ici .

Mage​

Mage is an open-source data engineering platform that simplifies the process of building, deploying, and maintaining data pipelines. It provides a user-friendly interface for creating data workflows, integrating with various data sources, and managing data transformations.

To read about Mage next to Ilum, visit the page de documentation .

NiFi​

Apache NiFi is a software project for building data processing pipelines. It provides a user interface for creating, managing, and deploying data processing pipelines.

To read about NiFi next to Ilum, visit the page de documentation .

Streamlit​

Streamlit is a library for creating beautiful, performant, and scalable data apps in Python. It is used to build custom data apps accessible from the Ilum UI.

To read about Streamlit next to Ilum, visit the page de documentation .

Pile Kube Prometheus ​

Kube Prometheus Stack inclut Prometheus, Grafana et d’autres outils pour surveiller votre infrastructure de données

Veuillez noter que Kube Prometheus Stack n’est pas inclus par défaut dans le package ilum. Si vous souhaitez exécuter ce service, ajoutez --set kube-prometheus-stack.enabled=vrai à votre commande d’installation.

Si vous mettez à niveau un graphique Helm Ilum existant qui le faisait précédemment non si la pile Kube Prometheus est activée, vous devez d’abord installer les définitions de ressources personnalisées (CRD) Prometheus requises avant de procéder à la mise à niveau. Pour ce faire, exécutez les commandes suivantes :

kubectl apply --server-side -f https://raw.githubusercontent.com/prometheus-operator/prometheus-operator/v0.80.0/example/prometheus-operator-crd/monitoring.coreos.com_alertmanagerconfigs.yaml 
kubectl apply --server-side -f https://raw.githubusercontent.com/prometheus-operator/prometheus-operator/v0.80.0/example/prometheus-operator-crd/monitoring.coreos.com_alertmanagers.yaml 
kubectl apply --server-side -f https://raw.githubusercontent.com/prometheus-operator/prometheus-operator/v0.80.0/example/prometheus-operator-crd/monitoring.coreos.com_podmonitors.yaml 
kubectl apply --server-side -f https://raw.githubusercontent.com/prometheus-operator/prometheus-operator/v0.80.0/example/prometheus-operator-crd/monitoring.coreos.com_probes.yaml 
kubectl apply --server-side -f https://raw.githubusercontent.com/prometheus-operator/prometheus-operator/v0.80.0/example/prometheus-operator-crd/monitoring.coreos.com_prometheusagents.yaml 
kubectl apply --server-side -f https://raw.githubusercontent.com/prometheus-operator/prometheus-operator/v0.80.0/example/prometheus-operator-crd/monitoring.coreos.com_prometheuses.yaml 
kubectl apply --server-side -f https://raw.githubusercontent.com/prometheus-operator/prometheus-operator/v0.80.0/example/prometheus-operator-crd/monitoring.coreos.com_prometheusrules.yaml 
kubectl apply --server-side -f https://raw.githubusercontent.com/prometheus-operator/prometheus-operator/v0.80.0/example/prometheus-operator-crd/monitoring.coreos.com_scrapeconfigs.yaml 
kubectl apply --server-side -f https://raw.githubusercontent.com/prometheus-operator/prometheus-operator/v0.80.0/example/prometheus-operator-crd/monitoring.coreos.com_servicemonitors.yaml 
kubectl apply --server-side -f https://raw.githubusercontent.com/prometheus-operator/prometheus-operator/v0.80.0/example/prometheus-operator-crd/monitoring.coreos.com_thanosrulers.yaml 

Si vous souhaitez accéder à l’interface utilisateur de Prometheus, la meilleure façon de le faire est de configurer une entrée ou d’utiliser la commande port-forward kubectl Port-forward SVC/Exploité par Prometheus 9090:9090

Si vous souhaitez accéder à l’interface utilisateur de Grafana, la meilleure façon de le faire est de configurer une entrée ou d’utiliser la commande port-forward kubectl port-forward svc/ilum-grafana 8080:80

Loki et Promtail ​

Loki est utilisé pour collecter et gérer les journaux de votre infrastructure de données. Promtail est utilisé comme un agent qui pousse les journaux dans Loki

S’il vous plaît, soyez conscient, que Loki n’est pas activé dans Ilum par défaut. Si vous souhaitez exécuter ce service, ajoutez --set global.logAggregation.loki.enabled=vrai à votre commande d’installation.

Promtail aussi n’est pas activé dans Ilum par défaut. Pour l’activer, ajoutez --set global.logAggreagtion.promtail.enabled=vrai à votre commande d’installation

Si vous souhaitez accéder à Loki et exécuter Loki Queries, vous pouvez configurer une entrée ou utiliser la commande port-forward kubectl port-forward svc/ilum-loki-read 3100:3100 pour les requêtes de lecture et kubectl port-forward svc/ilum-loki-write 3100:3100 pour les requêtes d’écriture. Vous pouvez également utiliser service ilum-loki-gateway Pour lier Grafana à Loki

Production Architecture Overview​

Recommendations on which optionally deployed components to place in which namespace, whether in the one belonging to the Ilum release or in separate, dedicated ones.

┌─────────────────────────┐     ┌────────────────────────────┐
│   ILUM                  │     │   Dependencies             │
│   components            │     │   separated                │
│   namespace             │     │   namespaces               │
├─────────────────────────┤     ├────────────────────────────┤
│ • Ilum Core **          │     │ • PostgreSQL **            │
│ • Ilum UI **            │     │ • MongoDB (legacy)         │
│ • Ilum API **           │     │ • Kafka **                 │
│ • Ilum Livy-Proxy *     │     │ • MinIO *                  │
│ • Ilum Jupyter *        │     │ • Kube-Prometheus-Stack *  │
│ • Ilum Zeppelin         │     │ • Loki & Promtail *        │
│ • Ilum Hive Metastore * │     └────────────────────────────┘
│ • Ilum Kyuubi *         │
│ • Trino                 │
│ • Marquez *             │
│ • Unity Catalog         │
│ • Nessie                │
│ • Airflow               │
│ • MLflow                │
│ • LangFuse              │
│ • Superset              │
│ • Streamlit             │
│ • Gitea *               │
│ • N8N                   │
│ • Kestra                │
│ • Mage                  │
│ • OpenLDAP              │
└─────────────────────────┘
**  Mandatory components for production release
*   Recommended components for production release

Network Communication​

• Inter-namespace Communication: Configured via Kubernetes Services and NetworkPolicies
• Service Discovery: DNS-based service resolution
• Sécurité : TLS encryption for all inter-service communication

High Availability Configuration​

For production deployments, critical services should run with multiple replicas to eliminate single points of failure. The following table shows recommended configurations:

Example Helm values for a fully HA deployment:

ilum-core : 
  replicaCount :  3 

mongodb: 
  replicaCount :  3 

Kafka : 
  replicaCount :  3 

minio : 
  Répliques :  4 

postgresql: 
  replicaCount :  3 

Failure Domains & Resilience​

Ilum's architecture is designed to eliminate single points of failure through several mechanisms:

Stateless Core Design​

Le ilum-core component is fully stateless. It persists no local data and can recover its entire state from PostgreSQL (or MongoDB on legacy deployments) and Kafka after a crash or restart. This means any ilum-core replica can handle any request, enabling seamless horizontal scaling and zero-downtime rolling updates.

Le ilum-api module-management microservice is also stateless. It can be scaled horizontally and tolerates pod restarts without losing in-flight Helm operations, thanks to a long termination grace period.

Pod Anti-Affinity​

Configure Kubernetes pod anti-affinity rules to ensure replicas of critical services are spread across different nodes and availability zones:

ilum-core : 
  affinité : 
    podAntiAffinity: 
      preferredDuringSchedulingIgnoredDuringExecution: 
        -  weight:  100 
          podAffinityTerm: 
            labelSelector: 
              matchExpressions: 
                -  clé : appli 
                  opérateur : Dans 
                  Valeurs : 
                    - ilum - noyau 
            topologyKey:  kubernetes.io/hostname

Namespace-Level Isolation​

Deploying dependencies (MongoDB, Kafka, MinIO, PostgreSQL) in separate namespaces provides blast radius containment. A failure in one component's namespace does not cascade to others. See Namespace Separation Strategy for details.

Leader Election​

For components that require coordination (such as the Spark History Server or scheduled maintenance tasks), Kubernetes-native leader election ensures that exactly one instance acts as the primary while others stand by for automatic failover.

Dynamic Resource Scaling​

Ilum supports multiple layers of dynamic scaling to match compute resources with workload demands.

Spark Dynamic Allocation​

Enable Spark's built-in dynamic allocation to automatically adjust the number of executors based on workload:

# Cluster-level Spark defaults in ilum
spark.dynamicAllocation.enabled:  « Vrai » 
spark.dynamicAllocation.minExecutors:  "1"
spark.dynamicAllocation.maxExecutors:  "20"
spark.dynamicAllocation.executorIdleTimeout:  "60s"
spark.dynamicAllocation.schedulerBacklogTimeout:  "5s"

With dynamic allocation, idle executors are released back to the cluster, freeing resources for other jobs. New executors are added automatically when tasks queue up.

Kubernetes Horizontal Pod Autoscaler (HPA)​

For always-on services like Trino coordinators or ilum-core, use Kubernetes HPA to scale based on CPU or memory utilization:

apiVersion :  autoscaling/v2
gentil :  HorizontalPodAutoscaler
métadonnées : 
  nom : ilum - noyau - hpa
Spec : 
  scaleTargetRef: 
    apiVersion : applications/v1 
    gentil : Déploiement 
    nom : ilum - noyau 
  minReplicas:  2 
  maxReplicas:  5 
  métrique : 
    -  type : Ressource 
      resource: 
        nom :  cpu
        cible : 
          type :  Utilization
          averageUtilization:  70 

Cluster Autoscaler Integration​

Ilum works seamlessly with Kubernetes cluster autoscalers (available on GKE, EKS, AKS, and via Cluster API). When Spark jobs request more executor pods than the current cluster can accommodate, the cluster autoscaler provisions additional nodes automatically. When pods are released, nodes are drained and removed.

Auto-Pause on Idle​

Ilum's interactive services (SQL Editor sessions, Jupyter notebooks) can be configured to automatically pause after a period of inactivity, releasing compute resources:

ilum-core : 
  SQL : 
    duckdb: 
      idleTimeout:  1h
  job: 
    retain: 
      hours:  24

Namespace Separation Strategy​

Recommended Namespace Structure​

# Core Ilum Components placed in ilum namespace
ilum :           # Main application services (ilum-core, ilum-ui, ilum-api)

# Critical Dependencies (Separate Namespaces)
ilum-postgresql:     # PostgreSQL databases (primary metadata store)
ilum-mongodb:        # MongoDB cluster (legacy metadata store)
ilum-kafka:          # Kafka brokers (required for ilum-core HA)
ilum-minio:          # Object storage cluster
ilum-kps:            # Kube-prometheus-stack monitoring resources
ilum-logs:           # Loki & Promtail log aggregation resources

Namespace Creation​

Create all required namespaces before deployment:

⚠️ Warning: Create namespaces only for components you plan to deploy

# Ilum namespace
kubectl create namespace ilum 

# Dependency namespaces
kubectl create namespace ilum-mongodb
kubectl create namespace ilum-kafka
kubectl create namespace ilum-minio
kubectl create namespace ilum-postgresql
kubectl create namespace ilum-kps
kubectl create namespace ilum-logs

Clés de sécurité ​

Cette application utilise des jetons Web JSON (JWT) à des fins d’authentification. Par défaut, l’application utilise une clé RSA pair, qui est généré de manière aléatoire au moment de l’exécution, pour signer ces jetons.

Dans sa configuration standard, l’application crée une nouvelle paire de clés RSA à chaque démarrage. Cette approche simplifie le développement et les tests locaux en gérant automatiquement le processus de génération de clés. Cependant, il doit l’être a souligné que cette approche n’est pas adaptée à un environnement de production.

Le principal problème lié à l’utilisation de clés générées de manière aléatoire dans un environnement de production est le manque de persistance. Chaque fois que l’application redémarre, elle génère une nouvelle paire de clés RSA, invalidant tous les tokens précédemment émis. Cela pourrait conduire à Une déconnexion soudaine et imprévue pour tous les utilisateurs, perturbant l’expérience utilisateur et entraînant potentiellement une perte de données.

Générer une clé privée ​

Pour un environnement de production, une paire de clés stable et sécurisée doit être générée manuellement et utilisée de manière cohérente. Ceci Garantit que les jetons restent valides lors de plusieurs redémarrages d’applications, offrant ainsi une expérience utilisateur cohérente.

Vous pouvez générer une paire de clés RSA manuellement à l’aide d’outils tels qu’OpenSSL. Voici une commande courante pour générer une clé privée RSA 2048 bits :

openssl genpkey -algorithme RSA \ 
-pkeyopt rsa_keygen_bits :2048 \ 
-pkeyopt rsa_keygen_pubexp :65537 | \ 
openssl pkcs8 -topk8 -nocrypt -outform pem > private-key.p8 

Le contenu de la clé privée doit ressembler à ce qui suit :

-----DÉBUT DE LA CLÉ PRIVÉE----- 
MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCsRnE83rm6BJya 
nTyzVqX0SG+D4zBjkyWsOmGG+CoDdgQ6Z8AaocmnjP1SbRykQsQSMf6SeW+fdpH+ 
ccmzuHe7pZIa2o2Mg8xbk/UszJDaPztwoQbUt/2gHi/rZP8cIVkquzhnN/yxrMls 
... 
-----FIN DE LA CLÉ PRIVÉE----- 

Afin d’utiliser la clé privée comme paramètre ilum-core.security.jwt.privateKey, supprimez l’en-tête et le pied de page de la clé.

Générer une clé publique ​

Pour générer la clé publique correspondante, utilisez :

openssl pkey -pubout -inform pem -outform pem -in private-key.p8 -out public-key.spki 

Le contenu de la clé publique doit ressembler à ce qui suit :

-----DÉBUT DE LA CLÉ PUBLIQUE----- 
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArEZxPN65ugScmp08s1al 
9Ehvg+MwY5MlrDphhvgqA3YEOmfAGqHJp4z9Um0cpELEEjH+knlvn3aR/nHJs7h3 
u6WSGtqNjIPMW5P1LMyQ2j87cKEG1Lf9oB4v62T/HCFZKrs4Zzf8sazJbMN3E/mJ 
... 
-----FIN DE LA CLÉ PUBLIQUE----- 

Afin d’utiliser la clé publique comme paramètre ilum-core.security.jwt.publicKey, supprimez l’en-tête et le pied de page de la clé.

Authentication Methods​

Ilum en tant que fournisseur d’identité ​

Ilum peut être déployé en tant que fournisseur d’identité. Grâce à cette fonctionnalité, vous pouvez gérer les utilisateurs exclusivement dans Ilum et les authentifier sur d’autres microservices tels que Airflow, Superset, Grafana, Gita et Minio.

Pour activer le fournisseur d’identité d’Ilum, ajoutez les indicateurs suivants : --set global.security.hydra.enabled=vrai et --set global.security.hydra.uiUrl=<your-ilum-ui-domain> .

Pour en savoir plus sur la configuration du fournisseur d’identité, consultez la page Cette page

OpenLDAP​

OpenLDAP is the open-source LDAP server. It is not enabled in Ilum by default. To enable it add --set openldap.enabled=true to your installation command.

If you want to access OpenLDAP you can use port-forward command kubectl port-forward svc/ilum-openldap 1389:389.

Ilum-Core is preconfigured to connect to OpenLDAP server deployed by Ilum. However you must switch security type to LDAP by adding --set ilum-core.security.type=ldapà votre commande d’installation.

To learn more about OpenLDAP and LDAP in Ilum, visit the LDAP documentation page ici .

Dependency Deployment​

Note : The components described below are required or recommended dependencies for Ilum. You can choose to deploy them using the provided instructions or integrate with your own existing managed services.

MongoDB ​

Deploy MongoDB in a dedicated namespace with high availability

1. Add Bitnami Repository​

helm repo add bitnami https://charts.bitnami.com/bitnami
Mise à jour du référentiel Helm 

2. Create MongoDB Values File​

# mongodb-values.yaml
image : 
  registry:  docker.io
  dépôt :  ilum/mongodb
  tag:  6.0.5
fullnameRemplacer :  "ilum-mongodb"
architecture:  "replicaset"
Auth : 
  Activé :  faux 
volumePermissions: 
  Activé :  vrai 

3. Deploy MongoDB, Ilum by default uses chart in ^13.x version but should also work with newer versions​

helm install mongodb bitnami/mongodb \
  --namespace ilum-mongodb \
  --version 13.18.5 \
  --values mongodb-values.yaml

For more information about mongo deployment refer to mongodb chart details

4. Ilum AIO chart configuration values that need to be changed​

# Disable bundled mongo
mongodb: 
  Activé :  faux 

ilum-core : 
  mongo: 
    URI :  "mongodb://ilum-mongodb-0.ilum-mongodb-headless.ilum-mongodb:27017,ilum-mongodb-1.ilum-mongodb-headless.ilum-mongodb:27017/ilum?replicaSet=rs0"
         # or use your mongo instance uri

Apache Kafka ​

Deploy Kafka cluster in a dedicated namespace

1. Add Bitnami Repository​

helm repo add bitnami https://charts.bitnami.com/bitnami
Mise à jour du référentiel Helm 

2. Create Kafka Values File​

# kafka-values.yaml
extraConfig:  | 
  auto.create.topics.enable=false
  message.max.bytes=20000000
fullnameRemplacer :  "ilum-kafka"
listeners: 
  client : 
    protocole :  PLAINTEXT

3. Deploy Kafka, Ilum by default uses chart in ^25.x version but should also work with newer versions​

helm install kafka bitnami/kafka \
  --namespace ilum-kafka \
  --version 25.3.5 \
  --values kafka-values.yaml

For more information about kafka deployment refer to kafka chart details

4. Ilum AIO chart configuration values that need to be changed​

ilum-core : 
  communication: 
    type : Kafka 
  Kafka : 
    address:  "ilum-kafka-controller-0.ilum-kafka-controller-headless.ilum-kafka:9092,ilum-kafka-controller-1.ilum-kafka-controller-headless.ilum-kafka:9092,ilum-kafka-controller-2.ilum-kafka-controller-headless.ilum-kafka:9092"
    # or use your kafka instance address

MinIO Deployment​

Deploy MinIO cluster for object storage:

1. Add Bitnami Repository​

helm repo add bitnami https://charts.bitnami.com/bitnami
Mise à jour du référentiel Helm 

2. Create MinIO Values File​

# minio-values.yaml
extraEnvVars :  | 
  - name: MINIO_BROWSER_REDIRECT_URL
    value: "http://ilum-minio.ilum-minio:9001/external/minio/"
 # Environment variables for hydra
  -  nom :  MINIO_IDENTITY_OPENID_CONFIG_URL
    valeur :  "ILUM_UI_PROTOCOL://ILUM_UI_DOMAIN/external/hydra/.well-known/openid-configuration"
  -  nom :  MINIO_IDENTITY_OPENID_CLIENT_ID
    valeur :  "HYDRA_CLIENT_ID"
  -  nom :  MINIO_IDENTITY_OPENID_CLIENT_SECRET
    valeur :  "HYDRA_CLIENT_SECRET"
  -  nom :  MINIO_IDENTITY_OPENID_REDIRECT_URI
    valeur :  "ILUM_UI_PROTOCOL://ILUM_UI_DOMAIN/external/minio/oauth_callback"
  -  nom :  MINIO_IDENTITY_OPENID_SCOPES
    valeur :  "openid,profile,email"
  -  nom :   MINIO_IDENTITY_OPENID_CLAIM_NAME
    valeur :  "minio_policies"
 # end of hydra related environment variables
fullnameRemplacer :  "ilum-minio"
defaultBuckets:  "ilum-files, ilum-data, ilum-tables, ilum-mlflow, ilum-kestra"
Auth : 
  rootUser:  "<your-s3-access-key>"
  rootPassword:  "<your-s3-secret-key>"
persistence: 
  taille :  16Gi

3. Deploy MinIO, Ilum by default uses chart in ^15.x version but should also work with newer versions​

helm install minio bitnami/minio \
  --namespace ilum-minio \
  --version 15.0.7 \
  --values minio-values.yaml

For more information about minio deployment refer to minio chart details

4. Ilum AIO chart configuration values that need to be changed​

# Disable bundled minio
minio : 
  Activé :  faux 

ilum-core : 
  minio : 
    statusProbe: 
      baseUrl:  "http://ilum-minio.ilum-minio:9000"
  kubernetes: 
    storage: 
      type : S3 
    S3 : 
      hôte :  "ilum-minio.ilum-minio"
      port :  9000 
      accessKey:  "<your-s3-access-key>"
      secretKey:  "<your-s3-secret-key>"

# If hive metastore is deployed with minio as the storage
ilum-hive-metastore: 
  storage: 
    metastore : 
      warehouse:  "s3a://ilum-data/"
    type :  « S3 » 
    S3 : 
      hôte :  "ilum-minio.ilum-minio"
      port :  9000 
      accessKey:  "<your-s3-access-key>"
      secretKey:  "<your-s3-secret-key>"

# If trino is deployed with minio as the storage
Trino : 
  Catalogues : 
    ilum-delta :  | 
connector.name=delta_lake 
      delta.metastore.store-table-metadata=true
      delta.register-table-procedure.enabled=true
      hive.metastore.uri=thrift://ilum-hive-metastore:9083
      fs.native-s3.enabled=true
      s3.endpoint=http://ilum-minio.ilum-minio:9000
      s3.region=us-east-1
      s3.path-style-access=true
      s3.aws-access-key=<your-s3-access-key>
      s3.aws-secret-key=<your-s3-secret-key>

# If Loki is deployed with s3 as the storage
loki: 
  loki: 
    auth_enabled:  faux 
    storage: 
      bucketNames: 
        chunks: ilum - Fichiers 
        ruler: ilum - Fichiers 
        Admin : ilum - Fichiers 
      type : S3 
      S3 : 
        extrémité : http : ilum - minio.ilum- minio : 9000 
        region:  us- Est - 1 
        secretAccessKey: <votre - S3 - secret - clé > 
        accessKeyId: <votre - S3 - accès - clé > 
        s3ForcePathStyle:  vrai 
        insecure:  vrai 

# If minio is deployed
minioExtensions: 
  hôte : http : ilum - minio.ilum- minio : 9000 

# If airflow is deployed with minio as the logs storage
airflow: 
  extraEnv:  | 
    - name: AIRFLOW__API__AUTH_BACKENDS
      value: "airflow.api.auth.backend.default"
    - name: MINIO_USERNAME
      value: "<your-s3-credential>"
    - name: MINIO_PASSWORD
      value: "<your-s3-credential>"
    - name: MINIO_ENDPOINT
      value: "http://ilum-minio.ilum-minio:9000"

# If mlflow is deployed
mlflow : 
  externalS3: 
    hôte :  "ilum-minio.ilum-minio"

# If kestra is deployed with minio as the storage
kestra: 
  configuration: 
    kestra: 
      storage: 
        type : minio 
        minio : 
          extrémité : ilum - minio.ilum- minio 
          port :  9000 
          secure:  faux 
          accessKey: <votre - S3 - accès - clé > 
          secretKey: <votre - S3 - secret - clé > 
          region:  « par défaut » 
          bucket: ilum - kestra

PostgreSQL Deployment​

Deploy PostgreSQL for metadata storage:

1. Add Bitnami Repository​

helm repo add bitnami https://charts.bitnami.com/bitnami
Mise à jour du référentiel Helm 

2. Create PostgreSQL Values File​

# postgresql-values.yaml
fullnameRemplacer : ilum - postgresql
Auth : 
  postgresPassword:  « CHANGE-MOI, S’IL TE PLAÎT » 
  nom d’utilisateur : ilum 
  mot de passe :  « CHANGE-MOI, S’IL TE PLAÎT » 

3. Deploy PostgreSQL, Ilum by default uses chart in ^13.x version but should also work with newer versions​

helm install postgresql bitnami/postgresql \
  --namespace ilum-postgresql \
  --version 13.4.4 \
  --values postgresql-values.yaml

For more information about postgresql deployment refer to postgresql chart details

4. Ilum AIO chart configuration values that need to be changed​

# Disable bundled PostgreSQL
postgresql: 
  Activé :  faux 

#Postgres extensions for databases auto-creation
postgresExtensions: 
  hôte :  "ilum-postgresql-hl.ilum-postgresql"
  port :  5432 
  databasesToCreate:  marquez, airflow, metastore , mlflow , mlflow_auth, superset, Gitea , n8n , hydre , kestra
  Auth : 
    nom d’utilisateur : ilum 
    mot de passe :  « CHANGE-MOI, S’IL TE PLAÎT » 

# Configure hydra database if hydra is enabled in ilum-core deployment
ilum-core : 
  hydre : 
    dns: Postgres : ilum : CHANGEMEPLEASE@ilum- postgresql.ilum- postgresql: 5432/hydra?sslmode=disable

# If ilum-hive-metastore is deployed
ilum-hive-metastore: 
  postgresql: 
    hôte :  "ilum-postgresql-hl.ilum-postgresql"
    port :  5432 
    database: metastore 
    Auth : 
      nom d’utilisateur : ilum 
      mot de passe :  « CHANGE-MOI, S’IL TE PLAÎT » 

# If lineage is enabled
ilum-marquez: 
  marquez: 
    db: 
      image :  « bitnami/postgresql :16 » 
      hôte :  "ilum-postgresql-0.ilum-postgresql-hl.ilum-postgresql"
      port :  5432 
      nom :  marquez
      utilisateur : ilum 
      mot de passe :  « CHANGE-MOI, S’IL TE PLAÎT » 

# If gitea is deployed
Gitea : 
  initPreScript:  "while ! nc -z ilum-postgresql-hl.ilum-postgresql 5432 2>/dev/null; do echo 'Waiting for Postgres...'; sleep 5; done; echo 'Postgres is ready!'"
  Gitea : 
    Configuration : 
      serveur : 
        ROOT_URL : http : //gitea.example.com/external/gitea
      database: 
        DB_TYPE: Postgres 
        HOST:  "ilum-postgresql-hl.ilum-postgresql:5432"
        NAME: Gitea 
        UTILISATEUR : ilum 
        PASSWD:  « CHANGE-MOI, S’IL TE PLAÎT » 

# If airflow is deployed with postgres as metadata connection
airflow: 
  données : 
    metadataConnection: 
      utilisateur : Postgres 
      passer :  « CHANGE-MOI, S’IL TE PLAÎT » 
      protocole :  postgresql
      hôte :  "ilum-postgresql-hl.ilum-postgresql"
      port :  5432 
      db:  airflow
      sslmode:  disable

# If superset is deployed with postgres as the storage
superset: 
  supersetNode: 
    connections: 
      db_host:  "ilum-postgresql-hl.ilum-postgresql"
      db_port:  "5432"
      db_user: ilum 
      db_pass:  « CHANGE-MOI, S’IL TE PLAÎT » 
      db_name:  superset

# If mlflow is deployed with postgres as the external database
mlflow : 
  externalDatabase: 
    dialectDriver:  "postgresql"
    hôte :  "ilum-postgresql-hl.ilum-postgresql"
    port :  5432 
    utilisateur : ilum 
    database: mlflow 
    authDatabase:  mlflow_auth
    existingSecret:  "ilum-postgresql"
    existingSecretPasswordKey:  "postgres-password"

# If n8n is deployed
n8n : 
  db: 
    type :  postgresdb
  externalPostgresql: 
    hôte :  "ilum-postgresql-hl.ilum-postgresql"
    nom d’utilisateur :  "ilum"
    mot de passe :  « CHANGE-MOI, S’IL TE PLAÎT » 
    database:  "n8n"

# If kestra is deployed
kestra: 
  configuration: 
    datasources: 
      Postgres : 
        URL :  "jdbc:postgresql://ilum-postgresql-hl.ilum-postgresql:5432/kestra"
        driverClassName:  "org.postgresql.Driver"
        nom d’utilisateur : ilum 
        mot de passe :  « CHANGE-MOI, S’IL TE PLAÎT » 
  initContainers: 
    -  nom :  wait- pour - Postgres 
      image :  « bitnami/postgresql :16 » 
      command: 
        -  /bin/bash
      args : 
        -  - ec
        -  | 
          until pg_isready -h ilum-postgresql-hl.ilum-postgresql -p 5432 -U ilum -d kestra; do
            echo "Waiting for PostgreSQL server to be ready..."
            sleep 2
fait 
          echo "Database is ready!"

Kube-Prometheus-Stack Deployment (If you plan to use it)​

Deploy Kube-Prometheus-Stack for monitoring purposes:

1. Add Prometheus Community Repository​

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
Mise à jour du référentiel Helm 

2. Create Kube-Prometheus-Stack Values File​

# kps-values.yaml
nomRemplacement :  "ilum-kps"
kubeStateMetrics: 
  Activé :  faux 
nodeExporter: 
  Activé :  faux 
alertmanager: 
  Activé :  faux 
Grafana : 
  nomRemplacement :  "ilum-grafana"
  grafana.ini : 
    serveur : 
      root_url :  "%(protocol)s://%(domain)s:%(http_port)s/external/grafana"
      serve_from_sub_path:  « Vrai » 
    auth.generic_oauth : 
      Activé :  faux 
      nom : Ilum 
      allow_sign_up:  vrai 
      login_attribute_path:  userId
      email_attribute_name: Messagerie électronique 
      role_attribute_path : contient(grafana_roles , 'Administrateur') && 'Administrateur' | | contient(grafana_roles , 'Éditeur') && 'Éditeur' | | contient(grafana_roles ,  'Viewer') && 'Spectateur' 
      role_attribute_strict:  vrai 
  adminPassword: Admin 
  sidecar: 
    dashboards: 
      folderAnnotation:  "grafana_folder"
      fournisseur : 
        foldersFromFilesStructure:  « Vrai » 

3. Deploy kube-prometheus-stack, Ilum by default uses chart in ^54.x version but should also work with newer versions​

helm install kube-prometheus-stack prometheus-community/kube-prometheus-stack \
  --namespace ilum-kps \
  --version 54.2.2 \
  --values kps-values.yaml

For more information about kube-prometheus-stack deployment refer to kps chart details

4. Define prometheus PodMonitors and ServiceMonitors​

You can define your own Pod and ServiceMonitors for prometheus. Example PodMonitors defined in Ilum AIO chart you can use

Ilum Pods Monitor

apiVersion :  monitoring.coreos.com/v1
gentil :  PodMonitor
métadonnées : 
  nom : ilum - pods- monitor
  Namespace : ilum - kps
  Étiquettes : 
    ilum.prometheus:  « Vrai » 
Spec : 
  sélecteur : 
    matchLabels : 
      ilum.prometheus:  « Vrai » 
  podMetricsEndpoints: 
    -  interval:  5s
      port : http 
      chemin :  /actuator/prometheus
  namespaceSelector: 
    matchNames: 
      - ilum 

Spark Driver Pods Monitor

apiVersion :  monitoring.coreos.com/v1
gentil :  PodMonitor
métadonnées : 
  nom : ilum - chauffeur - pods- monitor
  Namespace : ilum - kps
  Étiquettes : 
    ilum.resourceType: chauffeur 
Spec : 
  sélecteur : 
    matchLabels : 
      ilum.resourceType: chauffeur 
  podMetricsEndpoints: 
    -  interval:  5s
      port : étincelle - Ui 
      chemin :  /metrics/executors/prometheus/
    -  interval:  5s
      port : étincelle - Ui 
      chemin :  /metrics/prometheus/
  namespaceSelector: 
    any:  vrai 

Loki & Promtail Deployment (If you plan to use it)​

Deploy Loki & Promtail for logs aggregation:

1. Add Grafana Repository​

helm repo add grafana https://grafana.github.io/helm-charts
Mise à jour du référentiel Helm 

2. Create Loki and Promtail Values File​

# loki-values.yaml
nomRemplacement : ilum - loki
surveillance : 
  selfMonitoring: 
    Activé :  faux 
    grafanaAgent: 
      installOperator:  faux 
    lokiCanary: 
      Activé :  faux 
test: 
  Activé :  faux 
loki: 
  auth_enabled:  faux 
  storage: 
    bucketNames: 
      chunks: ilum - Fichiers 
      ruler: ilum - Fichiers 
      Admin : ilum - Fichiers 
    type : S3 
    S3 : 
      extrémité : http : ilum - minio.ilum- minio : 9000 
      region:  us- Est - 1 
      secretAccessKey: <votre - S3 - secret - clé > 
      accessKeyId: <votre - S3 - accès - clé > 
      s3ForcePathStyle:  vrai 
      insecure:  vrai 
  compactor: 
    retention_enabled:  vrai 
    deletion_mode: filtre - et - supprimer 
    shared_store: S3 
  limits_config: 
    allow_deletes:  vrai 

# promtail-values.yaml
Configuration : 
  clients: 
    -  URL : http : ilum - loki- écrire : 3100/loki/api/v1/push
  snippets: 
    pipelineStages: 
      -  match: 
          sélecteur :  '{ilum_logAggregation!="true"}'
          action: goutte 
          drop_counter_reason: non_ilum_log 
    extraRelabelConfigs: 
      -  action: Étiquettemap 
        regex:  "__meta_kubernetes_pod_label_ilum(.*)"
        replacement:  "ilum${1}"
      -  action: Étiquettemap 
        regex:  "__meta_kubernetes_pod_label_spark(.*)"
        replacement:  "spark${1}"

    scrapeConfigs:  | 
      - job_name: kubernetes-pods
        pipeline_stages:
          {{- toYaml .Values.config.snippets.pipelineStages | nindent 4 }}
        kubernetes_sd_configs:
          - role: pod
            namespaces:
              names:
              - ilum
        relabel_configs:
          - source_labels:
              - __meta_kubernetes_pod_controller_name
            regex: ([0-9a-z-.]+?)(-[0-9a-f]{8,10})?
            action: replace
            target_label: __tmp_controller_name
          - source_labels:
              - __meta_kubernetes_pod_label_app_kubernetes_io_name
              - __meta_kubernetes_pod_label_app
              - __tmp_controller_name
              - __meta_kubernetes_pod_name
            regex: ^;*([^;]+)(;.*)?$
            action: replace
            target_label: app
          - source_labels:
              - __meta_kubernetes_pod_label_app_kubernetes_io_instance
              - __meta_kubernetes_pod_label_instance
            regex: ^;*([^;]+)(;.*)?$
            action: replace
            target_label: instance
          - source_labels:
              - __meta_kubernetes_pod_label_app_kubernetes_io_component
              - __meta_kubernetes_pod_label_component
            regex: ^;*([^;]+)(;.*)?$
            action: replace
            target_label: component
          {{- if .Values.config.snippets.addScrapeJobLabel }}
          - replacement: kubernetes-pods
            target_label: scrape_job
          {{- end }}
          {{- toYaml .Values.config.snippets.common | nindent 4 }}
          {{- with .Values.config.snippets.extraRelabelConfigs }}
          {{- toYaml . | nindent 4 }}
          {{- end }}

3. Deploy Loki, Ilum by default uses chart in 3.5.0 version but should also work with newer versions​

helm install loki grafana/loki \
  --namespace ilum-logs \
  --version 3.5.0 \
  --values loki-values.yaml

For more information about loki deployment refer to loki chart details

4. Deploy Promtail, Ilum by default uses chart in ^6.15.x version but should also work with newer versions​

helm install promtail grafana/promtail \
  --namespace ilum-logs \
  --version 6.15.5 \
  --values promtail-values.yaml

For more information about promtail deployment refer to promtail chart details

5. Ilum AIO chart configuration values that need to be changed​

global : 
  logAggregation: 
    Activé :  vrai 
    loki: 
      Activé :  faux 
      URL : http : ilum - loki- gateway.ilum- logs
    promtail: 
      Activé :  faux 

Pre-configured Stack Examples​

Note : In those examples security configuration has been ignored, so those deployments stick to Ilum internal security mechanism, if you want to know how to use other security methods refer to LDAP ou OAUTH2

Option 1: Minimal Production Stack​

Suitable for deployments with basic requirements. Extra enabled modules:

• ilum-sql
• ilum-hive-metastore
• ilum-marquez (lineage)

Minimal needed values file taking into account the components deployment described above. For more detailed configuration you can examine dedicated charts, for example ilum-core

# minimal-production-values.yaml
global : 
  lineage: 
    Activé :  vrai 

ilum-core : 
  sécurité : 
    jwt: 
      privateKey:  Key generated as described in Security- keys section
      publicKey:  Key generated as described in Security- keys section
  SQL : 
    Activé :  vrai 
  metastore : 
    Activé :  vrai 
    type : ruche 
  mongo: 
    URI :  "mongodb://ilum-mongodb-0.ilum-mongodb-headless.ilum-mongodb:27017,ilum-mongodb-1.ilum-mongodb-headless.ilum-mongodb:27017/ilum?replicaSet=rs0"
  communication: 
    type : Kafka 
  Kafka : 
    address:  "ilum-kafka-controller-0.ilum-kafka-controller-headless.ilum-kafka:9092,ilum-kafka-controller-1.ilum-kafka-controller-headless.ilum-kafka:9092,ilum-kafka-controller-2.ilum-kafka-controller-headless.ilum-kafka:9092"
  minio : 
    statusProbe: 
      baseUrl:  "http://ilum-minio.ilum-minio:9000"
  kubernetes: 
    storage: 
      type : S3 
    S3 : 
      hôte :  "ilum-minio.ilum-minio"
      port :  9000 
      accessKey:  "<your-s3-access-key>"
      secretKey:  "<your-s3-secret-key>"

Gitea : 
  initPreScript:  "while ! nc -z ilum-postgresql-hl.ilum-postgresql 5432 2>/dev/null; do echo 'Waiting for Postgres...'; sleep 5; done; echo 'Postgres is ready!'"
  Gitea : 
    Configuration : 
      serveur : 
        ROOT_URL : http : //gitea.example.com/external/gitea
      database: 
        DB_TYPE: Postgres 
        HOST:  "ilum-postgresql-hl.ilum-postgresql:5432"
        NAME: Gitea 
        UTILISATEUR : ilum 
        PASSWD:  « CHANGE-MOI, S’IL TE PLAÎT » 

ilum-marquez: 
  marquez: 
    db: 
      hôte :  "ilum-postgresql-0.ilum-postgresql-hl.ilum-postgresql"

# Disable bundled dependencies
mongodb: 
  Activé :  faux 
Kafka : 
  Activé :  faux 
minio : 
  Activé :  faux 
postgresql: 
  Activé :  faux 

# Above-default modules
ilum-sql : 
  Activé :  vrai 

ilum-hive-metastore: 
  Activé :  vrai 
  storage: 
    metastore : 
      warehouse:  "s3a://ilum-data/"
    type :  « S3 » 
    S3 : 
      hôte :  "ilum-minio.ilum-minio"
      port :  9000 
      accessKey:  "<your-s3-access-key>"
      secretKey:  "<your-s3-secret-key>"
  postgresql: 
    hôte :  "ilum-postgresql-hl.ilum-postgresql"
    port :  5432 
    database: metastore 
    Auth : 
      nom d’utilisateur : ilum 
      mot de passe :  « CHANGE-MOI, S’IL TE PLAÎT » 

# Ilum add-ons
postgresExtensions: 
  hôte :  "ilum-postgresql-hl.ilum-postgresql"
  port :  5432 
  databasesToCreate:  marquez, airflow, metastore , mlflow , mlflow_auth, superset, Gitea , n8n , hydre , kestra
  Auth : 
    nom d’utilisateur : ilum 
    mot de passe :  « CHANGE-MOI, S’IL TE PLAÎT » 

minioExtensions: 
  hôte : http : ilum - minio.ilum- minio : 9000 

Option 2: Enterprise Production Stack​

Comprehensive setup with monitoring, logging aggregation, and more optional modules. Extra enabled modules:

• ilum-sql
• ilum-hive-metastore
• ilum-marquez (lineage)
• superset
• mlflow
• kube-prometheus-stack
• Loki & Promtail (log aggregation)

Minimal needed values file taking into account the components deployment described above. For more detailed configuration you can examine dedicated charts, for example ilum-core

# enterprise-production-values.yaml
global : 
  lineage: 
    Activé :  vrai 
  logAggregation: 
    Activé :  vrai 
    loki: 
      Activé :  faux 
      URL : http : ilum - loki- gateway.ilum- logs
    promtail: 
      Activé :  faux 

ilum-core : 
  sécurité : 
    jwt: 
      privateKey:  Key generated as described in Security- keys section
      publicKey:  Key generated as described in Security- keys section
  SQL : 
    Activé :  vrai 
  metastore : 
    Activé :  vrai 
    type : ruche 
  mongo: 
    URI :  "mongodb://ilum-mongodb-0.ilum-mongodb-headless.ilum-mongodb:27017,ilum-mongodb-1.ilum-mongodb-headless.ilum-mongodb:27017/ilum?replicaSet=rs0"
  communication: 
    type : Kafka 
  Kafka : 
    address:  "ilum-kafka-controller-0.ilum-kafka-controller-headless.ilum-kafka:9092,ilum-kafka-controller-1.ilum-kafka-controller-headless.ilum-kafka:9092,ilum-kafka-controller-2.ilum-kafka-controller-headless.ilum-kafka:9092"
  minio : 
    statusProbe: 
      baseUrl:  "http://ilum-minio.ilum-minio:9000"
  kubernetes: 
    storage: 
      type : S3 
    S3 : 
      hôte :  "ilum-minio.ilum-minio"
      port :  9000 
      accessKey:  "<your-s3-access-key>"
      secretKey:  "<your-s3-secret-key>"

Gitea : 
  initPreScript:  "while ! nc -z ilum-postgresql-hl.ilum-postgresql 5432 2>/dev/null; do echo 'Waiting for Postgres...'; sleep 5; done; echo 'Postgres is ready!'"
  Gitea : 
    Configuration : 
      serveur : 
        ROOT_URL : http : //gitea.example.com/external/gitea
      database: 
        DB_TYPE: Postgres 
        HOST:  "ilum-postgresql-hl.ilum-postgresql:5432"
        NAME: Gitea 
        UTILISATEUR : ilum 
        PASSWD:  « CHANGE-MOI, S’IL TE PLAÎT » 

ilum-marquez: 
  marquez: 
    db: 
      hôte :  "ilum-postgresql-0.ilum-postgresql-hl.ilum-postgresql"

# Disable bundled dependencies
mongodb: 
  Activé :  faux 
Kafka : 
  Activé :  faux 
minio : 
  Activé :  faux 
postgresql: 
  Activé :  faux 

# Above-default modules
ilum-sql : 
  Activé :  vrai 

ilum-hive-metastore: 
  Activé :  vrai 
  storage: 
    metastore : 
      warehouse:  "s3a://ilum-data/"
    type :  « S3 » 
    S3 : 
      hôte :  "ilum-minio.ilum-minio"
      port :  9000 
      accessKey:  "<your-s3-access-key>"
      secretKey:  "<your-s3-secret-key>"
  postgresql: 
    hôte :  "ilum-postgresql-hl.ilum-postgresql"
    port :  5432 
    database: metastore 
    Auth : 
      nom d’utilisateur : ilum 
      mot de passe :  « CHANGE-MOI, S’IL TE PLAÎT » 

# Ilum add-ons
postgresExtensions: 
  hôte :  "ilum-postgresql-hl.ilum-postgresql"
  port :  5432 
  databasesToCreate:  marquez, metastore , mlflow , mlflow_auth, superset, Gitea 
  Auth : 
    nom d’utilisateur : ilum 
    mot de passe :  « CHANGE-MOI, S’IL TE PLAÎT » 

minioExtensions: 
  hôte : http : ilum - minio.ilum- minio : 9000 

superset: 
  Activé :  vrai 
  supersetNode: 
    connections: 
      db_host:  "ilum-postgresql-hl.ilum-postgresql"
      db_port:  "5432"
      db_user: ilum 
      db_pass:  « CHANGE-MOI, S’IL TE PLAÎT » 
      db_name:  superset

mlflow : 
  Activé :  vrai 
  externalS3: 
    hôte :  "ilum-minio.ilum-minio"
  externalDatabase: 
    dialectDriver:  "postgresql"
    hôte :  "ilum-postgresql-hl.ilum-postgresql"
    port :  5432 
    utilisateur : ilum 
    database: mlflow 
    authDatabase:  mlflow_auth
    existingSecret:  "ilum-postgresql"
    existingSecretPasswordKey:  "postgres-password"

Helm Values Configuration​

Complete Production Values Template​

Reference the official Helm chart values at: https://artifacthub.io/packages/helm/ilum/ilum?modal=values

Ilum AIO Installation​

Step 1: Verify Dependencies​

# Check MongoDB
kubectl get pods -n ilum-mongodb
kubectl logs -f mongodb-0 -n ilum-mongodb

# Check Kafka
kubectl get pods -n ilum-kafka
kubectl logs -f kafka-0 -n ilum-kafka

# Check MinIO
kubectl get pods -n ilum-minio
kubectl logs -f minio-0 -n ilum-minio

# Check PostgreSQL
kubectl get pods -n ilum-postgresql
kubectl logs -f postgresql-primary-0 -n ilum-postgresql

Step 2: Deploy Ilum​

Ilum in defragmented deployment needs ilum-miniosecret

kubectl -n ilum create secret generic ilum-minio \
  --from-literal=root-user=<your-s3-access-key> \
  --from-literal=root-password=<your-s3-secret-key>

ilum-postgresqlsecret

kubectl -n ilum create secret generic ilum-postgresql \
--from-literal=password=CHANGEMEPLEASE \
--from-literal=postgres-password=CHANGEMEPLEASE

Installer Ilum

helm install ilum ilum/ilum \ 
  --namespace ilum \
  --values production-values.yaml

# Monitor deployment
kubectl get pods -n ilum -w

Post-Installation Configuration​

1. Verify Installation​

# Check all pods
kubectl get pods --all-namespaces | grep ilum

# Check services
kubectl get services --all-namespaces | grep ilum

# Check ingress (if enabled)
kubectl get ingress --all-namespaces

2. Access Ilum UI​

# Port forward (for testing)
kubectl port-forward svc/ilum-ui 9777:9777 -n ilum

# Or access via ingress
http://ilum.company.com

# Or access via NodePort
kubectl get svc
http://K8S_NODE_ADDRESS:ILUM_UI_NODEPORT

Dépannage ​

Erreurs d’extraction d’images ​

Lors de l’installation d’Ilum sur votre cluster, Helm extraira des images Docker, qui peuvent atteindre 10 Go, en fonction des modules supplémentaires que vous activez. Par conséquent, avec une connexion Internet lente, vous pouvez rencontrer des erreurs de délai d’extraction d’image si le temps de téléchargement de l’image dépasse le délai d’expiration configuré. Pour résoudre ce problème, vous pouvez :

1. Extrayez l’image Docker manuellement en exécutant :

Minikube SSH Docker Pull Image 
# par exemple 
Minikube SSH Docker pull ilum/core-6.1.3 

2. Modifiez le délai d’extraction de l’image dans vos configurations Kubernetes comme suit :

minikube start --extra-config=kubelet.runtime-request-timeout=5m 

ou comme ceci :

minikube start --extra-config=kubelet.image-pull-progress-deadline=5m 

Mots de passe / informations d’identification par défaut ​

Ilum est livré avec des informations d’identification prédéfinies pour divers modules afin de simplifier la configuration et les tests initiaux. Cependant, pour Déploiements en production C’est vrai essentiel pour modifier ces informations d’identification par défaut pour assurer la sécurité et empêcher tout accès non autorisé.

Informations d’identification par défaut ​

Informations d’identification de la base de données (à usage interne) ​