> 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/ubuntu-pentaho-lab.md).

# Laboratoire Pentaho Ubuntu

{% hint style="info" %}

#### **Laboratoire Pentaho**

Pentaho Data Integration est un outil client généralement installé et configuré pour fonctionner sous Windows 11.

Il existe plusieurs options de licence ; pour ces ateliers, nous allons installer une édition Enterprise. Cela vous donnera l’occasion d’essayer de construire une solution complète - pipelines de données automatisés + analytique ..
{% endhint %}

<figure><img src="/files/b637469a734b1aa81494669c15ca0f4f79818a1b" alt=""><figcaption><p>Niveaux Pentaho</p></figcaption></figure>

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

{% hint style="info" %}
**Prérequis**

* Système Ubuntu 24.04 LTS (machine physique ou virtuelle)
* Compte utilisateur avec privilèges sudo
* Connexion Internet
* Familiarité de base avec la ligne de commande Linux
  {% endhint %}

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

#### **Docker Compose - MySQL**

L’utilisateur pentaho\_admin n’a que l’autorisation de LECTURE sur la base de données Steel Wheels - sampledata. Le compte administrateur a été supprimé.

Comme vous allez effectuer des opérations de base de données CRUID, nous devons déployer une base de données sampledata sous forme de conteneur Docker, en accordant tous les privilèges à un utilisateur administrateur.
{% endhint %}

{% file src="/files/2028ce117f12ca5c20df94bfbc27b2beabb43013" %}

{% file src="/files/8d6ee11ebb5d6e1f462bfdc170f0d380124a5529" %}

{% file src="/files/15be85785c9e8aaf355147cf2b828d55672b9a07" %}

1. Exécutez le script suivant pour créer un dossier MySQL et copier les fichiers requis.

```bash
cd
cd ~/Workshop--Installation/MySQL
# Rendre exécutable
chmod +x copy_mysql.sh
./copy_mysql.sh
```

2. Vérifiez que le répertoire a été créé et que les fichiers ont été copiés.
3. Exécutez le script docker-compose pour créer le conteneur.

```bash
cd
cd ~/MySQL
# Rendre exécutable
chmod +x run_mysql_compose.sh
./run_mysql_compose.sh
```

<figure><img src="/files/4b77c05fe33a142811ac1e5a725a3c8d99bfc226" alt="" width="500"><figcaption><p>Déployer le conteneur Docker MySQL</p></figcaption></figure>

4. Vérifiez que le conteneur est en cours d'exécution dans Docker.

```
docker ps
```

<figure><img src="/files/a3787f728dd8acfb83cf29d367d35c1f2f738a41" alt=""><figcaption><p>Conteneurs MySQL Docker</p></figcaption></figure>
{% endtab %}

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

#### **Données d’exemple**

L’élément suivant de la liste consiste à créer la base de données sampledata.
{% endhint %}

<figure><img src="/files/6db1c3c711e108c6997411513a3412e66fd2bf84" alt=""><figcaption><p>Diagramme relationnel</p></figcaption></figure>

{% tabs %}
{% tab title="1. sampledata\_schema.sql" %}
{% hint style="info" %}

#### **sampledata\_schema.sql**

Ce script crée une structure de base de données relationnelle complète pour une application d’entreprise d’exemple. Il est conçu pour modéliser un système de gestion des ventes et des commandes pour une société qui vend divers produits.
{% endhint %}

{% hint style="info" %}

#### **Configuration de la base de données**

* Crée une base de données nommée

  ```
  sampledata
  ```

  avec un jeu de caractères UTF-8
* Configure des utilisateurs avec les autorisations appropriées
* Configure le mode SQL pour une meilleure intégrité des données
  {% endhint %}

{% hint style="info" %}

#### **Tables**

**OFFICES**: Stocke les emplacements des bureaux de l’entreprise avec les détails d’adresse

**EMPLOYEES**: Contient les informations des employés avec les relations vers les bureaux et la structure hiérarchique

**CUSTOMERS**: Stocke les informations clients, y compris les coordonnées et les limites de crédit

**PRODUCTS**: Contient le catalogue des produits avec les informations d’inventaire et de tarification

**ORDERS**: Suit les commandes clients avec leur statut et leurs dates

**ORDERDETAILS**: Contient les lignes de commande pour chaque commande avec la quantité et le prix

**PAYMENTS**: Enregistre les paiements des clients avec les montants et les dates

**ORDERFACT**: Une table de faits pour l’analyse des commandes

