# Préparer l'environnement

{% hint style="info" %}

#### **Préparer l'environnement**

Préparez votre serveur Ubuntu pour une installation Archive du serveur Pentaho.

Ce processus va :

* Créez une `pentaho` utilisateur d'installation (avec sudo)
* Définir les chemins Pentaho - `$PENTAHO_BASE`
* Installer Java 21 (OpenJDK)
* Définir `PENTAHO_JAVA_HOME`
* Installer PostgreSQL 17 (15 pris en charge pour Pentaho 11)
* Créer l'utilisateur de la base de données du dépôt - `pentaho` pour la configuration
* Installer pgAdmin 4 (bureau)
  {% endhint %}

{% hint style="warning" %}
Base Linux prise en charge pour Pentaho 11.x : Ubuntu 24.04 LTS.

Pour les versions et la compatibilité, voir [Référence des composants](https://docs.pentaho.com/install/pdia-11.0-installation/components-reference).
{% endhint %}

{% stepper %}
{% step %}
**Prérequis**

1. Assurez-vous que unzip est installé.

```bash
unzip --version
```

2. Définissez les variables de chemin Pentaho.
   {% endstep %}

{% step %}
**Créer un utilisateur d'installation Pentaho**

{% hint style="danger" %}
Pour la production, utilisez un compte d'installation dédié avec uniquement les privilèges requis et évitez le partage des identifiants.
{% endhint %}

1. Mettre à jour les paquets (exécuter une fois) :

```bash
sudo apt update -y && sudo apt upgrade -y
```

2. Ajouter l'utilisateur et définir un mot de passe :

```bash
sudo adduser pentaho
```

3. Accorder les privilèges sudo :

```bash
sudo usermod -aG sudo pentaho
```

4. Valider l'accès :

```bash
su - pentaho
groups
sudo -v
```

{% endstep %}

{% step %}
**Installer Java 21 (OpenJDK)**

{% hint style="info" %}
Pentaho 11.x est certifié avec Java 21.
{% endhint %}

<details>

<summary>Quelle est la différence entre Oracle JDK et OpenJDK ?</summary>

Oracle JDK et OpenJDK sont tous deux des implémentations de la plateforme Java, mais ils présentent quelques différences importantes :

**Licence et coût :**

* **OpenJDK** est entièrement gratuit et open source sous licence GPL. Vous pouvez l'utiliser à toutes fins sans restrictions.
* **Oracle JDK** a changé son modèle de licence en 2019. Il est désormais gratuit pour le développement et l'utilisation personnelle, mais nécessite un abonnement payant pour une utilisation commerciale en production (Oracle Java SE Subscription).

**Source et développement :**

* **OpenJDK** est l'implémentation de référence de Java et sert de base à la plupart des distributions JDK. Oracle contribue en fait de manière significative au développement d'OpenJDK.
* **Oracle JDK** est construit à partir du code source d'OpenJDK mais inclut certains composants propriétaires supplémentaires et des fonctionnalités commerciales.

**Performances et fonctionnalités :**

* Dans les versions modernes (Java 11+), les différences de performances sont négligeables. Oracle a reversé la plupart de ses améliorations de performances à OpenJDK.
* Oracle JDK incluait historiquement des outils et fonctionnalités supplémentaires (comme Java Flight Recorder et Java Mission Control), mais beaucoup d'entre eux ont été open-sourcés et sont maintenant disponibles dans OpenJDK.

**Support et mises à jour :**

* **OpenJDK** reçoit un support communautaire et des mises à jour pendant environ 6 mois par version (sauf pour les versions LTS maintenues par divers fournisseurs).
* **Oracle JDK** offre un support à long terme (LTS) avec des abonnements commerciaux, fournissant des mises à jour et des correctifs de sécurité sur des périodes prolongées.

**Autres distributions :** De nombreux fournisseurs proposent leurs propres builds d'OpenJDK avec support à long terme, notamment Amazon Corretto, Azul Zulu, Eclipse Temurin (anciennement AdoptOpenJDK) et Red Hat OpenJDK.

Pour la plupart des développeurs et organisations, OpenJDK ou les distributions OpenJDK soutenues par des fournisseurs sont le choix par défaut sauf si vous avez spécifiquement besoin du support commercial d'Oracle.

</details>

1. Installer Java 21 :

```bash
sudo apt install -y openjdk-21-jre-headless
```

2. Vérifier Java :

```bash
java -version
which java
readlink -f $(which java)
```

<figure><img src="https://3016379417-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5WjeDOi3MsT9tY3oU6mQ%2Fuploads%2Fgit-blob-8a19d6063ecae3f70fe22b493f3bba90f3a5f379%2Fimage%20(1)%20(1)%20(1)%20(1)%20(1)%20(1)%20(1).png?alt=media" alt="Ubuntu apt installed OpenJDK versions list"><figcaption><p>Versions OpenJDK</p></figcaption></figure>

<figure><img src="https://3016379417-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5WjeDOi3MsT9tY3oU6mQ%2Fuploads%2Fgit-blob-a84208f3797716e8202c86be22e97330444117d2%2Fimage%20(2)%20(1)%20(1)%20(1).png?alt=media" alt="java -version output showing Java 21"><figcaption><p>Java 21</p></figcaption></figure>

{% hint style="info" %}
Si plusieurs versions de Java sont installées, sélectionnez la version par défaut :

```bash
sudo update-alternatives --config java
```

{% endhint %}
{% endstep %}

{% step %}
**Définir `PENTAHO_JAVA_HOME`**

Définir `PENTAHO_JAVA_HOME` globalement afin que le serveur Pentaho utilise systématiquement Java 21.

1. Éditez `/etc/environment`:

```bash
sudo nano /etc/environment
```

2. Ajouter (ou mettre à jour) la ligne suivante :

```bash
# set PENTAHO_JAVA_HOME
PENTAHO_JAVA_HOME=/usr/lib/jvm/java-21-openjdk-amd64
```

<figure><img src="https://3016379417-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5WjeDOi3MsT9tY3oU6mQ%2Fuploads%2Fgit-blob-36e72adb0086568a1dbd03deee07c8b2770ca994%2Fimage%20(41).png?alt=media" alt=""><figcaption><p>Définir PENTAHO_JAVA_HOME</p></figcaption></figure>

3. Enregistrez et rechargez l'environnement (ou déconnectez/ reconnectez-vous) :

```bash
source /etc/environment
```

4. Vérifier :

```bash
echo $PENTAHO_JAVA_HOME
```

***

{% hint style="info" %}
Alternative : définir pour un seul utilisateur uniquement dans `~/.bashrc`.
{% endhint %}

1. Modifier :

```bash
nano ~/.bashrc
```

2. Ajouter et appliquer :

```bash
export PENTAHO_JAVA_HOME=/usr/lib/jvm/java-21-openjdk-amd64
. ~/.bashrc
```

{% endstep %}

{% step %}
**Installer PostgreSQL 17**

{% hint style="info" %}
Le dépôt par défaut d'Ubuntu 24.04 fournit PostgreSQL 16 plus récent. Pour installer la 17, ajoutez le dépôt officiel PostgreSQL (PGDG).

Si une autre version de PostgreSQL est déjà présente, purgez-la d'abord pour éviter les conflits de port et de paquets (voir l'onglet optionnel « Nettoyer les installations précédentes »).

