> 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/installation/archive-installation/prepare-environment.md).

# 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 permettra de :

* 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 (la version 15 est prise en charge pour Pentaho 11)
* Créer l'utilisateur de base de données du référentiel - `pentaho` pour la configuration
* Installer pgAdmin 4 (version 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.

{% hint style="info" %}
Utilisez ces variables pour simplifier les commandes et éviter les erreurs de chemin. Pensez à les ajouter à votre profil de shell pour plus de commodité.
{% endhint %}

* Modifiez le fichier /etc/environment.

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

* Ajoutez les chemins suivants.

```bash
# Chemins Pentaho
PENTAHO_BASE=/opt/pentaho
PENTAHO_SERVER=/opt/pentaho/server/pentaho-server
TOMCAT_HOME=/opt/pentaho/server/pentaho-server/tomcat
```

{% hint style="warning" %}
Si vous ajoutez ces éléments à `~/.bashrc` ou `/etc/environment`, rouvrez votre shell ou `source` le fichier pour appliquer.
{% endhint %}

<figure><img src="/files/69ed4f24eeabdb1005309719266037aa7ca74feb" alt=""><figcaption><p>Chemins Pentaho</p></figcaption></figure>
{% endstep %}

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

{% hint style="danger" %}
En production, utilisez un compte d'installation dédié avec uniquement les privilèges nécessaires et évitez de partager les identifiants.
{% endhint %}

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

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

2. Ajoutez l'utilisateur et définissez un mot de passe :

```bash
sudo adduser pentaho
```

3. Accorder les privilèges sudo :

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

4. Vérifier 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 d'importantes différences :

**Licence et coût :**

* **OpenJDK** est entièrement gratuit et open source sous licence GPL. Vous pouvez l'utiliser à n'importe quelle fin sans restrictions.
* **Oracle JDK** a modifié son modèle de licence en 2019. Il est désormais gratuit pour le développement et l'usage personnel, 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 d'ailleurs de manière significative au développement d'OpenJDK.
* **Oracle JDK** est construit à partir du code source OpenJDK, mais inclut certains composants propriétaires et fonctionnalités commerciales supplémentaires.

**Performances et fonctionnalités :**

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

**Support et mises à jour :**

* **OpenJDK** reçoit le support de la communauté 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 de longues périodes.

**Autres distributions :** De nombreux éditeurs proposent leurs propres versions 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 des organisations, OpenJDK ou les distributions OpenJDK prises en charge par un éditeur sont le choix privilégié, 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="/files/9648c9c957a5fe96546f6b7a7739ea48c678c749" alt="Ubuntu apt installed OpenJDK versions list"><figcaption><p>Versions d'OpenJDK</p></figcaption></figure>

<figure><img src="/files/3ded017f696eda732e9505f1163f8eabcb8adc3e" 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. Modifiez `/etc/environment`:

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

2. Ajoutez (ou mettez à jour) la ligne suivante :

```bash
# définir PENTAHO_JAVA_HOME
PENTAHO_JAVA_HOME=/usr/lib/jvm/java-21-openjdk-amd64
```

<figure><img src="/files/9f2bf77a90dce93fdd3a6d1eb3caa11dd6ad388a" alt=""><figcaption><p>Définir PENTAHO_JAVA_HOME</p></figcaption></figure>

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

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

4. Vérifier :

```bash
echo $PENTAHO_JAVA_HOME
```

***

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

1. Modifier :

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

2. Ajoutez à la fin et appliquez :

```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 version 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 facultatif « 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 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="/files/e433c1837411bff09003ded2b8b9e8585500dd12" alt=""><figcaption><p>PostgreSQL 17.7</p></figcaption></figure>

8. Nettoyage facultatif :

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

{% endtab %}

{% tab title="Facultatif : installer PostgreSQL 16" %}

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

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

2. Pour faciliter 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 à nouveau votre liste de paquets pour inclure le nouveau dépôt.

```bash
sudo apt update
```

6. Installez maintenant le paquet serveur PostgreSQL 16.

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

{% endtab %}

{% tab title="Facultatif : 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 examinez 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" %}
Vérification :

```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 créez éventuellement un `pentaho` rôle dédié.
{% endhint %}

{% hint style="danger" %}
En production, évitez d'utiliser un superutilisateur permanent pour l'application. Utilisez des rôles au moindre privilège et n'accordez que ce qui est nécessaire. La procédure de démonstration ci-dessous élève les privilèges pour simplifier la configuration.
{% endhint %}

1. Passez à l'utilisateur système postgres.

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

2. Ouvrez 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 de données 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="/files/95cb9158bf77c64ce88ec06c8460e95ff6d9dc08" 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` les 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émonstration uniquement
```

{% hint style="info" %}

* `sudo -u postgres` - Exécutez 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 seule commande SQL et quitte
* `CREATE USER pentaho` - Crée un nouveau rôle/utilisateur PostgreSQL nommé `pentaho`
* `WITH PASSWORD 'SecurePassword123'` - Définit le mot de passe de cet utilisateur

***

* `ALTER USER pentaho` - Modifie l'utilisateur existant `pentaho` utilisateur
* `WITH SUPERUSER` - Accorde tous les privilèges de superutilisateur (peut tout faire : créer des bases de données, créer des utilisateurs, contourner toutes les autorisations, etc.)
* `# Démonstration uniquement` - **Commentaire d'avertissement** indiquant que cela 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 %}
**Facultatif : autoriser les connexions distantes**

{% hint style="info" %} <mark style="color:vert;">À titre de référence uniquement, car la connexion à PostgreSQL se fait via localhost</mark>

Par défaut, PostgreSQL n'accepte que les connexions locales. Pour des configurations en localhost, cette étape n'est pas nécessaire.
{% endhint %}

1. Sauvegardez les configurations et modifiez `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="/files/ea1584a4512bd9af9ef76e6275a362a8d6d0cdc1" alt=""><figcaption><p>Définir l'écouteur</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 de l'authentification basée sur l'hôte de PostgreSQL) contrôle qui peut se connecter à votre base de données PostgreSQL et comment ils s'authentifient. Vous le configurez pendant l'installation pour définir les règles de sécurité d'accès à la base de données.

En production, vous modifieriez les paramètres pour n'autoriser que les utilisateurs requis à accéder aux bases de données 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 le fichier manuellement :

<figure><img src="/files/c7565134bd7872048a24a23c5e8bb1f4a4e511cc" alt=""><figcaption></figcaption></figure>

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

2. Exécutez le script suivant.

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

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

# Si cela fonctionne, exécutez ensuite :
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="/files/3145e6398d6dd09e3623f5ec357a1cd0bd2a61ed" alt=""><figcaption><p>SED : pg_hba.conf</p></figcaption></figure>

{% hint style="info" %}
Préférez `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 exemple, les pilotes PostgreSQL récents). Si des problèmes de compatibilité surviennent, utilisez `md5` comme solution de repli.
{% endhint %}

