Vai al contenuto principale

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.

Sommario​

Panoramica​

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

  • Enhanced Security: Namespace-level isolation and RBAC policies
  • Gestione delle risorse: Independent resource quotas and limits
  • Operational Excellence: Simplified maintenance and upgrades
  • Compliance: Meeting organizational separation requirements
  • Scalabilità: 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

Prerequisiti di 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:
    • Motore di Google Kubernetes (GKE)
    • Servizio Kubernetes elastico Amazon (EKS)
    • Servizio Azure Kubernetes (servizio Azure Kubernetes)
    • DigitalOcean Kubernetes
    • Red Hat OpenShift

Minimum Suggested Requirements​

ComponentRequirement
Kubernetes Version1.20+
CPU8 cores minimum, 16+ recommended
Memoria16GB minimum, 32GB+ recommended

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.

Architettura​

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-api con 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 store per 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 Abilitato in Ilum per impostazione predefinita.

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=Falso al comando di installazione.

MongoDB​

MongoDB is supported as a legacy metadata store per 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 funge da livello di comunicazione di Ilum, facilitando l'interazione tra i lavori Ilum-Core e Spark, oltre a tra diverse istanze Ilum-Core quando scalate. È fondamentale garantire che i broker Apache Kafka siano accessibili da entrambi Processi Ilum-Core e Spark, soprattutto quando i processi Spark vengono avviati in un cluster Kubernetes diverso.

Ilum utilizza Kafka per portare avanti la comunicazione utilizzando diversi argomenti, tutti creati durante l'avvio di Ilum. Pertanto, gli utenti Non è necessario gestire questi argomenti manualmente.

MinIO​

Ilum utilizza MinIO come livello di archiviazione per i componenti dell'applicazione Spark. Tutti i file (inclusi jar, configurazioni, dati necessari, necessari per il funzionamento dei componenti Spark (driver, esecutori) vengono memorizzati e resi disponibili per il download tramite MinIO.

MinIO implementa l'interfaccia S3, che consente anche di memorizzare i dati di input/output.

Ilum-Livio-proxy​

Il proxy Ilum-Livy è la nostra implementazione di Livy Api, che integra il codice spark con i gruppi Ilum in servizi come Jupyter, Zeppelin, Airflow

Ilum Livy-proxy è abilitato in Ilum per impostazione predefinita.

Nel caso in cui si desideri aggiungere o rimuovere Ilum-Livy-proxy, è possibile utilizzare ilum-livy-proxy.enabled helm valore per gestirlo. Per esempio: --set ilum-livy-proxy.enabled=falso per disabilitarlo.

Per saperne di più su Ilum-Livy-proxy qui

Giove​

Jupyter è un sofisticato ambiente di sviluppo Notebook che consente di avere codice, grafici, spiegazioni e altro in un unico documento eseguibile.

Giove è abilitato in Ilum per impostazione predefinita.

Tuttavia, nel caso in cui si desideri controllare se è abilitato o meno, è possibile utilizzare helm value ilum-jupyter.enabled. Ad esempio, è possibile aggiungere --set ilum-jupyter.enabled=falso al comando di installazione per disabilitarlo.

Tieni presente che Jupyter utilizza Ilum-Livio-proxy per l'integrazione con i Gruppi Ilum. Pertanto, dovresti abilitarlo anche: --set ilum-livy-proxy.enabled=vero

Se si vuole accedere all'interfaccia utente di Jupyter, è possibile farlo nei seguenti modi:

  • utilizzando l'interfaccia utente di Ilum: vai su Moduli > Jupyter
  • Configurazione di un ingresso
  • Utilizzo del comando port-forward kubectl port-forward svc/ilum-jupyter 8888:8888

Per saperne di più su Jupyter qui

Apache Zeppelin​

Zeppelin è un notebook - sofisticato ambiente di sviluppo che ti consente di avere codice, grafici, spiegazioni e altro in un unico documento eseguibile.

Tieni presente che il notebook Zeppelin non è incluso nel pacchetto ilum per impostazione predefinita. Se si desidera eseguire questo servizio, aggiungere --set ilum-zeppelin.enabled=vero al comando di installazione.

Tenete presente che Zeppelin fa uso di Ilum-Livio-proxy per l'integrazione con i Gruppi Ilum. Pertanto, dovresti abilitarlo anche: --set ilum-livy-proxy.enabled=vero

Se vuoi accedere all'interfaccia utente di Zeppelin, il modo migliore per farlo è configurare un ingresso o utilizzare il comando port-forward Kubectl Port-Forward SVC/ILUM-Zeppelin 8080:8080

Leggi tutto su Zeppelin qui

Hive 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 Esplora tabelle pagina.

Informazioni