**Prérequis**\
Ubuntu 24.04\
Privilèges root ou accès sudo\
utiliser `sudo su` pour passer en root au lieu de pentaho (utilisateur par défaut)
{% endhint %}

{% tabs %}
{% tab title="Installer PostgreSQL 17" %}

1. Avant d'installer PostgreSQL, assurez-vous que votre système est à jour.

```bash
sudo apt update && sudo apt upgrade -y
```

2. Installer les paquets prérequis.

```bash
sudo apt install -y wget ca-certificates
```

3. Importer la clé GPG de PostgreSQL.

```bash
wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -
```

4. Ajouter le dépôt PostgreSQL

```bash
sudo sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
```

5. Mettre à jour la liste des paquets.

```bash
sudo apt update
```

6. Installer les paquets serveur et client PostgreSQL 17.

```bash
sudo apt update -y && sudo apt upgrade -y
sudo apt install -y postgresql-17 postgresql-contrib-17
```

{% hint style="info" %}
**Ce qui est installé :**

* `postgresql-17`: Serveur de base de données principal
* `postgresql-contrib-17`: Utilitaires et extensions supplémentaires
  {% endhint %}

7. Vérifier le service et la version :

```bash
sudo systemctl status postgresql --no-pager
psql --version
```

<figure><img src="https://3016379417-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5WjeDOi3MsT9tY3oU6mQ%2Fuploads%2Fgit-blob-8527a959906835ff118d258144aacc32318a1cb2%2Fimage%20(2)%20(1)%20(1).png?alt=media" alt=""><figcaption><p>PostgreSQL 17.7</p></figcaption></figure>

8. Nettoyage optionnel :

```bash
sudo apt autoremove -y
```

{% endtab %}

{% tab title="Optionnel : Installer PostgreSQL 16" %}

