> For the complete documentation index, see [llms.txt](https://academy.pentaho.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://academy.pentaho.com/pentaho-11-installation-en/pentaho-11-installation-fr/installation/containers/docker.md). # Docker {% hint style="info" %} #### Conteneur Docker Le déploiement du conteneur Docker vous permet de packager et d’exécuter les produits Pentaho dans des conteneurs portables, prêts pour la production. La conteneurisation garantit un comportement cohérent dans 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 Pentaho Server, qui inclut la plateforme complète d’analytique métier et d’intégration des données avec la Pentaho User Console, les services de planification et la gestion du référentiel. Le serveur prend en charge des backends de base de données d’entreprise, notamment PostgreSQL, MySQL, Oracle et SQL Server. Pour le traitement ETL distribué, vous pouvez déployer des conteneurs serveur Carte qui exécutent des transformations et des tâches à distance. Les outils en ligne de commande Kitchen et Pan sont également disponibles sous forme de conteneurs, ce qui permet l’intégration avec des pipelines CI/CD et des flux de travail batch automatisés. Les déploiements en conteneurs sont particulièrement efficaces pour les environnements cloud, où vous pouvez rapidement faire évoluer les ressources afin de 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 passer entre des plateformes sur site et cloud. {% endhint %}

Architecture du 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 de planification et toutes les fonctionnalités d’analytique. {% endhint %} {% endtab %} {% tab title="Conteneur PostgreSQL" %} {% hint style="info" %} Ce conteneur fournit le backend de base de données relationnelle à l’aide de PostgreSQL 17. Il héberge trois bases de données critiques requises par Pentaho : Jackrabbit (référentiel de contenu), Quartz (ordonnanceur) et Hibernate (sécurité et audit). Les données sont conservées via un volume Docker afin de survivre aux redémarrages du conteneur. {% endhint %}

Architecture de la base de données PostgreSQL

Pentaho Server requiert trois bases de données distinctes, chacune remplissant un rôle spécifique :
Base de donnéesPropriétaireObjectif et contenu
jackrabbitjcr_userJava Content Repository (JCR) - Stocke tout le contenu Pentaho, y compris les rapports, tableaux de bord, sources de données, schémas d’analyse et fichiers utilisateurs. Il s’agit du stockage principal du contenu pour le référentiel Pentaho.
quartzpentaho_userQuartz Scheduler - Gère toutes les tâches planifiées, les déclencheurs et les calendriers. Contient les tables pour les définitions de tâches (QRTZ6_JOB_DETAILS), les déclencheurs (QRTZ6_TRIGGERS), l’historique d’exécution et les verrous de coordination du cluster.
hibernatehibuserHibernate Repository - Héberge la configuration de sécurité, la journalisation d’audit, les données de session utilisateur et contient deux schémas supplémentaires : pentaho_dilogs (journalisation de l’exécution ETL) et pentaho_operations_mart (datamart analytique).
{% hint style="info" %} La base de données hibernate contient des schémas spécialisés pour la supervision opérationnelle : **pentaho\_dilogs**: Capture des informations détaillées sur l’exécution ETL, notamment les journaux des tâches, les journaux de transformation, les métriques de performance des étapes et les enregistrements d’erreurs. Indispensable pour déboguer les workflows d’intégration de données et surveiller l’état du pipeline. **pentaho\_operations\_mart**: Un datamart dimensionnel pour l’analytique sur l’utilisation de Pentaho. Contient des tables de dimension (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 place 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 instantanés de volume pour des options de restauration 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 en interne sur le port 5432 (non exposé à l’hôte par défaut) * Pentaho Server expose le port 8080, mappé sur le système hôte * Tout le trafic entre conteneurs reste à l’intérieur du réseau Docker pour des raisons de sécurité {% endhint %}

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

Tomcat gère les pools de connexions définis dans context.xml. Chaque pool a un objectif spécifique :
Nom du poolCible de connexionUtilisé pour
jdbc/Hibernaterepository:5432/hibernateSécurité, utilisateurs, rôles
jdbc/Quartzrepository:5432/quartzPlanification des tâches
jdbc/jackrabbitrepository:5432/jackrabbitRéférentiel de contenu
jdbc/Auditrepository:5432/hibernateJournalisation d’audit
jdbc/live_logging_inforepository:5432/hibernateJournaux d’exécution ETL
jdbc/PDI_Operations_Martrepository:5432/hibernateAnalytique 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 l’achemine vers l’application web pentaho.war 4\. L’application récupère/stocke les données via les pools de connexions JDBC 5\. Les connexions JDBC acheminent vers 'repository:5432' (conteneur PostgreSQL) 6\. La réponse revient par le même chemin jusqu’au 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 liés 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 Montages liés : ./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 terminé la configuration : [Conteneurs Pentaho](/pentaho-11-installation-en/pentaho-11-installation-fr/configuration/pentaho-containers.md) {% endhint %} Suivez les étapes ci-dessous pour déployer Pentaho Server avec le référentiel PostgreSQL 15. {% tabs %} {% tab title="1. Préparer l’environnement" %} {% hint style="info" %} #### Préparer l’environnement Vérifiez que Docker est installé et en cours d’exécution : * Copier les ressources Pentaho-Server-PostgreSQL * Copier `pentaho-server-ee-11.0.0.0-237.zip` * Vérifier Docker et 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éez le répertoire du projet et copiez les ressources. ```bash cd cp -r ~/Workshop--Installation/Pentaho-Containers/On-Prem/Pentaho-Server-PostgreSQL . ``` 2. Copiez le fichier pentaho-server-ee-11.0.0.0-237.zip dans le répertoire /docker/stagedArtefacts. {% hint style="info" %} Si vous avez déployé un serveur Pentaho archivé, copiez depuis : `/opt/pentaho/software/pentaho-server-ee-version` Sinon, téléchargez le paquet 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 le fichier. ```bash cd cd ~/Pentaho-Server-PostgreSQL/docker/stagedArtifacts ls -al ``` 4. Vérifiez la version de Docker. ```bash docker --version # Sortie attendue : version de Docker 29.0.2 ou supérieure ``` 5. Vérifiez la version de Docker Compose. ```bash docker compose --version # Sortie attendue : version de Docker Compose 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 # Doit afficher les informations système sans erreur ``` 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 modifier la variable PORT dans le fichier .env avec n’importe quel port disponible (par exemple 8090, 8081, 9090). {% endhint %} 8. Pentaho Server nécessite une licence valide. Le `.env` fichier contient une URL 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 aux 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 capacités importantes : * Déploiement entièrement 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 journaux pour éviter l’épuisement de l’espace disque. * Système de substitution logicielle pour personnaliser les configurations sans modifier les fichiers principaux. * Modèles de configuration prêts pour la production. * Pilote JDBC PostgreSQL inclus * Procédures simples de sauvegarde et de restauration {% endhint %} {% hint style="success" %} Consultez les autres options de déploiement du référentiel à : ``` ~/Workshop--Installation/Pentaho-Containers/On-Prem/ ``` {% endhint %} *** **Fichiers du répertoire racine** ``` Pentaho-Server-PostgreSQL/ ├── README.md # Fichier principal de documentation ├── ARCHITECTURE.md # Détails sur l’architecture du système ├── CONFIGURATION.md # Guide de référence de configuration ├── TROUBLESHOOTING.md # Guide de résolution des problèmes ├── docker-compose.yml # Définitions des services Docker Compose ├── Makefile # Cibles de commodité (make help) ├── deploy.sh # Script de déploiement automatisé ├── .env # Configuration de l’environnement (créée) ├── .env.template # Modèle d’environnement avec valeurs par défaut ``` {% hint style="info" %} **Fichiers de documentation :** **README.md** - Le document d’entrée principal fournissant la vue d’ensemble du projet, les instructions de démarrage rapide, les prérequis et des informations générales d’utilisation pour l’atelier. **ARCHITECTURE.md** - Documentation technique détaillée couvrant l’architecture du système, les relations entre les composants, la conception 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 de configuration complet détaillant toutes les variables d’environnement disponibles, les options de configuration, les paramètres de personnalisation et les réglages pour les composants Pentaho Server et PostgreSQL. **TROUBLESHOOTING.md** - Guide de résolution des problèmes avec les soucis courants, les messages d’erreur, les procédures de diagnostic et les solutions aux problèmes de déploiement et d’exécution que vous pourriez rencontrer. **Orchestration et déploiement :** **docker-compose.yml** - Le fichier de définition 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 pratiques pour les opérations courantes comme la construction, le démarrage, l’arrêt et le nettoyage de 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 l’ensemble du flux de déploiement, y compris 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 actif de l’environnement (créé à partir du modèle) contenant les valeurs réelles pour les mots de passe de base de données, les ports, les noms d’hôte et autres paramètres spécifiques à l’environnement. Ce fichier est généralement ignoré par git. **.env.template** - Le fichier modèle avec les 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 construction Docker** ``` ├── docker/ │ ├── Dockerfile # Construction 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 principaux nécessaires pour construire et exécuter le déploiement conteneurisé de Pentaho Server : **Dockerfile** - Il s’agit de la principale configuration de construction utilisant une approche de build multi-étapes pour créer l’image du conteneur Pentaho Server. Les builds multi-étapes aident à optimiser la taille finale de l’image en séparant l’environnement de construction de l’environnement d’exécution. **entrypoint/** le répertoire contient le **docker-entrypoint.sh** script, qui est le script d’initialisation exécuté lorsque le conteneur démarre. Il gère généralement des tâches comme la configuration de l’environnement, la gestion de la configuration, les vérifications de santé et le démarrage des services Pentaho Server. **stagedArtifacts/** le répertoire sert de zone de préparation pour le paquet d’installation de 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 construction de l’image Docker. {% endhint %} *** **Initialisation de la base de données référentiel PostgreSQL** ``` ├── db_init_postgres/ │ ├── 1_create_jcr_postgresql.sql # Référentiel de contenu Jackrabbit │ ├── 2_create_quartz_postgresql.sql # Ordonnanceur Quartz │ ├── 3_create_repository_postgresql.sql # Référentiel Hibernate │ ├── 4_pentaho_logging_postgresql.sql # Schéma de journalisation Audit/DI │ └── 5_pentaho_mart_postgresql.sql # Schéma du mart Operations ``` {% hint style="info" %} La **db\_init\_postgres/** le répertoire contient les scripts d’initialisation de la base de données PostgreSQL qui mettent en place 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 **Référentiel de contenu Jackrabbit (JCR)** schéma, qui stocke le contenu du référentiel Pentaho, y compris les fichiers de solution, les plannings, les rapports, les tableaux de bord et les métadonnées. Il s’agit du système principal de gestion du contenu pour Pentaho. **2\_create\_quartz\_postgresql.sql** - Configure le **Ordonnanceur Quartz** schéma, qui gère toutes les tâches et travaux planifiés dans 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 **Référentiel Hibernate** schéma, qui stocke l’authentification des utilisateurs, les données d’autorisation, les rôles, les permissions et 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 **Journalisation d’audit et d’intégration de données (DI)** schéma pour capturer les journaux d’exécution, les métriques de transformation/tâches et les informations de piste d’audit provenant des processus PDI exécutés sur le serveur. **5\_pentaho\_mart\_postgresql.sql** - Crée le **Operations Mart** schéma, qui stocke les données d’analytique opérationnelle sur l’utilisation de Pentaho Server, les métriques de performance et les informations de supervision système utilisées par le tableau de bord Pentaho Operations Mart. {% endhint %} *** **Configuration PostgreSQL et Vault** ``` ├── postgres-config/ │ ├── custom.conf # Réglage 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 réglage des performances PostgreSQL optimisés pour les charges de travail de Pentaho Server. Cela inclut probablement les paramètres de tampons partagés, de mémoire de travail, de limites de connexion, de configuration des points de contrôle et d’autres paramètres liés aux performances adaptés aux besoins de base de données de Pentaho. **pg\_hba.conf** - Fichier de configuration d’authentification basée sur l’hôte PostgreSQL qui contrôle les méthodes d’authentification des connexions client, les règles d’accès par adresse IP et les politiques de sécurité pour les connexions à la base de données depuis le conteneur Pentaho Server. *** **vault/** - Intégration HashiCorp Vault Ce répertoire permet 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 points de terminaison API, le comportement de scellement/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écialement conçue pour Pentaho Server, définissant quels chemins de secrets l’application Pentaho peut lire, écrire ou gérer. Cela applique le principe du moindre privilège pour les 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 transmettre sous forme de variables d’environnement en clair. Le fichier doit avoir des permissions restreintes et est généralement référencé par Docker Compose à l’aide de `secrets:` configuration. {% endhint %}
CléDescription
postgres_passwordMot de passe du superutilisateur PostgreSQL
pentaho_userNom d’utilisateur de la base de données Pentaho
pentaho_passwordMot de passe de la base de données Pentaho
jdbc_urlURL de connexion JDBC
*** **Substitutions 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 des composants personnalisés qui remplacent l’installation par défaut de Pentaho Server. La structure numérotée assure une organisation logique et éventuellement une application ordonnée pendant le processus de construction Docker : *** **1\_drivers/** - Pilotes de base de données JDBC **tomcat/lib/** - Contient les fichiers JAR des pilotes JDBC (en particulier le pilote JDBC PostgreSQL) qui sont copiés dans le répertoire de bibliothèque de Tomcat, permettant à Pentaho Server de se connecter aux bases de données PostgreSQL. *** **2\_repository/** - Configuration du référentiel de base de données Cette section configure la connexion de Pentaho à tous les référentiels reposant sur PostgreSQL : **pentaho-solutions/system/hibernate/** - Fichiers de configuration du référentiel Hibernate (repository.xml, hibernate-settings.xml) pour les données de sécurité des utilisateurs/rôles **pentaho-solutions/system/jackrabbit/** - Configuration du référentiel Jackrabbit JCR (repository.xml) pour le stockage du contenu **pentaho-solutions/system/scheduler-plugin/quartz/** - Configuration de la base de données de l’ordonnanceur Quartz (quartz.properties) pour la planification des tâches **tomcat/webapps/pentaho/META-INF/** - Contient context.xml avec les définitions de sources de données JNDI pour toutes les bases de données 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 éventuellement des configurations LDAP/SSO pour l’authentification et l’autorisation. *** **4\_others/** - Paramètres supplémentaires de Tomcat et de l’application **pentaho-solutions/system/** - Autres configurations au niveau système comme pentaho.xml, pentaho-spring-beans.xml, les paramètres log4j et les configurations du comportement de l’application **tomcat/** - Personnalisations du serveur Tomcat incluant server.xml, web.xml, setenv.sh pour les paramètres JVM, et d’autres réglages spécifiques à Tomcat {% endhint %} **Scripts utilitaires** ``` ├── scripts/ │ ├── backup-postgres.sh # Utilitaire de sauvegarde de la base de données │ ├── restore-postgres.sh # Utilitaire de restauration de la 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 # Assistant 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 d’exploitation et de maintenance pour gérer le déploiement de Pentaho Server, organisés par domaine fonctionnel : *** **Gestion de base de données :** **backup-postgres.sh** - Utilitaire automatisé de sauvegarde PostgreSQL qui crée des exports de toutes les bases de données Pentaho (JCR, Quartz, Hibernate, Audit, Operations Mart). Comprend probablement la génération d'horodatages, la compression et la logique de rétention des sauvegardes. **restore-postgres.sh** - Utilitaire de restauration de base de données permettant de récupérer les bases Pentaho à partir de fichiers de sauvegarde, utile pour la reprise après sinistre, le clonage d'environnements ou la migration de données entre instances. *** **Gestion du coffre-fort/des secrets :** **backup-vault.sh** - Script de sauvegarde des identifiants HashiCorp Vault et des clés de déverrouillage, garantissant la capacité de récupération de l'instance Vault contenant les identifiants Pentaho sensibles. **restore-vault.sh** - Utilitaire de restauration du coffre-fort permettant de récupérer les données Vault et de 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 d'autres identifiants sensibles dans Vault, puis propage les changements à la configuration de Pentaho Server — en soutenant les bonnes pratiques de sécurité. **fetch-secrets.sh** - Utilitaire d'assistance permettant de récupérer les secrets depuis Vault de manière programmatique, utile pour les scripts qui doivent accéder aux identifiants sans les coder en dur. **vault-init.sh** - Script initial de configuration de Vault qui gère l'initialisation de Vault, son déverrouillage, la création de la politique Pentaho et le stockage des secrets initiaux pour le déploiement. *** **Opérations et validation :** **validate-deployment.sh** - Script de validation du déploiement qui effectue des vérifications de bon fonctionnement 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/ # Journaux de l'application (facultatif) ``` {% 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 de PDI (Pentaho Data Integration) / Kettle * **kettle.properties** - Contient les variables d'environnement Kettle/PDI, les paramètres de connexion, les propriétés système et les paramètres globaux utilisés par les transformations et les exécutions de jobs s'exécutant sur Pentaho Server. **`.pentaho/`** - Répertoire de paramètres utilisateur Pentaho pour stocker les préférences propres à l'utilisateur, les métadonnées en cache et les informations d'état de l'application. *** **backups/** - Stockage des sauvegardes de base de données **`*.sql.gz`** - Répertoire des fichiers de sauvegarde PostgreSQL compressés 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 reprise après sinistre, le clonage d'environnements ou les scénarios de retour arrière. Les fichiers de sauvegarde sont probablement horodatés pour le suivi des versions. *** **logs/** - Journalisation de l'application Répertoire de journalisation centralisé pour capturer les journaux d'exécution de tous les services. Cela inclut probablement : * Journaux de l'application Pentaho Server (catalina.out, pentaho.log) * Journaux de la base de données PostgreSQL * Journaux du service Vault * Journaux des conteneurs Docker * Journaux d'exécution ETL Cela prend en charge la **configuration de rotation des journaux** et les capacités de supervision que vous avez intégrées à votre déploiement, facilitant le dépannage et l'audit pendant les ateliers. {% endhint %} *** **Fichiers clés**
FichierRôle
docker-compose.ymlDéfinit tous les services (pentaho-server, postgres), les réseaux et les volumes
docker/DockerfileBuild multi-étapes utilisant debian:trixie-slim avec OpenJDK 21
docker-entrypoint.shTraite les répertoires softwareOverride au démarrage du conteneur
.envConfiguration spécifique à l'environnement (ports, mots de passe, mémoire)
deploy.shDéploiement automatisé avec vérifications de validation préalables
db_init_postgres/*.sqlScripts d'initialisation de la base de données PostgreSQL
vault-init.shInitialise Vault et stocke les secrets
rotate-secrets.shFait tourner les mots de passe de base de données de manière sécurisée
{% endtab %} {% tab title="3. Tâches de pré-déploiement" %} {% hint style="info" %} #### Tâches de pré-déploiement La section des tâches de pré-déploiement 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 modifiant le `.env.template` fichier avec les paramètres spécifiques à votre déploiement. Cela inclut la définition de la version de Pentaho et des détails de l'image, des identifiants PostgreSQL et de la configuration du port (par défaut 5432), des ports HTTP et HTTPS de Pentaho (8090 et 8443), de l'allocation mémoire JVM (minimum 4 Go, maximum 8 Go), de l'URL du serveur de licence et des paramètres du port Vault. Une fois configuré, ce modèle est enregistré comme le `.env` fichier. Le réglage des performances PostgreSQL est géré via le `postgres-config/custom.conf` fichier, où vous pouvez personnaliser les limites de connexion (200 connexions max par défaut), les paramètres d'allocation mémoire, y compris shared buffers et les tailles de cache, ainsi que 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 éventuellement le mettre à niveau en le téléchargeant depuis Maven Central ou en le copiant depuis la collection de pilotes de base de données de l'atelier. Cette préparation garantit que tous les fichiers, configurations et identifiants requis sont correctement préparés avant d'exécuter le script de déploiement automatisé. {% endhint %} *** **Configurer .env** 1. Modifier le fichier .env.template ```bash cd cd ~/Pentaho-Server-PostgreSQL nano .env.template ``` 2. Saisissez les détails suivants :
VariablePar défautDescription
PENTAHO_VERSION11.0.0.0-237Version du serveur Pentaho
PENTAHO_IMAGE_NAMEpentaho/pentaho-serverNom de l'image Docker
PENTAHO_IMAGE_TAG11.0.0.0-237Tag de l'image Docker
POSTGRES_PASSWORDpasswordMot de passe root PostgreSQL
POSTGRES_PORT5432Port exposé PostgreSQL
PENTAHO_HTTP_PORT8090Port HTTP Pentaho
PENTAHO_HTTPS_PORT8443Port HTTPS Pentaho
PENTAHO_MIN_MEMORY4096mTaille minimale du heap JVM
PENTAHO_MAX_MEMORY8192mTaille maximale du heap JVM
LICENSE_URL(vide)URL du serveur de licence EE
VAULT_PORT8200Port 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. Modifier le fichier .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 (ajustez selon la RAM disponible) shared_buffers = 256MB effective_cache_size = 768MB work_mem = 16MB # Performances 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 au démarrage du conteneur, puis traités par ordre alphabétique selon le nom du répertoire. {% 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 référentiel 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, valeurs 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 à niveau : 1. Téléchargez depuis [Maven Central](https://repo1.maven.org/maven2/org/postgresql/postgresql/) 2. Placez-le dans `softwareOverride/1_drivers/tomcat/lib/` Ou Copiez 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 vous guide à travers le processus de déploiement à l'aide soit du 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 validation préalable : ./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 s'il est manquant * Vérifie l'espace disque (10 Go minimum) * Vérifie que les ports requis sont disponibles * Construit l'image Docker du Pentaho Server * Démarre PostgreSQL et attend la vérification de bon fonctionnement * Démarre Pentaho Server et surveille le démarrage * Affiche les URL d'accès et les identifiants {% endhint %} 1\. Définissez les permissions d'exécution sur les scripts de déploiement. ```bash cd cd ~/Pentaho-Server-PostgreSQL chmod +x deploy.sh chmod +x scripts/*.sh ``` 2. Déployez les conteneurs. {% hint style="danger" %} Assurez-vous qu'aucun service postgresql n'est en cours d'exécution : ```bash systemctl stop postgresql ``` {% endhint %} ```bash cd cd ~/Pentaho-Server-PostgreSQL && ./deploy.sh ``` {% tabs %} {% tab title="Phase de pré-déploiement et de compilation" %} {% hint style="info" %} **Vérifications préalables ✓** Le script valide l'environnement avant de démarrer : * Docker est installé * Docker Compose est installé * Le daemon Docker est en cours d'exécution * Le package Pentaho a été 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 compilation** Une image Docker personnalisée est construite avec **24 étapes de compilation** prenant environ **5 à 10 minutes**: * Image de base : `debian:trixie-slim` * Installe les paquets système via `apt-get update` et `apt-get upgrade` * Installe **JRE headless OpenJDK 21** avec `curl` et `rm` * Crée un `pentaho` utilisateur et un groupe (GID 5000) * (Facultatif) Installe les plugins Pentaho (PAZ, PIR, PDD) * Copie l'installation Pentaho vers `/opt/pentaho/` * Exporte les couches et les manifestes * **Image finale**: `pentaho/pentaho-server:11.0.0.0-237` {% endhint %}

Vérifications préalables et compilation

{% endtab %} {% tab title="Déploiement et état final" %} {% hint style="info" %} **Démarrage de la base de données PostgreSQL** Récupère **PostgreSQL 15** l'image et les 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 que PostgreSQL soit prêt : **✓ PostgreSQL est prêt** **Démarrage de Pentaho Server** Cette phase prend **2 à 3 minutes pour l'initialisation initiale**: **Récupère l'image HashiCorp Vault 1.15** pour la gestion des secrets **Crée les volumes :** * `pentaho-server-postgresql_pentaho_solutions` * `pentaho-server-postgresql_pentaho_data` * `pentaho-server-postgresql_vault_data` {% endhint %}

Déployer les conteneurs

{% hint style="info" %} **État final** 🎉 Le déploiement est réussi et vous fournit : **Accès à 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 journaux | `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 d'assistance 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 %}

Assistant

{% endtab %} {% endtabs %} {% endtab %} {% tab title="Compilation manuelle" %} {% hint style="info" %} #### Compilation manuelle {% endhint %} 1. Construisez 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 opérationnel docker compose logs -f postgres ``` {% hint style="info" %} Surveillez le message indiquant que PostgreSQL est prêt à accepter les connexions. {% endhint %} 3. Démarrez 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 initiale. Surveillez le message : ``` Démarrage du serveur en [X] millisecondes ``` {% endhint %} {% endtab %} {% endtabs %} 3. Vérifiez l'état du conteneur. ```bash docker compose ps ``` ```bash cd cd ~/Pentaho-Server-PostgreSQL make status ``` 4. Exécutez le script de validation. ```bash cd cd ~/Pentaho-Server-PostgreSQL/scripts && ./validate-deployment.sh ```

Valider le déploiement

5. Ouvrez un navigateur web et accédez à : {% embed url="" %} 5. Connectez-vous avec les identifiants par défaut : | Nom d'utilisateur | Administration | | ----------------- | -------------- | | Mot de passe | password | 6. Saisissez l’URL du serveur de licence

Saisissez les détails de licence

{% endtab %} {% tab title="5. Sauvegarde et restauration" %} {% hint style="info" %} #### Sauvegarde et restauration Mettez en place des sauvegardes régulières pour protéger vos données et votre configuration Pentaho. {% endhint %} 1. Créez 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 ```

Script de sauvegarde

{% endtab %} {% endtabs %} --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://academy.pentaho.com/pentaho-11-installation-en/pentaho-11-installation-fr/installation/containers/docker.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.