Per impostazione predefinita, il metastore Hive non è abilitato in Ilum.

To enable the Hive Metastore bundled instance, set the following values in your Helm installation command:

ilum-core:
  metastore:
    Abilitato: vero
    digitare: alveare

ilum-hive-metastore:
  Abilitato: vero
nota

Hive Metastore uses Database PostgreSQL to store metadata. You can read about Postgres in Ilum sotto.

Progetto 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.

Informazioni

Project Nessie is not enabled in Ilum by default. To enable it, set the following values in your Helm installation command:

ilum-core:
  metastore:
    Abilitato: vero
    digitare: Nessie

Nessie:
  Abilitato: vero

Ilum SQL (Kyuubi Gateway)​

nota

Ilum SQL non è abilitato in Ilum per impostazione predefinita.

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, Trino, DuckDBo 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=vero per abilitare l'host di esecuzione SQL e --set ilum-core.sql.enabled=vero to enable the SQL features inside Ilum itself.

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

Trino​

Nota: Trino is not enabled in Ilum by default. To enable it, add --set trino.enabled=vero 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 support is available for Azienda deployments as a Beta feature. Flink is exposed through the Kyuubi SQL gateway for low-latency stream processing. Contact Ilum for enablement details.

n8n​

Nota: n8n non è abilitato in Ilum per impostazione predefinita. Per abilitarlo, aggiungere --set ilum-n8n.enabled=vero per abilitare una distribuzione N8N integrata.

n8n è una piattaforma di automazione del flusso di lavoro fair-code con funzionalità di intelligenza artificiale native.

Maggiori informazioni a riguardo leggi il Pagina n8n.

Flusso d'aria 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.

nota

Airflow is not enabled in the Ilum package by default. To deploy Airflow, add --set airflow.enabled=vero al comando di installazione.

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

Apache Livio

Airflow can leverage Ilum’s Livy proxy to easily create jobs within Ilum. For more details, see the Livy proxy section above.

Marquez​

Marquez is an open-source metadata management tool that focuses on capturing, aggregating, and visualizing the lineage of data assets within an organization’s data ecosystem. It tracks how datasets are produced and consumed by different jobs and provides a central view of these dependencies.

Si prega di notare che Marquez non è incluso nel pacchetto Ilum per impostazione predefinita. Se si desidera eseguire questo servizio, Aggiungere --set global.lineage.enabled=vero al comando di installazione.

Tenete conto del fatto che Marquez si avvale di Database PostgreSQL per memorizzare i metadati. Puoi leggere a riguardo sotto.

Additionally, if you wish to use Marquez’s web client instead of Ilum’s UI, enable the default web client with --set ilum-marquez.web.enabled=vero e impostare uno dei metodi di accesso:

  • Utilizzare il comando port-forward kubectl port-forward svc/ilum-marquez-web 9444:9444
  • Configurare un ingresso

Leggi tutto su Marquez e Ilum Lineage qui

OpenMetadata​

OpenMetadata is an open-source data catalog and governance platform. In Ilum it serves as the catalog of record: tables, schemas, column-level lineage, classification tags, glossary terms, domains, and data products are all populated through OpenLineage events and ingestion pipelines. It complements Marquez, which remains a lightweight lineage-event debugging surface.

OpenMetadata is opt-in and disabled by default. A plain installation brings up zero OpenMetadata resources. Enabling the full catalog stack requires four flags:

helm install ilum ilum/ilum \
  --mettere openmetadata.enabled=vero \
  --mettere openmetadata-dependencies.enabled=vero \
  --mettere openmetadataBootstrap.enabled=vero \
  --mettere ilum-core.job.openLineage.openmetadata.enabled=vero

openmetadata.enabled deploys the OpenMetadata server (a small Ilum fork of the 1.12.5 image that fixes OpenLineage auto-create reliability). openmetadata-dependencies.enabled brings up its backing OpenSearch e PostgreSQL. openmetadataBootstrap.enabled runs the post-install Job that registers the Hive, Delta Lake, MinIO, Superset, and OpenLineage services and seeds governance metadata. ilum-core.job.openLineage.openmetadata.enabled adds the Spark-to-OpenMetadata OpenLineage transport leg so engine lineage reaches the catalog.

Take into account that OpenMetadata makes use of a Database PostgreSQL and an OpenSearch index; both are provisioned by openmetadata-dependencies. When cookie-based UI auth is enabled, access to the embedded OpenMetadata view is gated by the access_openmetadata Nginx map.

Read more about OpenMetadata in Ilum qui.

Kestra​

Kestra è un open source Piattaforma di orchestrazione dei dati progettata per l'orchestrazione e l'automazione dei dati pipeline e flussi di lavoro aziendali. Puoi leggere a riguardo qui.