1. Assurez-vous que votre système Ubuntu est à jour.

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

2. Pour aider à l'installation du logiciel de base de données, installez les paquets suivants.

```bash
sudo apt install dirmngr ca-certificates software-properties-common apt-transport-https lsb-release curl -y
```

3. Importer la clé de signature du dépôt.

```bash
sudo apt install curl ca-certificates gnupg
curl https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/apt.postgresql.org.gpg >/dev/null
```

4. Créer le fichier de configuration du dépôt.

```bash
echo "deb [signed-by=/etc/apt/trusted.gpg.d/apt.postgresql.org.gpg] http://apt.postgresql.org/pub/repos/apt/ noble-pgdg main" | sudo tee /etc/apt/sources.list.d/pgdg.list
```

5. Mettez à jour votre liste de paquets à nouveau pour inclure le nouveau dépôt.

```bash
sudo apt update
```

6. Maintenant, installez le paquet serveur PostgreSQL 16.

```bash
sudo apt install -y postgresql-16 postgresql-client-16
psql --version
```

{% endtab %}

{% tab title="Optionnel : Nettoyer les installations précédentes" %}
Si une version non prise en charge de PostgreSQL est installée, purgez-la d'abord. Exécutez chaque commande séparément et vérifiez la sortie :

```bash
sudo apt-get --purge remove postgresql
sudo apt-get purge postgresql*
sudo apt-get --purge remove postgresql postgresql-doc postgresql-common
sudo apt autoremove -y
```

Vérifier les paquets résiduels :

```bash
dpkg -l | grep -i postgres
```

{% endtab %}
{% endtabs %}

{% hint style="info" %}
Validation :

```bash
sudo systemctl is-enabled postgresql
sudo ss -ltnp | grep 5432 || true
sudo -u postgres psql -c "SELECT version();"
```

{% endhint %}
{% endstep %}

{% step %}
**Créer l'utilisateur de base de données - pentaho**

{% hint style="info" %}
Lors de l'installation, PostgreSQL crée un superutilisateur local `postgres`. Définissez son mot de passe et (facultativement) créez un `pentaho` rôle.
{% endhint %}

{% hint style="danger" %}
Pour la production, évitez un superutilisateur permanent pour l'utilisation par l'application. Utilisez des rôles au moindre privilège et accordez uniquement ce qui est nécessaire. Le chemin de l'atelier ci‑dessous élève les privilèges pour simplifier la configuration.
{% endhint %}

1. Basculer vers l'utilisateur système postgres.

```bash
sudo -i -u postgres
```

2. Entrez dans le terminal interactif PostgreSQL.

```bash
psql
```

3. Vous devriez voir l'invite PostgreSQL :

```
postgres=#
```

4. Afficher les bases de données actuelles.

```
\l
```

{% hint style="info" %}
Cela répertorie toutes les bases de données. Vous devriez voir trois bases par défaut : postgres, template0 et template1.
{% endhint %}

5. Quitter.

```sql
q
```

6. Vérifier la version de PostgreSQL depuis SQL.

```sql
SELECT version();
```

7. Quitter l'invite PostgreSQL.

<pre class="language-sql"><code class="lang-sql"><strong>\q
</strong></code></pre>

8. Et quitter psql.

```sql
exit
```

***

**Créer l'utilisateur pentaho**

<figure><img src="https://3016379417-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5WjeDOi3MsT9tY3oU6mQ%2Fuploads%2Fgit-blob-e3528fc9de8520ef7238c4069e564e0c48575eb8%2Fimage%20(1)%20(1)%20(1)%20(1).png?alt=media" alt=""><figcaption></figcaption></figure>

1. Définir `postgres` mot de passe :

```bash
sudo -u postgres psql -c "ALTER USER postgres WITH PASSWORD 'SecurePassword123';"
```

2. Créez une `pentaho` utilisateur et accorder `SUPERUSER` privilèges :

```sql
sudo -u postgres psql -c "CREATE USER pentaho WITH PASSWORD 'SecurePassword123';"
sudo -u postgres psql -c "ALTER USER pentaho WITH SUPERUSER;" # Démo uniquement
```

{% hint style="info" %}

* `sudo -u postgres` - Exécuter la commande en tant qu'utilisateur système Linux `postgres` (qui a un accès local à PostgreSQL sans mot de passe)
* `psql -c` - Exécute une commande SQL unique et quitte
* `CREATE USER pentaho` - Crée un nouveau rôle/utilisateur PostgreSQL nommé `pentaho`
* `WITH PASSWORD 'SecurePassword123'` - Définit le mot de passe pour cet utilisateur

***

