# Docker {% hint style="info" %} #### Conteneur Docker Le déploiement de conteneurs Docker vous permet d’empaqueter et d’exécuter les produits Pentaho au sein de conteneurs portables et prêts pour la production. La conteneurisation garantit un comportement cohérent entre les environnements de développement, de test et de production tout en simplifiant les opérations de déploiement et de mise à l’échelle. Vous pouvez créer des conteneurs Docker pour le Pentaho Server, qui inclut la plateforme complète Business Analytics et Data Integration avec la Pentaho User Console, les services d’ordonnancement et la gestion du dépôt. Le serveur prend en charge des bases de données d’entreprise en backend telles que PostgreSQL, MySQL, Oracle et SQL Server. Pour le traitement ETL distribué, vous pouvez déployer des conteneurs de serveur Carte qui exécutent des transformations et des jobs à distance. Les outils en ligne de commande Kitchen et Pan sont également disponibles en tant que conteneurs, permettant l’intégration avec les pipelines CI/CD et les workflows batch automatisés. Les déploiements en conteneurs sont particulièrement efficaces pour les environnements cloud où vous pouvez augmenter rapidement les ressources pour répondre aux besoins de traitement des données. En exécutant les charges de travail Pentaho dans des conteneurs, les organisations peuvent optimiser les coûts d’infrastructure tout en conservant la flexibilité de se déplacer entre des plateformes sur site et cloud. {% endhint %}

*Architecture de conteneur Docker montrant les conteneurs Pentaho Server et PostgreSQL*

{% tabs %} {% tab title="Conteneur Pentaho Server" %} {% hint style="info" %} Ce conteneur exécute la plateforme complète Pentaho Business Analytics et Data Integration sur Apache Tomcat 10. Il inclut la Pentaho User Console (PUC), les services d’ordonnancement et toutes les fonctionnalités analytiques. {% endhint %} {% endtab %} {% tab title="Conteneur PostgreSQL" %} {% hint style="info" %} Ce conteneur fournit le backend de base de données relationnelle en utilisant PostgreSQL 17. Il héberge trois bases de données critiques requises par Pentaho : Jackrabbit (dépôt de contenu), Quartz (ordonnanceur) et Hibernate (sécurité et audit). Les données sont persistant via un volume Docker pour survivre aux redémarrages de conteneurs. {% endhint %}

*Architecture de la base de données PostgreSQL*

Pentaho Server nécessite trois bases de données distinctes, chacune ayant un rôle spécifique :

Base de données	Propriétaire	But et contenu
jackrabbit	jcr_user	Java Content Repository (JCR) - Stocke tout le contenu Pentaho incluant rapports, tableaux de bord, sources de données, schémas d’analyse et fichiers utilisateur. Il s’agit du stockage principal du dépôt Pentaho.
quartz	pentaho_user	Quartz Scheduler - Gère tous les jobs planifiés, déclencheurs et calendriers. Contient des tables pour les définitions de job (QRTZ6_JOB_DETAILS), les triggers (QRTZ6_TRIGGERS), l’historique d’exécution et les verrous de coordination de cluster.
hibernate	hibuser	Hibernate Repository - Héberge la configuration de sécurité, les journaux d’audit, les données de session utilisateur, et contient deux schémas additionnels : pentaho_dilogs (journalisation d’exécution ETL) et pentaho_operations_mart (data mart analytique).

{% hint style="info" %} La base de données hibernate contient des schémas spécialisés pour la surveillance opérationnelle : **pentaho\_dilogs**: Capture des informations détaillées d’exécution ETL incluant les journaux de jobs, journaux de transformations, métriques de performance des étapes et enregistrements d’erreurs. Essentiel pour le débogage des workflows d’intégration de données et la surveillance de la santé des pipelines. **pentaho\_operations\_mart**: Un data mart dimensionnel pour l’analyse de l’utilisation de Pentaho. Contient des tables de dimensions (DIM\_DATE, DIM\_TIME, DIM\_EXECUTOR) et des tables de faits (FACT\_EXECUTION, FACT\_STEP\_EXECUTION) pour analyser l’utilisation de la plateforme, les tendances de performance et l’activité des utilisateurs. Pour les déploiements en production, mettez en œuvre des sauvegardes régulières du volume Docker repository-data. La base de données jackrabbit est la plus critique car elle contient tout le contenu utilisateur. Envisagez d’utiliser pg\_dump pour des sauvegardes logiques ou des snapshots de volumes pour des options de récupération complètes. {% endhint %} {% endtab %} {% tab title="Réseau" %} {% hint style="info" %} Points clés : * Le conteneur Pentaho se connecte à PostgreSQL en utilisant le nom de service 'repository' comme nom d’hôte * PostgreSQL écoute sur le port 5432 en interne (non exposé à l’hôte par défaut) * Pentaho Server expose le port 8080, mappé au système hôte * Tout le trafic inter-conteneurs reste au sein du réseau Docker pour la sécurité {% endhint %}

*Flux de données montrant les requêtes HTTP et les connexions JDBC*

Tomcat gère des pools de connexions définis dans context.xml. Chaque pool a un usage spécifique :