**CUSTOMER\_W\_TER**: Informations client étendues avec le territoire

**DIM\_TIME**: Table dimension temps pour les rapports

**DEPARTMENT\_MANAGERS**: Stocke les informations sur les responsables de département

**QUADRANT\_ACTUALS**: Contient les données financières budgetées par rapport aux données réelles avec une colonne VARIANCE générée

**TRIAL\_BALANCE**: Données comptables financières
{% endhint %}

{% hint style="info" %}

#### **Vues**

**customer\_order\_summary**: Résume les commandes et les dépenses par client

**product\_performance**: Analyse les indicateurs de vente des produits, y compris le chiffre d’affaires et le profit

**employee\_sales\_performance**: Suit les performances commerciales par employé

**monthly\_sales\_trend**: Affiche les tendances des ventes au fil du temps par mois

**product\_inventory\_status**: Catégorise les produits selon les niveaux de stock

**customer\_payment\_history**: Résume l’activité de paiement des clients et les soldes
{% endhint %}

{% hint style="info" %}

#### **Procédures stockées**

**GetCustomerOrders**: Récupère les commandes d’un client spécifique

**UpdateProductStock**: Met à jour les niveaux de stock des produits

**GetProductSalesByQuarter**: Analyse les ventes de produits par trimestre

**GetTopCustomersByRegion**: Identifie les meilleurs clients par région

**GetInventoryValueByProductLine**: Calcule les indicateurs de stock par ligne de produits

**Déclencheurs**

**before\_order\_insert**: Valide les contraintes de date sur les commandes

**before\_payment\_insert**: Garantit que les montants des paiements sont positifs
{% endhint %}

{% hint style="info" %}

#### **Événements**

* **daily\_maintenance**: Tâche planifiée pour la maintenance de la base de données
  {% endhint %}

1. Exécutez la commande suivante pour créer le schéma.

```bash
cd 
cd ~/MySQL
cat sampledata_schema.sql | docker exec -i mysql-database-1 mysql -u root -p"password" sampledata
```

{% hint style="info" %}
Cette commande importe les données du schéma SQL dans une base de données MySQL exécutée dans un conteneur Docker. Voici un aperçu :

Cette commande lit le fichier SQL :

```powershell
cat sampledata_schema.sql
```

Transmet le contenu du fichier à la commande suivante :

```
|
```

Cette commande exécute une commande dans un conteneur Docker en cours d’exécution :

```
docker exec -i mysql-database-1 mysql -u root -p"password" sampledata
```

{% endhint %}

2. Vous pouvez vérifier la base de données et les tables sampledata avec les commandes suivantes.

Afficher les bases de données :

```powershell
docker exec -i mysql-database-1 mysql -u root -p"password" -e "SHOW DATABASES;"
```

Afficher les tables :

```powershell
docker exec -i mysql-database-1 mysql -u root -p"password" sampledata -e "SHOW TABLES;"
```

Afficher les colonnes de la table :

```powershell
docker exec -i mysql-database-1 mysql -u root -p"password" sampledata -e "DESCRIBE table_name;"
```

{% endtab %}

{% tab title="2. sampledata\_data.sql" %}
{% hint style="info" %}

#### **sampledata\_data.sql**

Ce script remplit la base de données avec des données d’exemple pour démontrer la fonctionnalité du schéma.
{% endhint %}

{% hint style="info" %}

#### **Données de référence**

* Emplacements des bureaux dans différentes régions
* Hiérarchie des employés avec leurs intitulés de poste
* Catalogue de produits organisé par lignes de produits
  {% endhint %}

{% hint style="info" %}

#### **Données transactionnelles**

* Fiches clients avec informations de contact
* Historique des commandes avec dates et statut
* Détails des commandes avec quantités et prix
* Enregistrements des paiements
  {% endhint %}

{% hint style="info" %}

#### **Données financières**

* Chiffres budgétés par rapport aux chiffres réels dans QUADRANT\_ACTUALS
* Données comptables de balance de vérification
  {% endhint %}

{% hint style="info" %}

#### **Caractéristiques des données**

* Scénarios commerciaux réalistes avec des statuts de commande variés
* Catalogue de produits complet avec descriptions et tarifs
* Structure hiérarchique des employés avec liens hiérarchiques
* Données chronologiques couvrant plusieurs années pour l’analyse des tendances
* Données financières adaptées à la budgétisation et à l’analyse des écarts
  {% endhint %}