Informazioni

Kestra non è abilitato in Ilum per impostazione predefinita. Per abilitarlo, aggiungere --set kestra.enabled=vero al comando di installazione.

nota

Kestra utilizza Database PostgreSQL per memorizzare i dati relativi ai lavori e alle attività e Minio for general file storage.

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 Pagina della documentazione.

Informazioni

Mage is not enabled in Ilum by default. To enable it, add --set mageai.enabled=true al comando di installazione.

nota

Ilum deploys Mage OSS, which is the open-source version of Mage, and does not include the commercial features available in Mage Pro (Cloud).

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 Pagina della documentazione.

Informazioni

NiFi is not enabled in Ilum by default. To enable it, add --set nifi.enabled=true al comando di installazione.

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 Pagina della documentazione.

Informazioni

Streamlit is not enabled in Ilum by default. To enable it, add --set streamlit.enabled=true al comando di installazione.

Additionally, can provide a docker image with your streamlit application running in it. To see how to do it, visit our Pagina della documentazione.

Cubo Prometeo Pila​

Kube Prometheus Stack include Prometheus, Grafana e altri strumenti per il monitoraggio dell'infrastruttura dati

Tieni presente che Kube Prometheus Stack non è incluso nel pacchetto ilum per impostazione predefinita. Se si desidera eseguire questo servizio, aggiungere --set kube-prometheus-stack.enabled=true al comando di installazione.

Se si sta aggiornando una carta Ilum Helm esistente che in precedenza lo faceva non se lo stack Kube Prometheus è abilitato, è necessario installare le definizioni delle risorse personalizzate (CRD) Prometheus necessarie prima di procedere con l'aggiornamento. A tale scopo, eseguire i comandi seguenti:

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

Se si desidera accedere all'interfaccia utente di Prometheus, il modo migliore per farlo è configurare un ingresso o utilizzare il comando port-forward Kubectl Port-Forward SVC/Prometheus 9090:9090

Se si desidera accedere all'interfaccia utente di Grafana, il modo migliore per farlo consiste nel configurare un ingresso o nell'utilizzare il comando port-forward kubectl port-forward svc/ilum-grafana 8080:80

Loki e Promtail​

Loki viene utilizzato per raccogliere e gestire i registri dell'infrastruttura dati. Promtail è usato come agente che spinge i registri in Loki

Si prega di essere consapevoli che Loki non è abilitato in Ilum per impostazione predefinita. Se si desidera eseguire questo servizio, aggiungere --set global.logAggregation.loki.enabled=true al comando di installazione.

Promtail anche non è abilitato in Ilum per impostazione predefinita. Per abilitarlo aggiungere --set global.logAggreagtion.promtail.enabled=true al comando di installazione

Se si desidera accedere a Loki ed eseguire le query Loki, è possibile configurare un ingresso o utilizzare il comando port-forward kubectl port-forward svc/ilum-loki-read 3100:3100 per le query di lettura e kubectl port-forward svc/ilum-loki-write 3100:3100 per le query di scrittura. È inoltre possibile utilizzare servizio ilum-loki-gateway Per collegare Grafana a 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
  • Sicurezza: 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:

ComponentMinimum ReplicasRecommendedHelm ValueNotes
ilum-core23ilum-core.replicaCount: 3Stateless; requires Kafka communication mode for HA
ilum-api22ilum-api.replicaCount: 2Stateless module-management microservice; cluster-scoped RBAC
PostgreSQL23postgresql.replicaCount: 3Primary metadata store; primary + standby with streaming replication
MongoDB (legacy)33mongodb.replicaCount: 3Only for legacy deployments; replica set with automatic failover
Apache Kafka33kafka.replicaCount: 3Required for HA communication; minimum 3 for quorum
MinIO44minio.replicas: 4Erasure coding requires minimum 4 nodes
Hive Metastore22ilum-hive-metastore.replicaCount: 2Stateless; connects to shared PostgreSQL backend
Kyuubi (ilum-sql)22ilum-sql.replicaCount: 2SQL gateway; stateless

Example Helm values for a fully HA deployment:

ilum-core:
  replicaCount: 3

mongodb:
  replicaCount: 3

Kafka:
  replicaCount: 3

minio:
  Repliche: 4

postgresql:
  replicaCount: 3
avvertimento

High Availability for ilum-core requires Apache Kafka as the communication type. The default gRPC communication does not support HA. Set ilum-core.communication.type: kafka to enable HA mode.

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:
                - chiave: app
                  operatore: In
                  valori:
                    - ilum-nucleo
            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: "vero"
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
gentile: HorizontalPodAutoscaler
Metadati:
  nome: ilum-nucleo-hpa