* `ALTER USER pentaho` - Modifie l' `pentaho` utilisateur
* `WITH SUPERUSER` - Accorde les privilèges complets de superutilisateur (peut tout faire : créer des bases, créer des utilisateurs, contourner toutes les permissions, etc.)
* `# Démo uniquement` - **Commentaire d'avertissement** indiquant que ceci est dangereux pour la production
  {% endhint %}

3. Tester la connexion en tant que `pentaho`:

```bash
sudo -u pentaho psql -d postgres -c "\conninfo"
```

{% endstep %}

{% step %}
**Optionnel : Autoriser les connexions distantes**

{% hint style="info" %} <mark style="color:vert;">Pour référence uniquement car la connexion à Postgresql via localhost</mark>

Par défaut, PostgreSQL n'accepte que les connexions locales. Pour les configurations localhost, vous n'avez pas besoin de cette étape.
{% endhint %}

1. Sauvegardez les configs et éditez `postgresql.conf` (PostgreSQL 17) :

```bash
sudo cp /etc/postgresql/17/main/postgresql.conf{,.bak}
sudo nano /etc/postgresql/17/main/postgresql.conf
```

2. Définir : `listen_addresses = '*'` (une interface/IP spécifique en production)

<figure><img src="https://3016379417-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5WjeDOi3MsT9tY3oU6mQ%2Fuploads%2Fgit-blob-8ec24c939427a85bee28a103a1aa0b71c3504238%2Fimage%20(1)%20(1)%20(1)%20(1)%20(1).png?alt=media" alt=""><figcaption><p>Définir le listener</p></figcaption></figure>

3. Enregistrer :

```
Ctrl + o
Entrée
Ctrl + x
```

{% endstep %}

{% step %}
**Configurer pg\_hba.conf**

{% hint style="info" %}
La **pg\_hba.conf** le fichier (configuration d'authentification basée sur l'hôte PostgreSQL) contrôle qui peut se connecter à votre base de données PostgreSQL et comment ils s'authentifient. Vous le configurez lors de l'installation pour définir des règles de sécurité pour l'accès à la base de données.

En production, vous modifierez les paramètres pour n'autoriser l'accès aux bases de données que pour les utilisateurs requis sur les IP des serveurs.
{% endhint %}

1. Configurer PostgreSQL pour utiliser l'authentification par mot de passe md5 `pg_hba.conf` .

```bash
sudo cp /etc/postgresql/17/main/pg_hba.conf{,.bak}
sudo nano /etc/postgresql/17/main/pg_hba.conf
```

2. Modifier manuellement le fichier :

<figure><img src="https://3016379417-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5WjeDOi3MsT9tY3oU6mQ%2Fuploads%2FT4ciA41ladztA8Qjiakd%2Fimage.png?alt=media&#x26;token=07a9f763-2e50-488a-bd05-2e548e4f762e" alt=""><figcaption></figcaption></figure>

<mark style="color:$primary;">Ou</mark>

2. Exécutez le script suivant.&#x20;

```bash
# Utilisez le chemin exact
PG_HBA_PATH=/etc/postgresql/17/main/pg_hba.conf

# Vérifier que le fichier existe
ls -la "$PG_HBA_PATH"

# Si cela fonctionne, alors exécutez :
sudo cp "$PG_HBA_PATH" "${PG_HBA_PATH}.backup"
sudo sed -i 's/^local[[:space:]]\+all[[:space:]]\+postgres[[:space:]]\+peer$/local   all             postgres                                scram-sha-256/' "$PG_HBA_PATH"
sudo sed -i 's/^local[[:space:]]\+all[[:space:]]\+all[[:space:]]\+peer$/local   all             all                                     scram-sha-256/' "$PG_HBA_PATH"
sudo sed -i '0,/^host[[:space:]]\+all[[:space:]]\+all[[:space:]]\+127\.0\.0\.1\/32[[:space:]]\+scram-sha-256$/s//host    all             all             0.0.0.0\/0               md5/' "$PG_HBA_PATH"

# Vérifier
sudo cat "$PG_HBA_PATH" | grep -E "^(local|host)[[:space:]]+(all|replication)"
```

<figure><img src="https://3016379417-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5WjeDOi3MsT9tY3oU6mQ%2Fuploads%2F3nP6gZNjqtUN0qtGhx5S%2Fimage.png?alt=media&#x26;token=d6b52293-1c42-483a-9fc0-cfd7dd71b0d3" alt=""><figcaption><p>SED : pg_hba.conf</p></figcaption></figure>

{% hint style="info" %}
Préférer `scram-sha-256` plutôt que `md5` dans `pg_hba.conf` pour un hachage de mot de passe plus fort sur les versions modernes de PostgreSQL.