{% hint style="info" %}

#### **Fonctionnalités notables**

* Les données respectent les contraintes d’intégrité référentielle
* Gestion appropriée des valeurs NULL lorsque cela est pertinent
* Valeurs réalistes de prix et de quantité
* Les colonnes générées (comme VARIANCE) sont exclues des insertions directes
* Les commandes sont ordonnées pour respecter les contraintes de clé étrangère
  {% endhint %}

1. Exécutez la commande suivante pour charger les données dans les tables sampledata.

```bash
cd 
cd ~/MySQL
cat sampledata_data.sql | docker exec -i mysql-database-1 mysql -u root -p"password" sampledata
```

2. Vous pouvez utiliser les commandes suivantes pour vérifier que les données ont été chargées.

Pour compter le nombre de lignes dans une table spécifique :

```docker
docker exec -i mysql-database-1 mysql -u root -p"password" sampledata -e "SELECT COUNT(*) FROM table_name;"
```

Pour afficher les premières lignes d’une table :

```docker
docker exec -i mysql-database-1 mysql -u root -p"password" sampledata -e "SELECT * FROM table_name LIMIT 10;"
```

Pour vérifier les comptes pour toutes les tables :

```docker
docker exec -i mysql-database-1 mysql -u root -p"password" sampledata -e "SELECT TABLE_NAME, TABLE_ROWS FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = 'sampledata';"
```

Pour obtenir un résumé des tables et de leur statut :

```docker
docker exec -i mysql-database-1 mysql -u root -p"password" sampledata -e "SHOW TABLE STATUS;"
```

<figure><img src="/files/fc7466a13f6670bc7f97dcae9d55fa650a5c6baa" alt=""><figcaption><p>Vérifier les tables</p></figcaption></figure>
{% endtab %}
{% endtabs %}
{% 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.

***

{% hint style="info" %}

#### **Base de données MySQL**

Si vous avez rempli les 3 exigences précédentes, vous devriez disposer d’un conteneur Docker MySQL exposé sur le port 3306 avec la base de données sampledata.
{% endhint %}

1. Lancez DBeaver et sélectionnez : MySQL.

<figure><img src="/files/3afd2ed4ff2e312efde938d9eb70be74649e8645" alt=""><figcaption><p>MySQL</p></figcaption></figure>

2. Configurez la connexion avec les propriétés suivantes :

Nom d’utilisateur : root ou pentaho\_user

Mot de passe : password

<figure><img src="/files/a518180258d034f032db138ae63b4c7548e61c97" alt=""><figcaption><p>Configurer et tester la connexion MySQL - sampledata</p></figcaption></figure>

{% hint style="warning" %}
Vous devrez peut-être télécharger la version prise en charge du pilote de base de données.

Activez également : allowPublicKeyRetrieval
{% endhint %}

<figure><img src="/files/ddd6d8eac11489df40e5876f3f3a578a7cbf6fac" alt=""><figcaption><p>Activer : allowPublicKeyRetrieval</p></figcaption></figure>

3. Testez la connexion.

<figure><img src="/files/115526da023847bfd881cb2ce68b3d97d7c04dd2" alt=""><figcaption><p>Tester la connexion</p></figcaption></figure>

4. Développez : databases > sampledata > Tables

<figure><img src="/files/541b1ab7a7929ee75581e3772daf3c65d8cc7f4d" alt=""><figcaption><p>Données clients</p></figcaption></figure>

5. Ouvrez une fenêtre SQL et exécutez une requête de test.

```sql
select * from CUSTOMERS
where COUNTRY = 'USA' and CITY = 'NYC';
```

<figure><img src="/files/3123affb8ee8e5751491ca1d48a52b68d16252be" alt=""><figcaption><p>Requête SQL - Clients NYC</p></figcaption></figure>
{% endtab %}
{% endtabs %}

<details>

<summary>Dépannage général (cliquez pour développer)</summary>

**Problème : erreurs « permission denied »**

* Solution : Assurez-vous que votre utilisateur appartient au groupe docker et que vous vous êtes déconnecté/reconnecté ou exécutez `newgrp docker`

**Problème : le service Docker ne démarre pas**

* Solution : consultez les journaux avec `sudo journalctl -u docker.service`

**Problème : impossible de se connecter au démon Docker**

* Solution : assurez-vous que le service Docker est en cours d'exécution avec `sudo systemctl start docker`

</details>


---

# 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/ubuntu-pentaho-lab.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.