Spec:
  scaleTargetRef:
    apiVersion: applicazioni/v1
    gentile: Spiegamento
    nome: ilum-nucleo
  minReplicas: 2
  maxReplicas: 5
  Metriche:
    - digitare: Risorsa
      resource:
        nome: cpu
        bersaglio:
          digitare: 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.

mancia

Combine Spark dynamic allocation with cluster autoscaling for full elasticity: Spark scales executors based on workload, and the cluster scales nodes based on pending pods.

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​

# 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 spazio dei nomi 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

Chiavi di sicurezza​

Questa applicazione utilizza token Web JSON (JWT) a scopo di autenticazione. Per impostazione predefinita, l'applicazione utilizza una chiave RSA , che viene generata in modo casuale in fase di esecuzione, per firmare questi token.

Nella sua configurazione standard, l'applicazione crea una nuova coppia di chiavi RSA ogni volta che viene avviata. Questo approccio Semplifica lo sviluppo e il test locale gestendo automaticamente il processo di generazione delle chiavi. Tuttavia, deve essere ha sottolineato che questo approccio non è adatto a un ambiente di produzione.

Il problema principale con l'utilizzo di chiavi generate casualmente in un ambiente di produzione è la mancanza di persistenza. Ogni volta l'applicazione si riavvia, genera una nuova coppia di chiavi RSA, invalidando tutti i token emessi in precedenza. Ciò potrebbe portare a Una disconnessione improvvisa e imprevista per tutti gli utenti, che interrompe l'esperienza utente e potenzialmente porta alla perdita di dati.

Generare la chiave privata​

Per un ambiente di produzione, una coppia di chiavi stabile e sicura deve essere generata manualmente e utilizzata in modo coerente. Questo Garantisce che i token rimangano validi in più riavvii dell'applicazione, fornendo così un'esperienza utente coerente.

È possibile generare manualmente una coppia di chiavi RSA utilizzando strumenti come OpenSSL. Un comando comune per generare una chiave privata RSA a 2048 bit è il seguente:

openssl genpkey -algoritmo RSA \
    -pkeyopt rsa_keygen_bits:2048 \
    -pkeyopt rsa_keygen_pubexp:65537 | \
  openssl pkcs8 -topk8 -nocrypt -outform pem > chiave-privata.p8

Il contenuto della chiave privata dovrebbe essere simile al seguente:

-----INIZIA LA CHIAVE PRIVATA-----
MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCsRnE83rm6BJya
nTyzVqX0SG+D4zBjkyWsOmGG+CoDdgQ6Z8AaocmnjP1SbRykQsQSMf6SeW+fdpH+
ccmzuHe7pZIa2o2Mg8xbk/UszJDaPztwoQbUt/2gHi/rZP8cIVkquzhnN/yxrMls
...
-----TERMINA LA CHIAVE PRIVATA-----

Per utilizzare la chiave privata come impostazione ilum-core.security.jwt.privateKey, rimuovere l'intestazione e il piè di pagina dalla chiave.

Generare la chiave pubblica​

Per generare la chiave pubblica corrispondente, utilizzare:

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

Il contenuto della chiave pubblica dovrebbe essere simile al seguente:

-----INIZIA LA CHIAVE PUBBLICA-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArEZxPN65ugScmp08s1al
9Ehvg+MwY5MlrDphhvgqA3YEOmfAGqHJp4z9Um0cpELEEjH+knlvn3aR/nHJs7h3
u6WSGtqNjIPMW5P1LMyQ2j87cKEG1Lf9oB4v62T/HCFZKrs4Zzf8sazJbMN3E/mJ
...
-----FINE CHIAVE PUBBLICA-----

Per utilizzare la chiave pubblica come impostazione ilum-core.security.jwt.publicKey, rimuovere l'intestazione e il piè di pagina dalla chiave.

Authentication Methods​

Ilum come provider di identità​

Ilum può essere distribuito come provider di identità. Con questa funzione, puoi gestire gli utenti esclusivamente all'interno di Ilum e autenticarli su altri microservizi come Airflow, Superset, Grafana, Givea e Minio.

Per abilitare l'Identity Provider di Ilum, aggiungi i seguenti flag: --set global.security.hydra.enabled=vero e --set global.security.hydra.uiUrl=.

Per ulteriori informazioni sulla configurazione del provider di identità, visitare il sito Web questa pagina

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 al comando di installazione.

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

Dependency Deployment​

Nota: 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 Aggiungere bitnami https://charts.bitnami.com/bitnami
Aggiornamento del repo Helm

2. Create MongoDB Values File​

# mongodb-values.yaml
immagine:
  registry: docker.io
  deposito: ilum/mongodb
  cartellino: 6.0.5
