# Conteneurs Pentaho

{% hint style="info" %}

#### Conteneurs Pentaho

Le serveur Pentaho offre des options de déploiement flexibles pour s'adapter à une variété de stratégies d'infrastructure. Pour **sur site** environnements, les organisations peuvent déployer en utilisant Docker Compose pour des configurations simples sur un seul hôte, ou orchestrer à travers des clusters en utilisant Kubernetes (K8s & K3s) pour une plus grande évolutivité et résilience. 

Pour **cloud (hyperscalers)** déploiements, Pentaho fournit des images Docker préconstruites et optimisées conçues pour Amazon Web Services (EKS/ECR), Microsoft Azure (AKS) et Google Cloud Platform (GKE), permettant aux équipes de tirer parti des services Kubernetes gérés et du stockage natif cloud comme Amazon S3. À partir de Pentaho 11, ces images comportent des chemins d'installation standardisés, des variables d'environnement et des scripts d'entrypoint améliorés qui prennent en charge les substitutions 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 le serveur Pentaho sur site pour les charges de travail sensibles tout en déployant des conteneurs Carte ou des nœuds worker PDI dans le cloud pour gérer le traitement par rafales, mélangeant le contrôle de l'infrastructure locale avec l'élasticité des ressources cloud.
{% endhint %}

{% hint style="danger" %}
Les étapes suivantes sont destinées à configurer un environnement Laboratoire Pentaho et doivent être complétées afin de terminer les ateliers.

Assurez-vous d'avoir téléchargé l'atelier--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 plate-forme 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 permettant à 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 à (Nov 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 apparaître comme "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 les 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 et 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 & 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>` - Voir les journaux d'un 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 des environnements aux ressources limitées et pour l'informatique en périphérie (edge). Elle est empaquetée en un seul binaire ou en une image de conteneur minimale, ce qui la rend beaucoup plus facile à déployer et à gérer que Kubernetes standard. La distribution utilise SQLite3 comme magasin de données léger par défaut, bien qu'elle prenne également en charge etcd3, MySQL et Postgres pour les utilisateurs nécessitant des 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 processus. Cette approche unifiée automatise des tâches complexes comme la distribution des certificats et la configuration TLS, tout en maintenant la sécurité par défaut avec des paramètres judicieux pour les environnements légers. K3s a peu de dépendances externes, ne nécessitant qu'un noyau Linux moderne et des montages cgroup pour fonctionner.

K3s est fourni "avec tout le nécessaire" avec des composants essentiels pré-packagés, éliminant le besoin d'installation et de configuration séparées. Cela inclut containerd pour le runtime des conteneurs, Flannel pour le réseau, CoreDNS pour la découverte de services, Traefik pour l'ingress, et plusieurs autres contrôleurs critiques pour l'équilibrage de charge, les politiques réseau, le stockage et la gestion des images. Ce paquet complet rend K3s idéal pour la création rapide de clusters en périphérie, les déploiements IoT, les pipelines CI/CD et les 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 permettant à apt d'utiliser des dépôts via HTTPS.

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

3. Désactiver 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. Activer 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. Configurer 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    # Flannel VXLAN
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 :

{% hint style="info" %}

{% endhint %}

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

#### **Installation sur nœud unique**

{% 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 + worker)
- Containerd (runtime de conteneurs)
- Flannel (plugin CNI réseau)
- CoreDNS (DNS de cluster)
- Traefik (contrôleur d'ingress)
- Provisionneur local-path (stockage)
- Serveur de métriques
```

{% endhint %}

2. Configurer l'accès kubectl.

```bash
# Créer le répertoire kube config
mkdir -p ~/.kube

# Copier la config 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 des nœuds
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="https://3016379417-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5WjeDOi3MsT9tY3oU6mQ%2Fuploads%2FYhZj3NpxUvk2kMjvKZ0x%2Fimage.png?alt=media&#x26;token=a6392e51-c65f-4f5c-acee-2b38bf3bee78" alt=""><figcaption><p>Vérifier K3s</p></figcaption></figure>

5. Vérifier 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œud

{% endhint %}

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

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

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

#### Nœuds agents (workers)

Sur chaque nœud worker :

```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œud

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. Ajouter 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 pour kubectl
source <(kubectl completion bash)
complete -F __start_kubectl k
EOF

source ~/.bashrc
```

{% endtab %}

{% tab title="Post-installation" %}
{% hint style="info" %}

### Configuration post-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 (par défaut)   rancher.io/local-path   Delete          WaitForFirstConsumer   false                  5d21h
```

2. Configurer l'ingress Traefik

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

3. Installer Helm (optionnel 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 (optionnel - interface terminal)

```bash
# Installer k9s pour faciliter la gestion du cluster
curl -sS https://webinstall.dev/k9s | bash

# Lancer k9s
k9s
```

<figure><img src="https://3016379417-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5WjeDOi3MsT9tY3oU6mQ%2Fuploads%2FULtnDplq4U3aX3pXeJrm%2Fimage.png?alt=media&#x26;token=406e414e-daa4-4086-9bc0-3fba1680a49e" 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="https://3016379417-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5WjeDOi3MsT9tY3oU6mQ%2Fuploads%2FIge7uTujHyuX8SAY0NiC%2Fimage.png?alt=media&#x26;token=f40d6b85-f9f2-40df-a578-9288c8f4d89c" 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 :

**Packaging**: Regroupant les ressources Kubernetes connexes

**Templating**: Paramétrant les manifests pour les rendre réutilisables entre environnements

**Versioning**: Gérant les versions d'application et les mises à jour

**Release Management**: Suivant les déploiements et permettant 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="https://3016379417-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5WjeDOi3MsT9tY3oU6mQ%2Fuploads%2F5ImRwrXKw8xYjm0T5iGh%2Fimage.png?alt=media&#x26;token=113d002f-3b0d-4926-8384-eeeb8eb8164a" 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# Install apt-transport-https package
```

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érifier 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

# Rend les templates de votre chart Helm localement et affiche la sortie, utile pour le débogage.
helm template

# Simule l'installation du chart sans le déployer réellement, vous permettant 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 release existante avec une nouvelle version du chart, essentiel pour maintenir et mettre à jour les applications.
helm --help

# Liste toutes les releases Helm dans l'espace de noms courant, utile pour suivre les applications déployées.
helm list

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

# Supprime une release Helm du cluster, supprimant les ressources Kubernetes associées.
helm delete RELEASE_NAME

# Restaure une release à une version précédente, utile pour revenir à un état stable si une mise à jour cause des problèmes.
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, vous assurant d'avoir les dernières versions disponibles.
helm repo update

# Emballe un chart Helm dans un fichier .tgz, qui peut être partagé ou téléchargé 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 allez avoir besoin d'un outil de gestion de base de données. DBeaver Community est un outil de gestion de base 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 Snapstore.

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

Ou

Allez sur le site officiel [page 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. Épingler DBeaver au Dash - barre d'outils inférieure.
   {% endtab %}

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

#### Make

Un makefile est simplement un moyen d'associer des noms courts, 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 nettoyant après le compilateur - suppression des fichiers objets et de l'exécutable résultant.

Nous utiliserons des scripts d'aide Make pour rationaliser le processus de déploiement.
{% endhint %}

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

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

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

```bash
make -version
```

3. Installer le paquet make.

```bash
sudo apt install make
```

4. Vérifier l'installation.

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

{% endtab %}
{% endtabs %}