> 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/configuration/pentaho-containers.md).

# Conteneurs Pentaho

{% hint style="info" %}

#### 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.
{% endhint %}

{% hint style="danger" %}
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 :

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

Pour installer git :

```bash
sudo apt install git
```

{% endhint %}

Sélectionnez votre hôte de conteneur :

{% tabs %}
{% tab title="Docker" %}
{% hint style="info" %}

#### 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).
{% endhint %}

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

```bash
sudo apt update && sudo apt upgrade
```

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

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

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

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

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

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

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

```bash
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
```

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

```bash
sudo apt update && sudo apt upgrade
```

6. Installez Docker Engine, containerd et Docker Compose.

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

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

```bash
docker --version
```

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

```
Docker version 29.0.2, build 810xxxx
```

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

```bash
sudo systemctl status docker
```

Le service devrait afficher « active (running) ».

9. Quitter.

```bash
q
```

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

```bash
sudo docker run hello-world
```

{% hint style="info" %}
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.
{% endhint %}

***

{% hint style="info" %}

#### Sans sudo

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

1. Ajoutez votre utilisateur au groupe docker.

```bash
sudo usermod -aG docker $USER
```

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

```bash
newgrp docker
```

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

```bash
docker run hello-world
```

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

```bash
sudo systemctl enable docker.service
sudo systemctl enable containerd.service
```

***

{% hint style="info" %}

#### Vérification et tests

Pour confirmer que tout fonctionne correctement, exécutez les commandes suivantes :
{% endhint %}

Vérifier la version de Docker :

```bash
docker version
```

Afficher les informations système Docker :

```bash
docker info
```

Lister les conteneurs en cours d'exécution :

```bash
docker ps
```

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

```bash
docker ps -a
```

Lister les images téléchargées :

```bash
docker images
```

***

{% hint style="info" %}

#### 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
  {% endhint %}
  {% endtab %}

{% tab title="K3s" %}
{% hint style="info" %}

#### 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.
{% endhint %}

{% embed url="<https://docs.k3s.io/>" %}

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

```bash
sudo apt update && sudo apt upgrade
```

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

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

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

```bash
# 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
```

4. Activez le transfert IP.

```bash
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
```

5. Configurez le pare-feu.

```bash
# 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 :

{% tabs %}
{% tab title="Nœud unique" %}
{% hint style="info" %}

#### **Installation sur un seul nœud**

{% endhint %}

1. Vérifiez les exigences système.

```bash
# 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}')"
```

2. Installer K3s.

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

{% hint style="info" %}
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
```

{% endhint %}

2. Configurez l'accès à kubectl.

```bash
# 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

```bash
# 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
```

<figure><img src="/files/8708ee9e20c10ce4e9a1fc9c71e01fa937b0e928" alt=""><figcaption><p>Vérifier K3s</p></figcaption></figure>

5. Vérifiez l'installation de K3s.

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

{% endtab %}

{% tab title="Multi-nœud" %}
{% hint style="info" %}

#### Cluster multi-nœuds

{% endhint %}

#### Nœud serveur (plan de contrôle)

```bash
# 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 :

```bash
# 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 :

```bash
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
```

{% endtab %}

{% tab title="Alias kubectl" %}

1. Ajoutez des alias utiles.

```bash
# 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
```

{% endtab %}

{% tab title="Après l'installation" %}
{% hint style="info" %}

### Configuration après installation

{% endhint %}

1. Vérifier la classe de stockage par défaut

```bash
# 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
```

2. Configurer Traefik Ingress

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

3. Installer Helm (facultatif mais recommandé)

```bash
# 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)

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

# Lancer k9s
k9s
```

<figure><img src="/files/22f7a7c72ed9caaf9d4fa23d60487d2f5621ed86" alt=""><figcaption><p>K9s</p></figcaption></figure>

5\. Vérifier l'installation de K3s.

```bash
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
```

<figure><img src="/files/3bd6dea835033a188eb90663614a4f4e43a6af2b" alt=""><figcaption><p>Vérifier K3s</p></figcaption></figure>
{% endtab %}
{% endtabs %}
{% endtab %}

{% tab title="Helm" %}
{% hint style="info" %}

#### 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
{% endhint %}

1. Exécutez le script d'installation suivant.

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

<figure><img src="/files/beb9692814b4cd947940075c19dfd9460d0bf38d" alt=""><figcaption><p>Installer Helm</p></figcaption></figure>

ou

1. Ajoutez la clé GPG de Helm.

```bash
# 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
```

2. Installer les dépendances

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

3. Ajouter le dépôt Helm.

```bash
# 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

```

4. Mettez à jour la liste des paquets et installez.

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

# Installer Helm :
sudo apt-get install helm
```

5. Vérifiez l'installation.

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

***

**Commandes Helm**

```bash
# 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
```

{% endtab %}

{% tab title="DBeaver" %}
{% hint style="info" %}

#### 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.
{% endhint %}

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

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

Ou

Rendez-vous sur la page officielle [de téléchargement de DBeaver](https://dbeaver.io/download/)

{% embed url="<https://dbeaver.io/files/dbeaver-ce_latest_amd64.deb>" %}

Ou

Pour installer ce fichier DEB.

```bash
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
```

4. Épinglez DBeaver à Dash - barre d'outils inférieure.
   {% endtab %}

{% tab title="Faire" %}
{% hint style="info" %}

#### 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.
{% endhint %}

1. Mettre à jour le système d’exploitation.

```bash
sudo apt update && sudo apt upgrade
```

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

```bash
make -version
```

3. Installez le paquet make.

```bash
sudo apt install make
```

4. Vérifiez l’installation.

```bash
ls /usr/bin/make
```

{% 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/configuration/pentaho-containers.md?ask=<question>&goal=<endgoal>
```

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