Assurez-vous que votre pilote JDBC prend en charge SCRAM (par ex., les pilotes PostgreSQL récents). Si des problèmes de compatibilité surviennent, utilisez `md5` comme solution de repli.
{% endhint %}

3. Redémarrer le service PostgreSQL.

```bash
cd
systemctl restart postgresql
# Mot de passe : password
```

4. Autoriser le pare-feu (si activé) et redémarrer :

```bash
sudo ufw allow 5432/tcp || true
sudo systemctl restart postgresql
sudo ss -ltnp | grep 5432
```

{% endstep %}

{% step %}
**Installer pgAdmin 4 (bureau)**

Installez le client de bureau pgAdmin 4 en utilisant le dépôt officiel.

1. Ajouter le dépôt et la clé :

```bash
sudo install -d -m 0755 /etc/apt/keyrings
curl -fsS https://www.pgadmin.org/static/packages_pgadmin_org.pub | gpg --dearmor | sudo tee /etc/apt/keyrings/packages-pgadmin-org.gpg > /dev/null
source /etc/os-release
echo "deb [signed-by=/etc/apt/keyrings/packages-pgadmin-org.gpg] https://ftp.postgresql.org/pub/pgadmin/pgadmin4/apt/${UBUNTU_CODENAME} pgadmin4 main" | sudo tee /etc/apt/sources.list.d/pgadmin4.list
```

2. Installer pgAdmin 4 (bureau) :

```bash
sudo apt update -y && sudo apt upgrade -y
sudo apt install -y pgadmin4-desktop
```

3. Optionnel : vérifier l'entrée du dépôt

```bash
cat /etc/apt/sources.list.d/pgadmin4.list
```

4. Ajouter une connexion de serveur dans pgAdmin :

* Clic droit Serveurs → Enregistrer → Serveur
* Nom : `Pentaho`
* Connexion : hôte, port `5432`, utilisateur `pentaho`, mot de passe `SecurePassword123` (ne pas enregistrer en production)

<figure><img src="https://3016379417-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5WjeDOi3MsT9tY3oU6mQ%2Fuploads%2Fgit-blob-1bbb9ab627e0fffc62e850ae0e52b89b297e557f%2Fpgadmin4-login.png?alt=media" alt="Create server group dialog in pgAdmin"><figcaption><p>Créer un groupe de serveurs</p></figcaption></figure>

<figure><img src="https://3016379417-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5WjeDOi3MsT9tY3oU6mQ%2Fuploads%2Fgit-blob-2bdd43a37c215603d3c38759d046d28b150718f3%2Fserver-name.png?alt=media" alt="pgAdmin server group list"><figcaption><p>Groupe de serveurs</p></figcaption></figure>

<figure><img src="https://3016379417-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5WjeDOi3MsT9tY3oU6mQ%2Fuploads%2Fgit-blob-e22e4e088e1f25ec4d149ecb8119826bd08d4823%2Fconnection.png?alt=media" alt="pgAdmin new server connection dialog"><figcaption><p>Détails de connexion</p></figcaption></figure>

{% hint style="danger" %}
Ne sauvegardez pas les mots de passe en production. Privilégiez les trousseaux au niveau OS ou les coffres sécurisés.
{% endhint %}

<figure><img src="https://3016379417-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5WjeDOi3MsT9tY3oU6mQ%2Fuploads%2Fgit-blob-62e1c97e1a111a1551c8b98a92345a5fa7562570%2Fserver-pentaho.png?alt=media" alt="pgAdmin 4 main UI window"><figcaption><p>Interface pgAdmin 4</p></figcaption></figure>
{% endstep %}

{% step %}
**Valider l'environnement**

1. Vérifications rapides pour confirmer que tout est prêt pour l'étape suivante.

```bash
# Java
java -version
[ "$PENTAHO_JAVA_HOME" = "/usr/lib/jvm/java-21-openjdk-amd64" ] && echo OK || echo "Vérifiez PENTAHO_JAVA_HOME"

# PostgreSQL
sudo -u postgres psql -c "SELECT version();"
sudo systemctl status postgresql --no-pager | sed -n '1,5p'

```

<figure><img src="https://3016379417-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5WjeDOi3MsT9tY3oU6mQ%2Fuploads%2Fgit-blob-44d72e2547457772e1e78f796d21fcf0ccef37ec%2Fimage%20(39).png?alt=media" alt=""><figcaption><p>Valider le service PostgreSQL 17 ..</p></figcaption></figure>
{% endstep %}
{% endstepper %}

***