Conteneurs Pentaho

Pentaho Server offre des options de déploiement flexibles adaptées à un éventail de stratégies d'infrastructure. Pour sur site les environnements, les organisations peuvent déployer à l'aide de Docker Compose pour des configurations simples sur un seul hôte, ou orchestrer sur des clusters à l'aide de Kubernetes (K8s et K3s) pour une plus grande évolutivité et résilience.

Pour cloud (hyperscaler) déploiements, Pentaho fournit des images Docker optimisées, préconstruites et conçues spécialement pour Amazon Web Services (EKS/ECR), Microsoft Azure (AKS) et Google Cloud Platform (GKE), permettant aux équipes d'exploiter des services Kubernetes gérés et un stockage natif du cloud comme Amazon S3. À partir de Pentaho 11, ces images disposent de chemins d'installation standardisés, de variables d'environnement et de scripts d'entrée améliorés qui prennent en charge les remplacements de configuration à l'exécution - ce qui signifie que les licences et les fichiers de configuration peuvent être injectés au démarrage sans reconstruire l'image.

Une hybride approche est également entièrement prise en charge, où les organisations peuvent exécuter Pentaho Server sur site pour les charges de travail sensibles tout en déployant des conteneurs de serveur Carte ou des nœuds de travail PDI dans le cloud pour gérer les pics de traitement, en combinant le contrôle de l'infrastructure locale avec l'élasticité des ressources cloud.

Les étapes suivantes sont destinées à la mise en place d'un environnement Pentaho Lab et doivent être effectuées dans l'ordre pour terminer les ateliers.

Assurez-vous d'avoir téléchargé le Workshop--Installation :

cd
git clone https://github.com/jporeilly/Workshop--Installation

Pour installer git :

sudo apt install git

Sélectionnez votre hôte de conteneur :

Docker

Docker est une plateforme qui permet aux développeurs d'empaqueter des applications et leurs dépendances dans des conteneurs légers et portables. Les conteneurs garantissent que les applications s'exécutent de manière cohérente dans différents environnements informatiques, des ordinateurs portables de développement aux serveurs de production. Cet atelier vous guidera à travers le processus complet d'installation de Docker Engine sur Ubuntu 24.04 LTS (Noble Numbat).

Avant d'installer Docker, mettez à jour votre liste de paquets existante.

sudo apt update && sudo apt upgrade

Installez les paquets qui permettent à apt d'utiliser des dépôts via HTTPS.

sudo apt install -y ca-certificates curl gnupg lsb-release

Créez un répertoire pour les keyrings et ajoutez la clé GPG de Docker.

sudo install -m 0755 -d /etc/apt/keyrings

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

sudo chmod a+r /etc/apt/keyrings/docker.gpg

Ajoutez le dépôt Docker à vos sources apt.

echo \\
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \\
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \\
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Maintenant que le dépôt Docker est ajouté, mettez à jour l'index des paquets.

sudo apt update && sudo apt upgrade

Installez Docker Engine, containerd et Docker Compose.

sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Vérifiez que Docker est installé correctement en vérifiant la version.

docker --version

Vous devriez voir une sortie similaire à celle-ci (novembre 2025) :

Docker version 29.0.2, build 810xxxx

Vérifiez que Docker Engine est en cours d'exécution.

sudo systemctl status docker

Le service devrait afficher « active (running) ».

Quitter.

Testez votre installation Docker en exécutant le conteneur hello-world.

sudo docker run hello-world

Cette commande télécharge une image de test et l'exécute dans un conteneur. Si elle réussit, vous verrez un message confirmant que Docker fonctionne correctement.

Sans sudo

Par défaut, Docker nécessite des privilèges sudo. Pour exécuter des commandes Docker sans sudo.

Ajoutez votre utilisateur au groupe docker.

sudo usermod -aG docker $USER

Appliquez la nouvelle appartenance au groupe (ou déconnectez-vous puis reconnectez-vous).

newgrp docker

Vérifiez que vous pouvez exécuter Docker sans sudo.

docker run hello-world

Assurez-vous que Docker démarre automatiquement au démarrage du système.

sudo systemctl enable docker.service
sudo systemctl enable containerd.service

Vérification et tests

Pour confirmer que tout fonctionne correctement, exécutez les commandes suivantes :

Vérifier la version de Docker :

docker version

Afficher les informations système Docker :

docker info

Lister les conteneurs en cours d'exécution :

docker ps

Lister tous les conteneurs (y compris ceux arrêtés) :

docker ps -a

Lister les images téléchargées :

docker images