fullnameOverride: "ilum-mongodb"
architecture: "replicaset"
Auth:
  Abilitato: falso
volumePermissions:
  Abilitato: vero

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:
  Abilitato: falso

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 Aggiungere bitnami https://charts.bitnami.com/bitnami
Aggiornamento del repo Helm

2. Create Kafka Values File​

# kafka-values.yaml
extraConfig: |
  auto.create.topics.enable=false
  message.max.bytes=20000000
fullnameOverride: "ilum-kafka"
listeners:
  cliente:
    protocollo: 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:
    digitare: 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 Aggiungere bitnami https://charts.bitnami.com/bitnami
Aggiornamento del repo 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
  - nome: MINIO_IDENTITY_OPENID_CONFIG_URL
    valore: "ILUM_UI_PROTOCOL://ILUM_UI_DOMAIN/external/hydra/.well-known/openid-configuration"
  - nome: MINIO_IDENTITY_OPENID_CLIENT_ID
    valore: "HYDRA_CLIENT_ID"
  - nome: MINIO_IDENTITY_OPENID_CLIENT_SECRET
    valore: "HYDRA_CLIENT_SECRET"
  - nome: MINIO_IDENTITY_OPENID_REDIRECT_URI
    valore: "ILUM_UI_PROTOCOL://ILUM_UI_DOMAIN/external/minio/oauth_callback"
  - nome: MINIO_IDENTITY_OPENID_SCOPES
    valore: "openid,profile,email"
  - nome:  MINIO_IDENTITY_OPENID_CLAIM_NAME
    valore: "minio_policies"
 # end of hydra related environment variables
fullnameOverride: "ilum-minio"
defaultBuckets: "ilum-files, ilum-data, ilum-tables, ilum-mlflow, ilum-kestra"
Auth:
  rootUser: ""
  rootPassword: ""
persistence:
  grandezza: 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:
  Abilitato: falso

ilum-core:
  minio:
    statusProbe:
      baseUrl: "http://ilum-minio.ilum-minio:9000"
  kubernetes:
    storage:
      digitare: S3
    S3:
      ospite: "ilum-minio.ilum-minio"
      porto: 9000
      accessKey: ""
      secretKey: ""

# If hive metastore is deployed with minio as the storage
ilum-hive-metastore:
  storage:
    metastore:
      warehouse: "s3a://ilum-data/"
    digitare: "S3"
    S3:
      ospite: "ilum-minio.ilum-minio"
      porto: 9000
      accessKey: ""
      secretKey: ""

# If trino is deployed with minio as the storage
Trino:
  Cataloghi:
    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=
      s3.aws-secret-key=

# If Loki is deployed with s3 as the storage
loki:
  loki:
    auth_enabled: falso
    storage:
      bucketNames:
        chunks: ilum-file
        ruler: ilum-file
        Admin: ilum-file
      digitare: S3
      S3:
        Endpoint: http (in inglese)://ilum-minio.ilum-minio:9000
        region: us-A est-1
        secretAccessKey: -S3-segreto-chiave>
        accessKeyId: -S3-accesso-chiave>
        s3ForcePathStyle: vero
        insecure: vero

# If minio is deployed
minioExtensions:
  ospite: http (in inglese)://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: ""
    - name: MINIO_PASSWORD
      value: ""
    - name: MINIO_ENDPOINT
      value: "http://ilum-minio.ilum-minio:9000"

# If mlflow is deployed
Flusso ML:
  externalS3:
    ospite: "ilum-minio.ilum-minio"

# If kestra is deployed with minio as the storage
kestra:
  configuration:
    kestra:
      storage:
        digitare: minio
        minio:
          Endpoint: ilum-minio.ilum-minio
          porto: 9000
          secure: falso
          accessKey: -S3-accesso-chiave>
          secretKey: -S3-segreto-chiave>
          region: "predefinito"
          bucket: ilum-kestra

PostgreSQL Deployment​

Deploy PostgreSQL for metadata storage:

1. Add Bitnami Repository​

helm repo Aggiungere bitnami https://charts.bitnami.com/bitnami
Aggiornamento del repo Helm

2. Create PostgreSQL Values File​

# postgresql-values.yaml
fullnameOverride: ilum-postgresql
Auth:
  postgresPassword: "CAMBIAMIPER favore"
  nome utente: ilum
  parola d’ordine: "CAMBIAMIPER favore"

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:
  Abilitato: falso

#Postgres extensions for databases auto-creation
postgresExtensions:
  ospite: "ilum-postgresql-hl.ilum-postgresql"
  porto: 5432
  databasesToCreate: marquez,airflow,metastore,Flusso ML,mlflow_auth,superset,Gitea,n8n,idra,kestra
  Auth:
    nome utente: ilum
    parola d’ordine: "CAMBIAMIPER favore"

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