Nom du pool	Cible de connexion	Utilisé pour
jdbc/Hibernate	repository:5432/hibernate	Sécurité, Utilisateurs, Rôles
jdbc/Quartz	repository:5432/quartz	Ordonnancement des jobs
jdbc/jackrabbit	repository:5432/jackrabbit	Dépôt de contenu
jdbc/Audit	repository:5432/hibernate	Journalisation d’audit
jdbc/live_logging_info	repository:5432/hibernate	Journaux d’exécution ETL
jdbc/PDI_Operations_Mart	repository:5432/hibernate	Analytique des opérations

{% hint style="info" %} Lorsqu’un utilisateur accède à Pentaho Server : 1\. Le navigateur de l’utilisateur envoie une requête HTTP à localhost:8080 2\. Docker transfère la requête vers le port 8080 du conteneur Pentaho 3\. Tomcat reçoit la requête et la redirige vers l’application web pentaho.war 4\. L’application récupère/enregistre des données via les pools de connexions JDBC 5\. Les connexions JDBC sont routées vers 'repository:5432' (conteneur PostgreSQL) 6\. La réponse revient par le même chemin vers le navigateur de l’utilisateur {% endhint %} {% endtab %} {% tab title="Mappage des volumes" %} {% hint style="info" %} #### Mappage des volumes Le déploiement utilise à la fois des volumes Docker nommés et des montages bind pour la persistance et la configuration : {% endhint %} ``` Volumes Docker : vault_data -> /vault/data pentaho_postgres_data -> /var/lib/postgresql/data pentaho_solutions -> /opt/pentaho/pentaho-server/pentaho-solutions pentaho_data -> /opt/pentaho/pentaho-server/data Bind mounts : ./softwareOverride -> /docker-entrypoint-init (ro) ./db_init_postgres -> /docker-entrypoint-initdb.d (ro) ./postgres-config -> /etc/postgresql/conf.d (ro) ./config/.kettle -> /home/pentaho/.kettle ./config/.pentaho -> /home/pentaho/.pentaho ./vault/config -> /vault/config (ro) ./scripts -> /scripts (ro) ``` {% endtab %} {% endtabs %} *** {% hint style="danger" %} Avant de commencer le déploiement Docker, assurez-vous d’avoir complété la configuration : [Conteneurs Pentaho](https://academy.pentaho.com/pentaho-11-installation-en/pentaho-11-installation-fr/configuration/conteneurs-pentaho) {% endhint %} Suivez les étapes suivantes pour déployer Pentaho Server avec le dépôt PostgreSQL 15. {% tabs %} {% tab title="1. Préparer l’environnement" %} {% hint style="info" %} #### Préparer l'environnement Vérifiez que Docker est en fonctionnement : * Copier les assets Pentaho-Server-PostgreSQL * Copier `pentaho-server-ee-11.0.0.0-237.zip` * Vérifier Docker & Docker Compose * Vérifier les ports {% endhint %} {% hint style="danger" %} Assurez-vous d’avoir téléchargé : `pentaho-server-ee-11.0.0.0-237.zip` {% endhint %} 1. Créer le répertoire du projet et copier les assets. ```bash cd cp -r ~/Workshop--Installation/Pentaho-Containers/On-Prem/Pentaho-Server-PostgreSQL . ``` 2. Copiez le pentaho-server-ee-11.0.0.0-237.zip dans le répertoire /docker/stagedArtefacts. {% hint style="info" %} Si vous avez déjà déployé un Pentaho Server Archive, copiez depuis : `/opt/pentaho/software/pentaho-server-ee-version` Sinon, téléchargez le package depuis le [Portail client Pentaho](https://support.pentaho.com/hc/en-us). {% endhint %} ```bash cd cd ~/Pentaho-Server-PostgreSQL/docker/stagedArtifacts cp /opt/pentaho/software/server/pentaho-server-ee-11.0.0.0-237.zip . ``` 3. Vérifiez que le fichier existe. ```bash cd cd ~/Pentaho-Server-PostgreSQL/docker/stagedArtifacts ls -al ``` 4. Vérifiez la version de Docker. ```bash docker --version # Sortie attendue : Docker version 29.0.2 ou supérieure ``` 5. Vérifiez la version de Docker Compose. ```bash docker compose --version # Sortie attendue : Docker Compose version 2.40.3 ou supérieure ``` ```bash sudo apt install docker-compose # installe Docker Compose ``` 6. Vérifiez que le démon Docker est en cours d’exécution. ```bash docker info # Devrait afficher des informations système globales sans erreurs ``` 7. Vérifiez que le port 8080 / 8090 est disponible sur le système hôte. ```bash sudo lsof -i ::8080 ``` {% hint style="info" %} Si le port 8080 est utilisé par une autre application, vous pouvez changer la variable PORT dans le fichier .env pour un port disponible (par ex. 8090, 8081, 9090). {% endhint %} 8. Pentaho Server requiert une licence valide. Le `.env` fichier contient une LICENSE\_URL pointant vers le serveur de licences Flexera. Assurez-vous que vos droits de licence sont actifs avant le déploiement. {% hint style="warning" %} Sans licence valide, Pentaho Server démarrera mais de nombreuses fonctionnalités seront désactivées. Vérifiez l’état de votre licence avant de procéder à des déploiements en production. {% endhint %} {% endtab %} {% tab title="2. Structure des répertoires" %} {% hint style="info" %} #### Structure des répertoires Cette configuration de déploiement offre plusieurs fonctionnalités importantes : * Déploiement complètement autonome et portable. * Initialisation automatisée de la base de données avec des scripts SQL. * Vérifications de santé et ordre de démarrage approprié entre les services. * Volumes de données persistants pour la base de données et le contenu Pentaho. * HashiCorp Vault pour la gestion des secrets avec authentification AppRole. * Conteneurs en lecture seule avec montages tmpfs pour la sécurité. * Limites de ressources (CPU/mémoire) pour la stabilité. * Rotation des logs pour éviter l’épuisement du disque. * Système de remplacement logiciel pour personnaliser les configurations sans modifier les fichiers principaux. * Templates de configuration prêts pour la production. * Pilote JDBC PostgreSQL inclus * Procédures de sauvegarde et de restauration faciles {% endhint %} {% hint style="success" %} Consultez les autres options de déploiement du dépôt à : ``` ~/Workshop--Installation/Pentaho-Containers/On-Prem/ ``` {% endhint %} *** **Fichiers du répertoire racine** ``` Pentaho-Server-PostgreSQL/ ├── README.md # Fichier de documentation principal ├── ARCHITECTURE.md # Détails de l’architecture système ├── CONFIGURATION.md # Guide de référence de configuration ├── TROUBLESHOOTING.md # Guide de résolution de problèmes ├── docker-compose.yml # Définitions des services Docker Compose ├── Makefile # Cibles utilitaires (make help) ├── deploy.sh # Script de déploiement automatisé ├── .env # Configuration d’environnement (créé) ├── .env.template # Modèle d’environnement avec valeurs par défaut ``` {% hint style="info" %} **Fichiers de documentation :** **README.md** - Point d’entrée principal de la documentation fournissant une vue d’ensemble du projet, des instructions de démarrage rapide, des prérequis et des informations générales d’utilisation pour l’atelier. **ARCHITECTURE.md** - Documentation technique détaillée couvrant l’architecture système, les relations entre les composants, le design des conteneurs, le réseau, le flux de données et les décisions architecturales pour le déploiement basé sur Docker. **CONFIGURATION.md** - Guide de référence complet de configuration détaillant toutes les variables d’environnement disponibles, options de configuration, paramètres de personnalisation et réglages pour le Pentaho Server et les composants PostgreSQL. **TROUBLESHOOTING.md** - Guide de résolution de problèmes avec problèmes courants, messages d’erreur, procédures de diagnostic et solutions pour les problèmes de déploiement et d’exécution que vous pourriez rencontrer. **Orchestration et déploiement :** **docker-compose.yml** - Le fichier de définitions des services Docker Compose qui déclare tous les conteneurs (Pentaho Server, PostgreSQL, éventuellement Vault/autres services), leurs configurations, le réseau, les volumes et les dépendances. **Makefile** - Contient des cibles de commandes utilitaires pour des opérations courantes comme construire, démarrer, arrêter et nettoyer l’environnement. Les utilisateurs peuvent exécuter `make help` pour voir les commandes disponibles. **deploy.sh** - Script de déploiement automatisé qui gère probablement le workflow complet de déploiement incluant la validation de l’environnement, la construction des images, le démarrage des services et la configuration initiale. **Configuration de l’environnement :** **.env** - Le fichier de configuration d’environnement actif (créé à partir du modèle) contenant les valeurs réelles pour les mots de passe de base de données, ports, noms d’hôtes et autres paramètres spécifiques à l’environnement. Ce fichier est généralement ignoré par git. **.env.template** - Le fichier modèle avec des valeurs par défaut et des espaces réservés que les utilisateurs copient pour créer leur `.env` fichier, fournissant une référence pour toutes les variables d’environnement configurables. {% endhint %} *** **Contexte de build Docker** ``` ├── docker/ │ ├── Dockerfile # Build d’image Pentaho Server en plusieurs étapes │ ├── entrypoint/ │ │ └── docker-entrypoint.sh # Script de démarrage du conteneur │ └── stagedArtifacts/ │ └── pentaho-server-ee-11.0.0.0-237.zip ``` {% hint style="info" %} La **docker/** le répertoire contient tous les composants de base nécessaires pour construire et exécuter le déploiement conteneurisé du Pentaho Server : **Dockerfile** - Il s’agit de la configuration de build principale utilisant une approche multi-stage pour créer l’image du conteneur Pentaho Server. Les builds multi-stage aident à optimiser la taille finale de l’image en séparant l’environnement de build de l’environnement d’exécution. **entrypoint/** le répertoire contient le **docker-entrypoint.sh** script, qui est le script d’initialisation qui s’exécute au démarrage du conteneur. Cela gère typiquement des tâches comme la configuration de l’environnement, la gestion des configurations, les vérifications de santé et le démarrage des services Pentaho Server. **stagedArtifacts/** le répertoire sert de zone de staging pour le paquet d’installation Pentaho Server. Il contient actuellement **pentaho-server-ee-11.0.0.0-237.zip**, qui est la version Enterprise Edition 11.0.0.0 build 237 qui est extraite et installée pendant le processus de build de l’image Docker. {% endhint %} *** **Initialisation de la base de données du dépôt PostgreSQL** ``` ├── db_init_postgres/ │ ├── 1_create_jcr_postgresql.sql # Dépôt de contenu Jackrabbit │ ├── 2_create_quartz_postgresql.sql # Ordonnanceur Quartz │ ├── 3_create_repository_postgresql.sql # Dépôt Hibernate │ ├── 4_pentaho_logging_postgresql.sql # Schéma de journalisation Audit/DI │ └── 5_pentaho_mart_postgresql.sql # Schéma du mart opérationnel ``` {% hint style="info" %} La **db\_init\_postgres/** le répertoire contient les scripts d’initialisation de la base de données PostgreSQL qui créent tous les schémas requis pour Pentaho Server 11. Ces scripts sont numérotés pour s’exécuter dans un ordre spécifique : **1\_create\_jcr\_postgresql.sql** - Crée le **Jackrabbit Content Repository (JCR)** schema, qui stocke le contenu du dépôt Pentaho incluant les fichiers solution, les plannings, les rapports, les tableaux de bord et les métadonnées. Il s’agit du système de gestion de contenu principal pour Pentaho. **2\_create\_quartz\_postgresql.sql** - Met en place le **Quartz Scheduler** schema, qui gère tous les jobs et tâches planifiés au sein de Pentaho Server, y compris la génération de rapports, les exécutions ETL et d’autres processus automatisés. **3\_create\_repository\_postgresql.sql** - Crée le **Hibernate Repository** schema, qui stocke l’authentification des utilisateurs, les données d’autorisation, les rôles, les permissions et d’autres informations liées à la sécurité gérées par le sous-système de sécurité de Pentaho. **4\_pentaho\_logging\_postgresql.sql** - Établit le **Audit and Data Integration (DI) Logging** schema pour capturer les journaux d’exécution, les métriques des transformations/jobs et les informations de piste d’audit des processus PDI s’exécutant sur le serveur. **5\_pentaho\_mart\_postgresql.sql** - Crée le **Operations Mart** schema, qui stocke les données analytiques opérationnelles concernant l’utilisation de Pentaho Server, les métriques de performance et les informations de surveillance système utilisées par le tableau de bord Pentaho Operations Mart. {% endhint %} *** **Configuration PostgreSQL et Vault** ``` ├── postgres-config/ │ ├── custom.conf # Tuning des performances PostgreSQL │ └── pg_hba.conf # Configuration de l’authentification client ├── vault/ │ ├── config/ │ │ └── vault.hcl # Configuration du serveur Vault │ └── policies/ │ └── pentaho-policy.hcl # Politique d’accès Pentaho ├── secrets/ │ └── postgres_password.txt # Fichier de secrets Docker ``` {% hint style="info" %} **postgres-config/** - Configuration PostgreSQL **custom.conf** - Paramètres personnalisés de tuning des performances PostgreSQL optimisés pour les charges de travail Pentaho Server. Cela inclut probablement des réglages pour shared\_buffers, work\_mem, limites de connexion, configurations de checkpoint et d’autres paramètres liés aux performances adaptés aux exigences de la base de données de Pentaho. **pg\_hba.conf** - Fichier de configuration PostgreSQL Host-Based Authentication qui contrôle les méthodes d’authentification des clients, les règles d’accès par adresse IP et les politiques de sécurité pour les connexions de la part du conteneur Pentaho Server. *** **vault/** - Intégration HashiCorp Vault Ce répertoire supporte l’intégration de Vault pour la gestion des secrets : **config/vault.hcl** - Le fichier de configuration du serveur HashiCorp Vault définissant le backend de stockage, les paramètres d’écoute, les endpoints API, le comportement de scellage/déverrouillage et les paramètres opérationnels généraux du serveur Vault. **policies/pentaho-policy.hcl** - Politique de contrôle d’accès Vault spécifiquement pour Pentaho Server, définissant les chemins de secrets que l’application Pentaho peut lire, écrire ou gérer. Cela applique le principe du moindre privilège pour l’accès aux identifiants sensibles. *** **secrets/** - Gestion des secrets Docker **postgres\_password.txt** - Un fichier de secrets Docker contenant le mot de passe PostgreSQL. Lors de l’utilisation des secrets Docker (ou de l’intégration Vault), ce fichier fournit les identifiants de base de données de manière sécurisée plutôt que de les passer en variables d’environnement en clair. Le fichier doit avoir des permissions restreintes et est généralement référencé par Docker Compose en utilisant la `secrets:` configuration. {% endhint %}