Commandes courantes

Voici les commandes Docker essentielles que vous utiliserez régulièrement :

docker pull <image> - Télécharger une image depuis Docker Hub
docker images - Lister toutes les images locales
docker run <image> - Créer et démarrer un conteneur à partir d'une image
docker ps - Lister les conteneurs en cours d'exécution
docker ps -a - Lister tous les conteneurs
docker stop <container> - Arrêter un conteneur en cours d'exécution
docker rm <container> - Supprimer un conteneur arrêté
docker rmi <image> - Supprimer une image
docker logs <container> - Afficher les journaux du conteneur
docker exec -it <container> bash - Accéder au shell d'un conteneur en cours d'exécution

K3s

K3s est une distribution Kubernetes légère et entièrement conforme, conçue pour les environnements à ressources limitées et d'informatique en périphérie. Elle est fournie sous forme d'un binaire unique ou d'une image de conteneur minimale, ce qui la rend considérablement plus facile à déployer et à gérer que Kubernetes standard. La distribution utilise SQLite3 comme magasin de données léger par défaut, mais prend également en charge etcd3, MySQL et Postgres pour les utilisateurs ayant besoin d'options plus robustes.

La plateforme simplifie les opérations Kubernetes en regroupant tous les composants du plan de contrôle dans un seul binaire et un seul processus. Cette approche unifiée automatise des tâches complexes comme la distribution des certificats et la configuration TLS, tout en conservant par défaut une sécurité raisonnable grâce à des paramètres adaptés aux environnements légers. K3s a très peu de dépendances externes et ne nécessite, pour fonctionner, qu'un noyau Linux moderne et des points de montage cgroup.

K3s est livré « prêt à l'emploi » avec les composants essentiels préemballés, éliminant le besoin d'une installation et d'une configuration séparées. Cela inclut containerd pour l'exécution des conteneurs, Flannel pour le réseau, CoreDNS pour la découverte de services, Traefik pour l'ingress, ainsi que plusieurs autres contrôleurs critiques pour l'équilibrage de charge, les politiques réseau, le stockage et la gestion des images. Cette suite complète fait de K3s un choix idéal pour la création rapide de clusters dans des sites en périphérie, des déploiements IoT, des pipelines CI/CD et des environnements de développement.

K3s - Lightweight Kubernetes | K3sdocs.k3s.io

Avant d'installer Docker, mettez à jour votre liste de paquets existante.

sudo apt update && sudo apt upgrade

Installez les paquets qui permettent à apt d'utiliser des dépôts via HTTPS.

sudo apt install -y ca-certificates curl gnupg lsb-release

Désactivez le swap (recommandé pour Kubernetes).

# Désactiver le swap immédiatement
sudo swapoff -a

# Désactiver le swap de façon permanente
sudo sed -i '/ swap / s/^/#/' /etc/fstab

# Vérifier que le swap est désactivé
free -h | grep Swap

Activez le transfert IP.

sudo tee /etc/sysctl.d/k3s.conf <<EOF 
net.ipv4.ip_forward = 1 
net.bridge.bridge-nf-call-iptables = 1 
net.bridge.bridge-nf-call-ip6tables = 1 
EOF 
sudo sysctl --system

Configurez le pare-feu.

# Vérifier si UFW est actif
sudo ufw status

# Si UFW est actif, autoriser les ports requis
sudo ufw allow 6443/tcp    # API Kubernetes
sudo ufw allow 8472/udp    # VXLAN Flannel
sudo ufw allow 10250/tcp   # Kubelet
sudo ufw allow 80/tcp      # HTTP
sudo ufw allow 443/tcp     # HTTPS

Sélectionnez vos options de déploiement :

Installation sur un seul nœud

Vérifiez les exigences système.

# Vérifier les exigences système
echo "=== Informations système ==="
echo "OS : $(lsb_release -d | cut -f2)"
echo "Noyau : $(uname -r)"
echo "Cœurs CPU : $(nproc)"
echo "RAM totale : $(free -h | awk '/^Mem:/ {print $2}')"
echo "Disque disponible : $(df -h / | awk 'NR==2 {print $4}')"

Installer K3s.

# Installer le serveur K3s (inclut l'agent)
curl -sfL https://get.k3s.io | sh -

Cette commande :

- Télécharge et installe K3s

- Démarre le service K3s

- Installe kubectl

- Configure kubeconfig

Ce qui est installé :
- Serveur K3s (plan de contrôle + nœud de travail)
- Containerd (runtime de conteneurs)
- Flannel (plugin réseau CNI)
- CoreDNS (DNS du cluster)
- Traefik (contrôleur ingress)
- Provisionneur local-path (stockage)
- Serveur de métriques