# If ilum-hive-metastore is deployed
ilum-hive-metastore:
  postgresql:
    ospite: "ilum-postgresql-hl.ilum-postgresql"
    porto: 5432
    database: metastore
    Auth:
      nome utente: ilum
      parola d’ordine: "CAMBIAMIPER favore"

# If lineage is enabled
ilum-marquez:
  marquez:
    db:
      immagine: "Bitnami/PostgreSQL:16"
      ospite: "ilum-postgresql-0.ilum-postgresql-hl.ilum-postgresql"
      porto: 5432
      nome: marquez
      utente: ilum
      parola d’ordine: "CAMBIAMIPER favore"

# 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:
    configurazione:
      server:
        ROOT_URL: http (in inglese)://gitea.example.com/external/gitea
      database:
        DB_TYPE: postgres
        HOST: "ilum-postgresql-hl.ilum-postgresql:5432"
        NAME: Gitea
        UTENTE: ilum
        PASSWD: "CAMBIAMIPER favore"

# If airflow is deployed with postgres as metadata connection
airflow:
  dati:
    metadataConnection:
      utente: postgres
      passare: "CAMBIAMIPER favore"
      protocollo: postgresql
      ospite: "ilum-postgresql-hl.ilum-postgresql"
      porto: 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: "CAMBIAMIPER favore"
      db_name: superset

# If mlflow is deployed with postgres as the external database
Flusso ML:
  externalDatabase:
    dialectDriver: "postgresql"
    ospite: "ilum-postgresql-hl.ilum-postgresql"
    porto: 5432
    utente: ilum
    database: Flusso ML
    authDatabase: mlflow_auth
    existingSecret: "ilum-postgresql"
    existingSecretPasswordKey: "postgres-password"

# If n8n is deployed
n8n:
  db:
    digitare: postgresdb
  externalPostgresql:
    ospite: "ilum-postgresql-hl.ilum-postgresql"
    nome utente: "ilum"
    parola d’ordine: "CAMBIAMIPER favore"
    database: "n8n"

# If kestra is deployed
kestra:
  configuration:
    datasources:
      postgres:
        URL: "jdbc:postgresql://ilum-postgresql-hl.ilum-postgresql:5432/kestra"
        driverClassName: "org.postgresql.Driver"
        nome utente: ilum
        parola d’ordine: "CAMBIAMIPER favore"
  initContainers:
    - nome: wait-per-postgres
      immagine: "Bitnami/PostgreSQL:16"
      command:
        - /bin/bash
      argomenti:
        - -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
          fatto
          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 Aggiungere prometheus-community https://prometheus-community.github.io/helm-charts
Aggiornamento del repo Helm

2. Create Kube-Prometheus-Stack Values File​

# kps-values.yaml
nameOverride: "ilum-kps"
kubeStateMetrics:
  Abilitato: falso
nodeExporter:
  Abilitato: falso
alertmanager:
  Abilitato: falso
grafana:
  nameOverride: "ilum-grafana"
  grafana.ini:
    server:
      root_url: "%(protocol)s://%(domain)s:%(http_port)s/external/grafana"
      serve_from_sub_path: "vero"
    auth.generic_oauth:
      Abilitato: falso
      nome: Ilum
      allow_sign_up: vero
      login_attribute_path: userId
      email_attribute_name: E-mail
      role_attribute_path: contiene(grafana_roles, 'Amministratore') && 'Amministratore' || contiene(grafana_roles, 'Editore') && 'Editore' || contiene(grafana_roles, 'Viewer') && 'Spettatore'
      role_attribute_strict: vero
  adminPassword: Admin
  sidecar:
    dashboards:
      folderAnnotation: "grafana_folder"
      provider:
        foldersFromFilesStructure: "vero"

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
gentile: PodMonitor
Metadati:
  nome: ilum-pods-monitor
  Namespace: ilum-kps
  Etichette:
    ilum.prometheus: "vero"
Spec:
  selettore:
    matchLabels:
      ilum.prometheus: "vero"
  podMetricsEndpoints:
    - interval: 5s
      porto: http (in inglese)
      sentiero: /actuator/prometheus
  namespaceSelector:
    matchNames:
      - ilum

Spark Driver Pods Monitor

apiVersion: monitoring.coreos.com/v1
gentile: PodMonitor
Metadati:
  nome: ilum-autista-pods-monitor
  Namespace: ilum-kps
  Etichette:
    ilum.resourceType: autista