Clé	Description
postgres_password	Mot de passe du superutilisateur PostgreSQL
pentaho_user	Nom d’utilisateur de la base de données Pentaho
pentaho_password	Mot de passe de la base de données Pentaho
jdbc_url	URL de connexion JDBC

*** **Remplacements de configuration Pentaho** ``` ├── softwareOverride/ │ ├── 1_drivers/ # Pilotes JDBC │ │ └── tomcat/lib/ │ ├── 2_repository/ # Configuration de la base de données │ │ ├── pentaho-solutions/system/ │ │ │ ├── hibernate/ │ │ │ ├── jackrabbit/ │ │ │ └── scheduler-plugin/quartz/ │ │ └── tomcat/webapps/pentaho/META-INF/ │ ├── 3_security/ # Paramètres d’authentification │ │ └── pentaho-solutions/system/ │ └── 4_others/ # Paramètres Tomcat et application │ ├── pentaho-solutions/system/ │ └── tomcat/ ``` {% hint style="info" %} La **softwareOverride/** le répertoire contient des fichiers de configuration et composants personnalisés qui remplacent l’installation par défaut de Pentaho Server. La structure numérotée assure une organisation logique et potentiellement une application ordonnée lors du processus de build Docker : *** **1\_drivers/** - Pilotes de base de données JDBC **tomcat/lib/** - Contient les fichiers JAR des pilotes JDBC (spécifiquement le pilote JDBC PostgreSQL) qui sont copiés dans le répertoire lib de Tomcat, permettant à Pentaho Server de se connecter aux bases PostgreSQL. *** **2\_repository/** - Configuration du dépôt de base de données Cette section configure la connexion de Pentaho à tous les dépôts supportés par PostgreSQL : **pentaho-solutions/system/hibernate/** - Fichiers de configuration du dépôt Hibernate (repository.xml, hibernate-settings.xml) pour les données de sécurité utilisateur/rôle **pentaho-solutions/system/jackrabbit/** - Configuration du dépôt Jackrabbit JCR (repository.xml) pour le stockage du contenu **pentaho-solutions/system/scheduler-plugin/quartz/** - Configuration de la base de données du scheduler Quartz (quartz.properties) pour l’ordonnancement des jobs **tomcat/webapps/pentaho/META-INF/** - Contient context.xml avec les définitions des sources de données JNDI pour toutes les bases Pentaho (Quartz, Jackrabbit, Hibernate, Audit, Operations Mart) *** **3\_security/** - Paramètres d’authentification et de sécurité **pentaho-solutions/system/** - Fichiers de configuration de sécurité incluant applicationContext-security.xml, security.properties, et potentiellement des configurations LDAP/SSO pour l’authentification et l’autorisation. *** **4\_others/** - Paramètres Tomcat & application supplémentaires **pentaho-solutions/system/** - Autres configurations au niveau système comme pentaho.xml, pentaho-spring-beans.xml, réglages log4j et configurations de comportement de l’application **tomcat/** - Personnalisations du serveur Tomcat incluant server.xml, web.xml, setenv.sh pour les paramètres JVM et autres optimisations spécifiques à Tomcat {% endhint %} **Scripts utilitaires** ``` ├── scripts/ │ ├── backup-postgres.sh # Utilitaire de sauvegarde de base de données │ ├── restore-postgres.sh # Utilitaire de restauration de base de données │ ├── backup-vault.sh # Sauvegarde des identifiants Vault │ ├── restore-vault.sh # Restauration des identifiants Vault │ ├── rotate-secrets.sh # Script de rotation des mots de passe │ ├── fetch-secrets.sh # Helper de récupération des secrets │ ├── vault-init.sh # Initialisation de Vault │ └── validate-deployment.sh # Validation du déploiement ``` {% hint style="info" %} La **scripts/** le répertoire contient des utilitaires opérationnels et de maintenance pour la gestion du déploiement Pentaho Server, organisés par domaine fonctionnel : *** **Gestion de la base de données :** **backup-postgres.sh** - Utilitaire automatisé de sauvegarde PostgreSQL qui crée des dumps de toutes les bases Pentaho (JCR, Quartz, Hibernate, Audit, Operations Mart). Inclut probablement l’ajout d’un horodatage, la compression et la logique de rétention des sauvegardes. **restore-postgres.sh** - Utilitaire de restauration de base de données pour récupérer les bases Pentaho à partir de fichiers de sauvegarde, utile pour la reprise après sinistre, le clonage d’environnement ou la migration de données entre instances. *** **Vault/Gestion des secrets :** **backup-vault.sh** - Script de sauvegarde des identifiants et des clés d’unseal de HashiCorp Vault, assurant la capacité de récupération pour l’instance Vault contenant des identifiants sensibles pour Pentaho. **restore-vault.sh** - Utilitaire de restauration Vault pour récupérer les données Vault et réinitialiser le système de gestion des secrets à partir d’une sauvegarde. **rotate-secrets.sh** - Script automatisé de rotation des mots de passe qui met à jour les mots de passe de base de données et autres identifiants sensibles dans Vault, puis propage les changements à la configuration de Pentaho Server — soutenant les bonnes pratiques de sécurité. **fetch-secrets.sh** - Utilitaire d’aide pour récupérer des secrets depuis Vault de manière programmatique, utile pour des scripts qui doivent accéder aux identifiants sans les coder en dur. **vault-init.sh** - Script d’installation initiale de Vault qui gère l’initialisation de Vault, le déverrouillage, la création de la politique Pentaho et le stockage des secrets initiaux pour le déploiement. *** **Opérations & Validation :** **validate-deployment.sh** - Script de validation du déploiement qui effectue des vérifications de santé sur tous les composants (connectivité PostgreSQL, démarrage de Pentaho Server, accessibilité de Vault, disponibilité des services), confirmant que l’environnement est correctement configuré et opérationnel. {% endhint %} *** **Configuration utilisateur et stockage des données** ``` ├── config/ │ ├── .kettle/ # Configuration PDI/Kettle │ │ └── kettle.properties │ └── .pentaho/ # Paramètres utilisateur Pentaho ├── backups/ # Stockage des sauvegardes de base de données │ └── *.sql.gz # Sauvegardes SQL compressées └── logs/ # Logs d’application (optionnel) ``` {% hint style="info" %} **config/** - Configuration de l’application Ce répertoire stocke les fichiers de configuration au niveau utilisateur et application : **`.kettle/`** - Répertoire de configuration PDI (Pentaho Data Integration) / Kettle * **kettle.properties** - Contient les variables d’environnement Kettle/PDI, paramètres de connexion, propriétés système et réglages globaux utilisés par les exécutions de transformations et de jobs s’exécutant sur Pentaho Server. **`.pentaho/`** - Répertoire des paramètres utilisateur Pentaho pour stocker les préférences spécifiques à l’utilisateur, les métadonnées mises en cache et l’état de l’application. *** **backups/** - Stockage des sauvegardes de bases de données **`*.sql.gz`** - Dépôt des fichiers de sauvegarde compressés PostgreSQL créés par le `backup-postgres.sh` script. La compression gzip réduit les besoins de stockage tout en conservant des instantanés complets de la base de données pour la récupération après sinistre, le clonage d’environnement ou les scénarios de rollback. Les fichiers de sauvegarde sont probablement horodatés pour le suivi des versions. *** **logs/** - Journalisation de l’application Répertoire centralisé de journalisation pour capturer les logs d’exécution de tous les services. Cela inclut probablement : * Logs de l’application Pentaho Server (catalina.out, pentaho.log) * Logs de la base de données PostgreSQL * Logs du service Vault * Logs des conteneurs Docker * Journaux d’exécution ETL Ceci soutient la **configuration de rotation des logs** et les capacités de surveillance que vous avez intégrées dans votre déploiement, facilitant le dépannage et l’audit lors des ateliers. {% endhint %} *** **Fichiers clés**

Fichier	But
docker-compose.yml	Définit tous les services (pentaho-server, postgres), réseaux et volumes
docker/Dockerfile	Build multi-stage utilisant debian:trixie-slim avec OpenJDK 21
docker-entrypoint.sh	Traite les répertoires softwareOverride au démarrage du conteneur
.env	Configuration spécifique à l’environnement (ports, mots de passe, mémoire)
deploy.sh	Déploiement automatisé avec contrôles de validation préalables
db_init_postgres/*.sql	Scripts d’initialisation de la base de données PostgreSQL
vault-init.sh	Initialise Vault et stocke les secrets
rotate-secrets.sh	Fait tourner les mots de passe de base de données de manière sécurisée

{% endtab %} {% tab title="3. Tâches préalables" %} {% hint style="info" %} #### Tâches préalables La section Tâches préalables décrit les étapes de préparation essentielles nécessaires avant de déployer Pentaho Server 11 dans des conteneurs Docker. Tout d’abord, vous devez configurer les variables d’environnement en éditant le `.env.template` fichier avec vos paramètres spécifiques de déploiement. Cela inclut la définition de la version Pentaho et des détails de l’image, des identifiants PostgreSQL et de la configuration des ports (par défaut 5432), des ports HTTP et HTTPS de Pentaho (8090 et 8443), l’allocation mémoire JVM (minimum 4 Go, maximum 8 Go), l’URL du serveur de licence et les paramètres de port Vault. Une fois configuré, ce modèle est enregistré en tant que fichier `.env` actif. Le tuning des performances PostgreSQL est géré via le fichier `postgres-config/custom.conf` , où vous pouvez personnaliser les limites de connexion (par défaut 200 connexions max), les paramètres d’allocation mémoire incluant shared\_buffers et tailles de cache, et d’autres optimisations de performances spécialement adaptées aux environnements conteneurisés. Enfin, le `softwareOverride/` répertoire fournit un mécanisme optionnel pour personnaliser les configurations Pentaho sans modifier les fichiers d’installation principaux. Le pilote JDBC PostgreSQL est inclus par défaut, mais vous pouvez le mettre à niveau en le téléchargeant depuis Maven Central ou en le copiant depuis la collection de pilotes de bases de données de l’atelier. Cette préparation garantit que tous les fichiers, configurations et identifiants requis sont correctement mis en place avant d’exécuter le script de déploiement automatisé. {% endhint %} *** **Configurer .env** 1. Éditez le .env.template ```bash cd cd ~/Pentaho-Server-PostgreSQL nano .env.template ``` 2. Saisissez les détails suivants :

Variable	Par défaut	Description
PENTAHO_VERSION	11.0.0.0-237	Version de Pentaho Server
PENTAHO_IMAGE_NAME	pentaho/pentaho-server	Nom de l’image Docker
PENTAHO_IMAGE_TAG	11.0.0.0-237	Tag de l’image Docker
POSTGRES_PASSWORD	password	Mot de passe root PostgreSQL
POSTGRES_PORT	5432	Port exposé PostgreSQL
PENTAHO_HTTP_PORT	8090	Port HTTP Pentaho
PENTAHO_HTTPS_PORT	8443	Port HTTPS Pentaho
PENTAHO_MIN_MEMORY	4096m	Taille minimale du heap JVM
PENTAHO_MAX_MEMORY	8192m	Taille maximale du heap JVM
LICENSE_URL	(vide)	URL du serveur de licences EE
VAULT_PORT	8200	Port de l'API Vault

3. Enregistrer : ``` CTRL + o Entrée CTRL + x ``` 4. Créer .env ```bash cd cd ~/Pentaho-Server-PostgreSQL cp .env.template .env ``` *** **Personnaliser postgres-config/custom.conf** 1. Éditez le .env.template ```bash cd cd ~/Pentaho-Server-PostgreSQL/progres-config nano custom.conf ``` 2. Saisissez les détails suivants : ```conf # Limites de connexion max_connections = 200 # Mémoire (ajuster en fonction de la RAM disponible) shared_buffers = 256MB effective_cache_size = 768MB work_mem = 16MB # Performance random_page_cost = 1.1 effective_io_concurrency = 200 ``` 3. Enregistrer : ``` CTRL + o Entrée CTRL + x ``` *** **softwareOverride** {% hint style="info" %} La `softwareOverride/` Le répertoire fournit un mécanisme puissant pour personnaliser Pentaho Server sans modifier l'installation principale. Les fichiers sont copiés dans l'installation Pentaho lors du démarrage du conteneur, traités par ordre alphabétique des noms de répertoires. {% endhint %} ```` ``` softwareOverride/ ├── 1_drivers/ # pilotes JDBC et connecteurs de données │ ├── tomcat/lib/ │ │ └── postgresql-42.x.x.jar # pilote JDBC PostgreSQL (inclus) │ └── pentaho-solutions/drivers/ # pilotes Big Data (.kar files) ├── 2_repository/ # configuration du dépôt de base de données │ ├── pentaho-solutions/system/ │ │ ├── hibernate/hibernate-settings.xml │ │ ├── jackrabbit/repository.xml │ │ └── scheduler-plugin/quartz/quartz.properties │ └── tomcat/webapps/pentaho/META-INF/context.xml ├── 3_security/ # authentification et autorisation │ └── pentaho-solutions/system/ │ ├── applicationContext-spring-security-hibernate.properties │ └── applicationContext-spring-security-memory.xml ├── 4_others/ # Tomcat, paramètres par défaut et divers │ ├── pentaho-solutions/system/ │ │ ├── defaultUser.spring.properties │ │ ├── pentaho.xml │ │ └── security.properties │ └── tomcat/ │ ├── bin/startup.sh │ └── webapps/pentaho/WEB-INF/web.xml └── 99_exchange/ # échange de données utilisateur (non traité automatiquement) ``` ```` Le pilote JDBC PostgreSQL est inclus dans la distribution Pentaho. Si vous devez le mettre à jour : 1. Télécharger depuis [Maven Central](https://repo1.maven.org/maven2/org/postgresql/postgresql/) 2. Placer dans `softwareOverride/1_drivers/tomcat/lib/` Ou Copier depuis Workshop--Installation/'Database Drivers'/ ```bash cd cd ~/Workshop--Installation/'Database Drivers' cp postgresql-42.7.8.jar ~/Pentaho-Server-PostgreSQL/softwareOverride/1_drivers/tomcat/lib ``` {% endtab %} {% tab title="4. Déploiement" %} {% hint style="info" %} #### Déploiement Cette section explique le processus de déploiement en utilisant soit le script automatisé soit des commandes manuelles. {% endhint %} Sélectionnez l'option de déploiement : {% tabs %} {% tab title="Automatisé" %} {% hint style="info" %} #### Déploiement automatisé Le script deploy.sh automatise l'ensemble du processus de déploiement avec une validation préliminaire : ./deploy.sh Le script effectue les actions suivantes : * Valide l'installation de Docker et Docker Compose * Vérifie que le package Pentaho existe dans : `docker/stagedArtifacts/` * Crée `.env` à partir du modèle si manquant * Vérifie l'espace disque (10 Go minimum) * Vérifie que les ports requis sont disponibles * Construit l'image Docker de Pentaho Server * Démarre PostgreSQL et attend la vérification de santé * Démarre Pentaho Server et surveille le démarrage * Affiche les URL d'accès et les identifiants {% endhint %} 1\. Donner les permissions d'exécution aux scripts de déploiement. ```bash cd cd ~/Pentaho-Server-PostgreSQL chmod +x deploy.sh chmod +x scripts/*.sh ``` 2. Déployer les conteneurs. {% hint style="danger" %} Assurez-vous de ne pas avoir un service postgresql en cours d'exécution : ```bash systemctl stop postgresql ``` {% endhint %} ```bash cd cd ~/Pentaho-Server-PostgreSQL && ./deploy.sh ``` {% tabs %} {% tab title="Phase de pré-validation et de construction" %} {% hint style="info" %} **Vérifications préalables ✓** Le script valide l'environnement avant de démarrer : * Docker est installé * Docker Compose est installé * Le démon Docker fonctionne * Package Pentaho trouvé * `.env` le fichier existe * Espace disque suffisant (414 Go disponibles) * Le port 8090 (HTTP Pentaho) est disponible * Le port 5432 (PostgreSQL) est disponible **Phase de construction** Une image Docker personnalisée est construite avec **24 étapes de construction** prenant approximativement **5-10 minutes**: * Image de base : `debian:trixie-slim` * Installe des paquets système via `apt-get update` et `apt-get upgrade` * Installe **OpenJDK 21 JRE headless** avec `curl` et `rm` * Crée un `pentaho` utilisateur et groupe (GID 5000) * (Optionnel) Installe des plugins Pentaho (PAZ, PIR, PDD) * Copie l'installation Pentaho vers `/opt/pentaho/` * Exporte les couches et manifestes * **Image finale**: `pentaho/pentaho-server:11.0.0.0-237` {% endhint %}

{% endtab %} {% tab title="Déploiement & État final" %} {% hint style="info" %} **Démarrage de la base de données PostgreSQL** Récupère **PostgreSQL 15** image et couches associées : * Crée le réseau : `pentaho-server-postgresql_pentaho-net` * Crée le volume : `pentaho-server-postgresql_pentaho_postgres_data` * Crée le conteneur : `pentaho-postgres` * Attend la disponibilité de PostgreSQL : **✓ PostgreSQL est prêt** **Démarrage de Pentaho Server** Cette phase prend **2-3 minutes pour l'initialisation la première fois**: **Récupère l'image HashiCorp Vault 1.15** pour la gestion des secrets **Crée des volumes :** * `pentaho-server-postgresql_pentaho_solutions` * `pentaho-server-postgresql_pentaho_data` * `pentaho-server-postgresql_vault_data` {% endhint %}

{% hint style="info" %} **État final** 🎉 Le déploiement a réussi et vous fournit : **Accès au Pentaho Server :** * URL : `http://localhost:8090/pentaho` * Identifiant : `admin` / `password` **Base de données PostgreSQL :** * Hôte : `localhost:5432` * Identifiant : `postgres` / `password` {% endhint %} | Action | Commande | | ----------------------- | ------------------------ | | Afficher les logs | `docker compose logs -f` | | Arrêter les services | `docker compose stop` | | Démarrer les services | `docker compose start` | | Redémarrer les services | `docker compose restart` | | Arrêt | `docker compose down` | {% hint style="info" %} **Scripts utilitaires fournis :** * `./scripts/backup-postgres.sh` -- Sauvegarder la base de données * `./scripts/restore-postgres.sh ` -- Restaurer la base de données * `./scripts/validate-deployment.sh` -- Valider le déploiement {% endhint %}

{% endtab %} {% endtabs %} {% endtab %} {% tab title="Construction manuelle" %} {% hint style="info" %} #### Construction manuelle {% endhint %} 1. Construire l'image du Pentaho Server. ```bash docker compose build --no-cache pentaho-server ``` {% hint style="info" %} Ce processus prend environ 5-10 minutes car il extrait le package Pentaho et configure l'image. {% endhint %} 2. Démarrer la base de données PostgreSQL ```bash docker compose up -d postgres # Attendre que PostgreSQL soit sain docker compose logs -f postgres ``` {% hint style="info" %} Surveillez le message indiquant que PostgreSQL est prêt à accepter des connexions. {% endhint %} 3. Démarrer le Pentaho Server. ```bash docker compose up -d pentaho-server # Surveiller la progression du démarrage docker compose logs -f pentaho-server ``` {% hint style="info" %} Le Pentaho Server prend généralement 2-3 minutes pour l'initialisation la première fois. Surveillez le message : ``` Démarrage du serveur en [X] millisecondes ``` {% endhint %} {% endtab %} {% endtabs %} 3. Vérifier l'état des conteneurs. ```bash docker compose ps ``` ```bash cd cd ~/Pentaho-Server-PostgreSQL make status ``` 4. Exécuter le script de validation. ```bash cd cd ~/Pentaho-Server-PostgreSQL/scripts && ./validate-deployment.sh ```

5. Ouvrez un navigateur web et naviguez vers : {% embed url="" %} 5. Connectez-vous avec les identifiants par défaut : | Nom d'utilisateur | Admin | | ----------------- | -------- | | Mot de passe | password | 6. Saisissez l'URL du serveur de licences

{% endtab %} {% tab title="5. Sauvegarde & Récupération" %} {% hint style="info" %} #### Sauvegarde & Récupération Mettez en place des sauvegardes régulières pour protéger vos données et la configuration Pentaho. {% endhint %} 1. Créer une sauvegarde compressée des bases de données Pentaho. ```bash ./scripts/backup-postgres.sh # Les sauvegardes sont enregistrées dans le répertoire backups/ avec horodatage # Exemple : backups/pentaho-postgres-backup-20260113-143022.sql.gz ```

{% endtab %} {% endtabs %}