Configurez l'accès à kubectl.

# Créer le répertoire de configuration kube
mkdir -p ~/.kube

# Copier la configuration K3s à l'emplacement standard
sudo cp /etc/rancher/k3s/k3s.yaml ~/.kube/config

# Corriger les permissions
sudo chown $(id -u):$(id -g) ~/.kube/config
chmod 600 ~/.kube/config

# Définir la variable d'environnement KUBECONFIG
echo 'export KUBECONFIG=~/.kube/config' >> ~/.bashrc
source ~/.bashrc

# Tester l'accès à kubectl
kubectl version --short

4. Vérifier l'installation

# Vérifier l'état du nœud
kubectl get nodes

# Sortie attendue :
# NAME         STATUS   ROLES                  AGE   VERSION
NAME      STATUS   ROLES           AGE     VERSION
pentaho   Ready    control-plane   5d20h   v1.34.3+k3s1

# Vérifier les pods système
kubectl get pods -A

Vérifiez l'installation de K3s.

cd
cd ~/Pentaho-K3s-PostgreSQL
./verify-k3s.sh

Cluster multi-nœuds

Nœud serveur (plan de contrôle)

# Installer le serveur K3s
curl -sfL https://get.k3s.io | sh -

# Obtenir le jeton du nœud (nécessaire pour les agents)
sudo cat /var/lib/rancher/k3s/server/node-token

Nœuds agents (travailleurs)

Sur chaque nœud travailleur :

# Définir les variables
K3S_URL="https://<server-ip>:6443"
K3S_TOKEN="<node-token-from-server>"

# Installer l'agent K3s
curl -sfL https://get.k3s.io | K3S_URL=$K3S_URL K3S_TOKEN=$K3S_TOKEN sh -

Vérifier le cluster multi-nœuds

Sur le nœud serveur :

kubectl get nodes

# Sortie attendue :
# NAME         STATUS   ROLES                  AGE   VERSION
# server-01    Ready    control-plane,master   5m    v1.29.0+k3s1
# worker-01    Ready    <none>                 2m    v1.29.0+k3s1
# worker-02    Ready    <none>                 1m    v1.29.0+k3s1

Ajoutez des alias utiles.

# Ajouter des alias utiles
cat >> ~/.bashrc << 'EOF'

# Alias Kubernetes
alias k='kubectl'
alias kgp='kubectl get pods'
alias kgs='kubectl get svc'
alias kgn='kubectl get nodes'
alias kga='kubectl get all'
alias kd='kubectl describe'
alias kl='kubectl logs'
alias kaf='kubectl apply -f'
alias kdf='kubectl delete -f'

# Activer l'autocomplétion de kubectl
source <(kubectl completion bash)
complete -F __start_kubectl k
EOF

source ~/.bashrc

Configuration après installation

Vérifier la classe de stockage par défaut

# Vérifier la classe de stockage
kubectl get storageclass

# Sortie attendue :
NAME                   PROVISIONER             RECLAIMPOLICY   VOLUMEBINDINGMODE      ALLOWVOLUMEEXPANSION   AGE
local-path (default)   rancher.io/local-path   Delete          WaitForFirstConsumer   false                  5d21h

Configurer Traefik Ingress

kubectl get pods -n kube-system -l app.kubernetes.io/name=traefik

Installer Helm (facultatif mais recommandé)

# Installer Helm
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

# Vérifier
helm version

4. Installer k9s (facultatif - interface utilisateur terminale)

# Installer k9s pour une gestion de cluster plus facile
curl -sS https://webinstall.dev/k9s | bash

# Lancer k9s
k9s

5. Vérifier l'installation de K3s.

cd
cd ~/Pentaho-K3s-PostgreSQL

# Rendre le script exécutable
chmod +x scripts/verify-k3s.sh

# Exécuter la vérification
./scripts/verify-k3s.sh

Charts Helm

Helm est le gestionnaire de paquets pour Kubernetes, souvent appelé « apt/yum pour Kubernetes ». Il simplifie le déploiement et la gestion des applications Kubernetes en :

Empaquetage: Regrouper les ressources Kubernetes associées

Gabaritage: Paramétrer les manifestes pour les réutiliser dans différents environnements

Gestion des versions: Gérer les versions de l'application et les mises à niveau

Gestion des publications: Suivre les déploiements et permettre les retours en arrière

Exécutez le script d'installation suivant.