Spec:
  selettore:
    matchLabels:
      ilum.resourceType: autista
  podMetricsEndpoints:
    - interval: 5s
      porto: scintilla-Ui
      sentiero: /metrics/executors/prometheus/
    - interval: 5s
      porto: scintilla-Ui
      sentiero: /metrics/prometheus/
  namespaceSelector:
    any: vero

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

Deploy Loki & Promtail for logs aggregation:

1. Add Grafana Repository​

helm repo Aggiungere grafana https://grafana.github.io/helm-charts
Aggiornamento del repo Helm

2. Create Loki and Promtail Values File​

# loki-values.yaml
nameOverride: ilum-loki
monitoraggio:
  selfMonitoring:
    Abilitato: falso
    grafanaAgent:
      installOperator: falso
    lokiCanary:
      Abilitato: falso
test:
  Abilitato: falso
loki:
  auth_enabled: falso
  storage:
    bucketNames:
      chunks: ilum-file
      ruler: ilum-file
      Admin: ilum-file
    digitare: S3
    S3:
      Endpoint: http (in inglese)://ilum-minio.ilum-minio:9000
      region: us-A est-1
      secretAccessKey: -S3-segreto-chiave>
      accessKeyId: -S3-accesso-chiave>
      s3ForcePathStyle: vero
      insecure: vero
  compactor:
    retention_enabled: vero
    deletion_mode: filtro-e-cancellare
    shared_store: S3
  limits_config:
    allow_deletes: vero
# promtail-values.yaml
configurazione:
  clients:
    - URL: http (in inglese)://ilum-loki-scrivere:3100/loki/api/v1/push
  snippets:
    pipelineStages:
      - match:
          selettore: '{ilum_logAggregation!="true"}'
          action: goccia
          drop_counter_reason: non_ilum_log
    extraRelabelConfigs:
      - action: per etichetteper mappa
        regex: "__meta_kubernetes_pod_label_ilum(.*)"
        replacement: "ilum${1}"
      - action: per etichetteper mappa
        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​

globale:
  logAggregation:
    Abilitato: vero
    loki:
      Abilitato: falso
      URL: http (in inglese)://ilum-loki-gateway.ilum-logs
    promtail:
      Abilitato: falso

Pre-configured Stack Examples​

Nota: 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 o 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
globale:
  lineage:
    Abilitato: vero

ilum-core:
  sicurezza:
    jwt:
      privateKey: Key generated as described in Security-keys section
      publicKey: Key generated as described in Security-keys section
  SQL:
    Abilitato: vero
  metastore:
    Abilitato: vero
    digitare: alveare
  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:
    digitare: 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:
      digitare: S3
    S3:
      ospite: "ilum-minio.ilum-minio"
      porto: 9000
      accessKey: ""
      secretKey: ""

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:
    configurazione:
      server:
        ROOT_URL: http (in inglese)://gitea.example.com/external/gitea
      database:
        DB_TYPE: postgres
        HOST: "ilum-postgresql-hl.ilum-postgresql:5432"
        NAME: Gitea
        UTENTE: ilum
        PASSWD: "CAMBIAMIPER favore"

ilum-marquez:
  marquez:
    db:
      ospite: "ilum-postgresql-0.ilum-postgresql-hl.ilum-postgresql"

# Disable bundled dependencies
mongodb:
  Abilitato: falso
Kafka:
  Abilitato: falso
minio:
  Abilitato: falso
postgresql:
  Abilitato: falso

# Above-default modules
ilum-sql:
  Abilitato: vero

ilum-hive-metastore:
  Abilitato: vero
  storage:
    metastore:
      warehouse: "s3a://ilum-data/"
    digitare: "S3"
    S3:
      ospite: "ilum-minio.ilum-minio"
      porto: 9000
      accessKey: ""
      secretKey: ""
  postgresql:
    ospite: "ilum-postgresql-hl.ilum-postgresql"
    porto: 5432
    database: metastore
    Auth:
      nome utente: ilum
      parola d’ordine: "CAMBIAMIPER favore"

# Ilum add-ons
postgresExtensions:
  ospite: "ilum-postgresql-hl.ilum-postgresql"
  porto: 5432
  databasesToCreate: marquez,airflow,metastore,Flusso ML,mlflow_auth,superset,Gitea,n8n,idra,kestra
  Auth:
    nome utente: ilum
    parola d’ordine: "CAMBIAMIPER favore"

minioExtensions:
  ospite: http (in inglese)://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
  • Flusso ML
  • 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
globale:
  lineage:
    Abilitato: vero
  logAggregation:
    Abilitato: vero
    loki:
      Abilitato: falso
      URL: http (in inglese)://ilum-loki-gateway.ilum-logs
    promtail:
      Abilitato: falso