3. Redémarrez le service PostgreSQL.

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

4. Autorisez le pare-feu (s'il est activé) et redémarrez :

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

{% endstep %}

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

Installez le client de bureau pgAdmin 4 à l'aide du 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 (version bureau) :

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

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

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

4. Ajouter une connexion serveur dans pgAdmin :

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

<figure><img src="/files/66e3d25e2806b5bf2a4afafe81487e7c4556871e" alt="Create server group dialog in pgAdmin"><figcaption><p>Créer un groupe de serveurs</p></figcaption></figure>

<figure><img src="/files/ff03eef25cb188fdac829b13a173a86e31e5a5c0" alt="pgAdmin server group list"><figcaption><p>Groupe de serveurs</p></figcaption></figure>

<figure><img src="/files/8579f1955f49eab0b217e8c85b459a1fb0e5863e" alt="pgAdmin new server connection dialog"><figcaption><p>Détails de connexion</p></figcaption></figure>

{% hint style="danger" %}
N'enregistrez pas les mots de passe en production. Privilégiez les trousseaux de clés au niveau du système d'exploitation ou des coffres-forts sécurisés.
{% endhint %}

<figure><img src="/files/d6beb73c82ada978404a88e79d230d082dca982b" alt="pgAdmin 4 main UI window"><figcaption><p>Interface utilisateur de 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 "Check PENTAHO_JAVA_HOME"

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

```

<figure><img src="/files/76415b333d4fe65f141ca0bc5d998f126e1a73c1" alt=""><figcaption><p>Valider le service PostgreSQL 17 ..</p></figcaption></figure>
{% endstep %}
{% endstepper %}

***


---

# 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/installation/archive-installation/prepare-environment.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.