cd
cd ~/Pentaho-K3s-PostgreSQL/helm-chart
./install-helm.sh

Ajoutez la clé GPG de Helm.

# Ajouter la clé GPG de Helm
curl https://baltocdn.com/helm/signing.asc | gpg --dearmor | sudo tee /usr/share/keyrings/helm.gpg > /dev/null# Installer le paquet apt-transport-https

Installer les dépendances

# Installer le paquet apt-transport-https :
sudo apt-get install apt-transport-https --yes

Ajouter le dépôt Helm.

# Ajouter le dépôt Helm
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/helm.gpg] https://baltocdn.com/helm/stable/debian/ all main" | sudo tee /etc/apt/sources.list.d/helm-stable-debian.list

Mettez à jour la liste des paquets et installez.

# Mettre à jour la liste des paquets :
sudo apt-get update

# Installer Helm :
sudo apt-get install helm

Vérifiez l'installation.

# Vérifier l'installation de Helm :
helm version --client

Commandes Helm

# Vérifie votre chart Helm pour détecter des problèmes avant le déploiement.
helm lint

# Génère localement les modèles de votre chart Helm et affiche le résultat, utile pour le débogage.
helm template

# Simule l'installation du chart sans le déployer réellement, ce qui vous permet de vérifier les modifications.
helm install my-chart . --dry-run

# Fournit la liste de toutes les commandes et options Helm disponibles.
helm --help

# Met à jour une publication existante avec une nouvelle version du chart, essentiel pour maintenir et mettre à niveau les applications.
helm --help

# Répertorie toutes les publications Helm dans l'espace de noms actuel, utile pour suivre les applications déployées.
helm list

# Récupère les valeurs utilisées pour une publication spécifique, vous permettant de consulter ou modifier les paramètres de configuration.
helm get values RELEASE_NAME

# Supprime une publication Helm du cluster, en retirant les ressources Kubernetes associées.
helm delete RELEASE_NAME

# Rétablit une publication à une version précédente, utile pour revenir à un état stable si une mise à jour pose problème.
helm rollback RELEASE_NAME REVISION

# Ajoute un dépôt de charts Helm, vous permettant de télécharger des charts depuis différentes sources.
helm repo add REPO_NAME REPO_URL

# Met à jour le cache local des dépôts de charts, en vous assurant de disposer des dernières versions disponibles.
helm repo update

# Empaquette un chart Helm dans un fichier .tgz, qui peut être partagé ou téléversé dans un dépôt.
helm package CHART_PATH

# Pousse un chart empaqueté vers un dépôt Helm, facilitant la distribution et le déploiement.
helm push CHART_PATH REPO_NAME

DBeaver

Vous aurez besoin d'un outil de gestion de base de données. DBeaver Community est un outil de gestion de bases de données gratuit et open source pour les projets personnels.

L'option la plus simple est de télécharger et d'installer depuis le Snap Store.

cd
sudo apt update && sudo apt upgrade
sudo apt install snapd
sudo snap install dbeaver-ce

Rendez-vous sur la page officielle de téléchargement de DBeaver

https://dbeaver.io/files/dbeaver-ce_latest_amd64.debdbeaver.io

Pour installer ce fichier DEB.

wget https://dbeaver.io/debs/dbeaver.gpg.key -O /tmp/dbeaver.gpg.key
sudo gpg --dearmor -o /usr/share/keyrings/dbeaver.gpg /tmp/dbeaver.gpg.key
echo "deb [signed-by=/usr/share/keyrings/dbeaver.gpg] https://dbeaver.io/debs/dbeaver-ce /" | sudo tee /etc/apt/sources.list.d/dbeaver.list
sudo apt update
sudo apt install dbeaver-ce

Épinglez DBeaver à Dash - barre d'outils inférieure.

Faire

Un makefile est simplement un moyen d’associer de brefs noms, appelés cibles, à une série de commandes à exécuter lorsque l’action est demandée. Par exemple, une cible courante d’un makefile est « clean », qui effectue généralement des actions de nettoyage après le compilateur — en supprimant les fichiers objet et l’exécutable obtenu.

Nous utiliserons des scripts d’aide Make pour simplifier le processus de déploiement.

Mettre à jour le système d’exploitation.

sudo apt update && sudo apt upgrade

Vérifiez si make est déjà installé.

make -version

Installez le paquet make.

sudo apt install make

Vérifiez l’installation.

ls /usr/bin/make

PrécédentLaboratoire Pentaho Windows SuivantQuestions fréquentes

Mis à jour il y a 24 jours

Ce contenu vous a-t-il été utile ?