ilum-core:
  sicurezza:
    jwt:
      privateKey: Key generated as described in Security-keys section
      publicKey: Key generated as described in Security-keys section
  SQL:
    Abilitato: vero
  metastore:
    Abilitato: vero
    digitare: alveare
  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:
    digitare: 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:
      digitare: S3
    S3:
      ospite: "ilum-minio.ilum-minio"
      porto: 9000
      accessKey: ""
      secretKey: ""

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:
    configurazione:
      server:
        ROOT_URL: http (in inglese)://gitea.example.com/external/gitea
      database:
        DB_TYPE: postgres
        HOST: "ilum-postgresql-hl.ilum-postgresql:5432"
        NAME: Gitea
        UTENTE: ilum
        PASSWD: "CAMBIAMIPER favore"

ilum-marquez:
  marquez:
    db:
      ospite: "ilum-postgresql-0.ilum-postgresql-hl.ilum-postgresql"

# Disable bundled dependencies
mongodb:
  Abilitato: falso
Kafka:
  Abilitato: falso
minio:
  Abilitato: falso
postgresql:
  Abilitato: falso

# Above-default modules
ilum-sql:
  Abilitato: vero

ilum-hive-metastore:
  Abilitato: vero
  storage:
    metastore:
      warehouse: "s3a://ilum-data/"
    digitare: "S3"
    S3:
      ospite: "ilum-minio.ilum-minio"
      porto: 9000
      accessKey: ""
      secretKey: ""
  postgresql:
    ospite: "ilum-postgresql-hl.ilum-postgresql"
    porto: 5432
    database: metastore
    Auth:
      nome utente: ilum
      parola d’ordine: "CAMBIAMIPER favore"

# Ilum add-ons
postgresExtensions:
  ospite: "ilum-postgresql-hl.ilum-postgresql"
  porto: 5432
  databasesToCreate: marquez,metastore,Flusso ML,mlflow_auth,superset,Gitea
  Auth:
    nome utente: ilum
    parola d’ordine: "CAMBIAMIPER favore"

minioExtensions:
  ospite: http (in inglese)://ilum-minio.ilum-minio:9000

superset:
  Abilitato: vero
  supersetNode:
    connections:
      db_host: "ilum-postgresql-hl.ilum-postgresql"
      db_port: "5432"
      db_user: ilum
      db_pass: "CAMBIAMIPER favore"
      db_name: superset

Flusso ML:
  Abilitato: vero
  externalS3:
    ospite: "ilum-minio.ilum-minio"
  externalDatabase:
    dialectDriver: "postgresql"
    ospite: "ilum-postgresql-hl.ilum-postgresql"
    porto: 5432
    utente: ilum
    database: Flusso ML
    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-minio segreto

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-postgresql segreto

kubectl -n ilum create secret generic ilum-postgresql \
--from-literal=parola d’ordine=CAMBIAMIPER favore \
--from-literal=postgres-password=CAMBIAMIPER favore

Installa 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

Risoluzione dei problemi​

Errori di estrazione delle immagini​

Durante l'installazione di Ilum nel cluster, Helm estrarrà le immagini Docker, che possono avere dimensioni fino a 10 GB, a seconda dei moduli aggiuntivi abilitati. Di conseguenza, con una connessione Internet lenta, è possibile che si verifichino errori di timeout dell'estrazione dell'immagine se il tempo di download dell'immagine supera il timeout configurato. Per risolvere questo problema, puoi:

  1. Estrarre manualmente l'immagine Docker eseguendo:
minikube ssh docker pull image
# per esempio
minikube ssh docker pull ilum/core-6.1.3

  1. Modifica il timeout di estrazione dell'immagine nelle configurazioni di Kubernetes in questo modo:
minikube start --extra-config=kubelet.runtime-request-timeout=5m

o in questo modo:

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

Password/credenziali predefinite​

Ilum viene fornito con credenziali predefinite per vari moduli per semplificare la configurazione iniziale e il test. Tuttavia, per Distribuzioni di produzioneLo è Fondamentale per modificare queste credenziali predefinite per garantire la sicurezza e impedire l'accesso non autorizzato.

Credenziali predefinite​

ApplicazioneNome utente predefinitoPassword predefinita
Interfaccia utente di IlumAdminAdmin
Object Storage ConsoleAdminadmin12345
Flusso d'aria Web Interfaccia utenteAdminAdmin
Interfaccia utente SupersetAdminAdmin
Interfaccia utente Giteailumilum
GrafanaAdminAdmin

Credenziali del database (per uso interno)​

Banca datiNome utente predefinitoPassword predefinita
PostgreSQLpostgresCAMBIAMIPER favore
MarquezpostgresCAMBIAMIPER favore
Hive MetastorepostgresCAMBIAMIPER favore
Last updated on