# Installez le serveur Pentaho

{% hint style="info" %}

#### **Serveur Pentaho**

Cette section vous guide pour installer et démarrer le serveur Pentaho sur Ubuntu.

Vous allez :

* Créer des répertoires d'installation
* Préparer les bases de données du dépôt Pentaho
* Configurer les connexions JDBC/JNDI
* Démarrer le serveur Pentaho (et éventuellement configurer systemd)
* Configurer le gestionnaire de licences
  {% endhint %}

{% hint style="warning" %}
Base testée : Ubuntu 24.04 LTS avec Java 21 (OpenJDK) et PostgreSQL 17.

Assurez-vous d'avoir terminé [Préparer l'environnement](https://academy.pentaho.com/pentaho-11-installation-en/pentaho-11-installation-fr/installation/archive-installation/prepare-environment) d'abord. 

Pour les détails de compatibilité, voir [Référence des composants](https://docs.pentaho.com/install/components-reference).
{% endhint %}

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

* Serveur Ubuntu 24.04 LTS
* Java 21 installé et `PENTAHO_JAVA_HOME` défini
* PostgreSQL 17 installé et en cours d'exécution
* Un utilisateur non root `pentaho` avec sudo
* `package unzip` installé
* Archives ZIP et pilotes JDBC téléchargés
  {% endhint %}

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

{% tabs %}
{% tab title="1. Serveur Pentaho" %}
{% hint style="info" %}

#### **Répertoires du serveur Pentaho**

Le serveur Pentaho est une application web s'exécutant dans un conteneur de servlets Apache Tomcat.
{% endhint %}

1. Créez les répertoires de base sous `/opt/pentaho`.

```bash
cd
sudo mkdir -p /opt/pentaho/{server,software}
```

```
/opt/pentaho
├── server      # Runtime serveur décompressé (tomcat, pentaho-solutions, scripts)
└── software    # Installateurs, ZIPs, pilotes (zone de préparation)
```

2. Créez des sous-répertoires dans `/opt/pentaho/software`.

```bash
cd /opt/pentaho/software
sudo mkdir -p {db-drivers,docker,ee-client,ee-plugins,ops-mart,sdk,server,shims}
```

```
db-drivers   - pilotes JDBC
docker       - configuration Pentaho on-prem & dockerfiles
ee-client    - plugins client Pentaho EE
ee-plugins   - plugins serveur Pentaho EE
ops-mart     - scripts Operations Mart
sdk          - kit Pentaho SDK
server       - serveur Pentaho
shims        - collections de shims Hadoop
```

***

{% hint style="info" %}
**Décompresser le package du serveur Pentaho (ZIP)**

Utilisez `package unzip` pour extraire le ZIP du serveur dans le répertoire runtime. Cela évite d'exiger le JDK complet (le JRE n'inclut pas l'outil `jar` ).

* `pentaho-server-ee-11.0.0.0-2xx.zip` - Serveur Pentaho (Archive - inclut Tomcat 10)
  {% endhint %}

1. Assurez-vous que `package unzip` est disponible et copiez les ZIPs du serveur dans la zone de préparation.

```bash
cd
sudo apt update -y && sudo apt install -y unzip
sudo cp ~/Downloads/'Archive Build (Suggested Installation Method)'/* /opt/pentaho/software/server
```

2. Extraire le ZIP du serveur Pentaho dans `$PENTAHO_BASE/server`.

```bash
cd
cd "$PENTAHO_BASE/server"

# Remplacez <version> par le nom de fichier exact que vous avez téléchargé
sudo unzip /opt/pentaho/software/server/pentaho-server-ee-11.0.0.0-2xx.zip
```

<figure><img src="https://3016379417-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5WjeDOi3MsT9tY3oU6mQ%2Fuploads%2FJy93CD0Tri999fFR1upa%2Fimage.png?alt=media&#x26;token=d7464f38-379c-4f72-8d6c-aba8415f876a" alt=""><figcaption><p>Décompresser Pentaho Server</p></figcaption></figure>

3. Rendre tous les `.sh` fichiers exécutables.

```bash
cd
cd "$PENTAHO_BASE/server"
sudo find . -iname "*.sh" -exec chmod +x {} \;
```

4. Définir la propriété et des permissions sensées pour exécuter 'pentaho' en tant qu'utilisateur non root.

```bash
cd
sudo chown -R pentaho:pentaho /opt/pentaho
sudo find /opt/pentaho -type d -exec chmod 755 {} \;
sudo find /opt/pentaho -type f -exec chmod 644 {} \;
sudo find /opt/pentaho -name "*.sh" -exec chmod 755 {} \;
```

{% hint style="info" %}
755 signifie que vous pouvez tout faire avec le fichier ou le répertoire, et que les autres utilisateurs peuvent le lire et l'exécuter mais pas le modifier. Convient pour les programmes et répertoires que vous voulez rendre accessibles publiquement.&#x20;

644 signifie que vous pouvez lire et écrire le fichier ou le répertoire et que les autres utilisateurs peuvent seulement le lire.
{% endhint %}

5. Vérifiez la structure du répertoire du serveur.

{% hint style="info" %}
/opt/pentaho/

```
  server/
    pentaho-server/
      pentaho-solutions/
        system/
```

Les plugins serveur sont installés dans le `pentaho-solutions/system` dossier.
{% endhint %}
{% endtab %}

{% tab title="2. Dépôt Pentaho" %}
{% hint style="info" %}

#### **Composants du dépôt Pentaho**

Le dépôt Pentaho (sur PostgreSQL par défaut) se compose de :

* Jackrabbit : dépôt de solutions, sécurité et métadonnées de contenu
* Quartz : données du planificateur
* Hibernate : journalisation d'audit
* Pentaho Operations Mart : rapports d'utilisation et de performance
  {% endhint %}

{% stepper %}
{% step %}
**Vérifier les mots de passe par défaut dans les scripts SQL**

1. Inspectez les scripts PostgreSQL fournis avec le serveur.

```bash
cd
cd "$PENTAHO_SERVER/data/postgresql"
ls -1
```

Vous devriez voir des fichiers similaires à :

```
alter_script_postgresql_BISERVER-13674.sql
create_jcr_postgresql.sql
create_quartz_postgresql.sql
create_repository_postgresql.sql
migrate_old_quartz_data_postgresql.sql
pentaho_logging_postgresql.sql
pentaho_mart_drop_postgresql.sql
pentaho_mart_postgresql.sql
pentaho_mart_upgrade_audit_postgresql.sql
pentaho_mart_upgrade_postgresql.sql

```

2. Ouvrez un script pour vérifier les utilisateurs/mots de passe par défaut (modifiez pour la production).

```bash
sed -n '1,120p' create_jcr_postgresql.sql
```

{% endstep %}

{% step %}
**Exécuter les scripts SQL pour créer les bases de données du dépôt**

1. Confirmez que PostgreSQL est en cours d'exécution et localisez les scripts.

```bash
sudo systemctl status postgresql --no-pager
cd
cd "$PENTAHO_SERVER/data/postgresql"
ls -l
```

2. Connectez-vous en tant que `pentaho` superutilisateur.

&#x20;      Mot de passe : `SecurePassword123`

```bash
sudo -u pentaho psql -d postgres
```

3. Exécutez les commandes étape par étape - pas comme un seul bloc de script. Fournissez les mots de passe si demandé - voir ci‑dessous.

```plsql
\i create_jcr_postgresql.sql
\i create_quartz_postgresql.sql
\q quitter après Quartz et reconnectez-vous ..
assurez‑vous d'être dans le répertoire "$PENTAHO_SERVER/data/postgresql"
sudo -u pentaho psql -d postgres
\i create_repository_postgresql.sql
\i pentaho_mart_postgresql.sql
\q quitter après hibernate et reconnectez-vous ..
assurez‑vous d'être dans le répertoire "$PENTAHO_SERVER/data/postgresql"
sudo -u pentaho psql -d postgres
\i pentaho_logging_postgresql.sql
\q
```

| Utilisateur   | Mot de passe      |
| ------------- | ----------------- |
| postgres      | SecurePassword123 |
| pentaho       | SecurePassword123 |
| jcr\_user     | password          |
| pentaho\_user | password          |
| hibuser       | password          |

4. Validation rapide (CLI) - lister les bases créées et se connecter - appuyez sur q pour faire défiler la liste.

```sql
\l+ jackrabbit
\l+ quartz
\l+ hibuser
\l+ opsmart
\c jackrabbit
\dt
\c quartz
\dt
```

{% hint style="warning" %}
Les tables pour Hibernate et Jackrabbit peuvent être créées plus tard par le serveur Pentaho au premier démarrage. Voir des schémas vides à ce stade peut être attendu.
{% endhint %}

5. Optionnel : vérifiez dans pgAdmin (GUI).

<figure><img src="https://3016379417-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5WjeDOi3MsT9tY3oU6mQ%2Fuploads%2Fgit-blob-3f5c1b3286cf8b2594c1137d2c926dcf909538ca%2Fimage%20(42).png?alt=media" alt=""><figcaption><p>Bases de données Pentaho</p></figcaption></figure>
{% endstep %}

{% step %}
**Configurer Pentaho pour utiliser PostgreSQL**

{% hint style="info" %}
PostgreSQL est le défaut. Si vous avez conservé les mots de passe et le port par défaut (`5432`), vérifiez seulement les paramètres ci‑dessous ; sinon, ajustez hôte/port/utilisateur/mot de passe pour correspondre à votre environnement.
{% endhint %}

***

{% hint style="info" %}
Quartz - définir le délégué PostgreSQL et la source de données JNDI.
{% endhint %}

1. Ouvrez la configuration Quartz.

```bash
cd "$PENTAHO_SERVER/pentaho-solutions/system/scheduler-plugin/quartz"
sudo nano -c quartz.properties
```

2. Vérifiez ces valeurs (les numéros de ligne peuvent différer) :

{% code title="quartz.properties — entrées requises" %}

```
org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.PostgreSQLDelegate
org.quartz.dataSource.myDS.jndiURL=Quartz
```

{% endcode %}

***

{% hint style="info" %}
Hibernate — pointer vers le fichier de configuration PostgreSQL.
{% endhint %}

1. Ouvrez les réglages Hibernate.

```bash
cd "$PENTAHO_SERVER/pentaho-solutions/system/hibernate"
sudo nano -c hibernate-settings.xml
```

2. Confirmez la référence du fichier de config :

{% code title="hibernate-settings.xml" %}

```
<config-file>system/hibernate/postgresql.hibernate.cfg.xml</config-file>
```

{% endcode %}

3. Examinez éventuellement `postgresql.hibernate.cfg.xml` pour le nom de la source de données et le dialecte.

```bash
sudo nano -c postgresql.hibernate.cfg.xml
```

Assurez-vous :

{% code title="postgresql.hibernate.cfg.xml — propriétés clés" %}

```
<property name="connection.driver_class">org.postgresql.Driver</property>
<property name="dialect">org.hibernate.dialect.PostgreSQLDialect</property>
<property name="hibernate.connection.datasource">java:comp/env/jdbc/Hibernate</property>
```

{% endcode %}

***

{% hint style="info" %}
Jackrabbit — vérifiez le stockage PostgreSQL dans `repository.xml`.
{% endhint %}

1. Ouvrez la configuration Jackrabbit.

```bash
cd "$PENTAHO_SERVER/pentaho-solutions/system/jackrabbit"
sudo nano -c repository.xml
```

2. Vérifiez que les sections PostgreSQL sont actives (les autres commentées), par exemple :

{% hint style="info" %}

* Schéma Filesystem : `postgresql`
* Datastore `databaseType="postgresql"`
* Schéma PersistenceManager : `postgresql`
* Journal de base de données : `postgresql`
  {% endhint %}

{% hint style="warning" %}
Vérifiez les noms JNDI et les ports entre Quartz, Hibernate, Jackrabbit et Tomcat `context.xml` pour assurer la cohérence (même hôte, port 5432 sauf modification, et noms de ressources JNDI correspondants).

Noms JNDI attendus :

* Quartz : `Quartz`
* Hibernate : `java:comp/env/jdbc/Hibernate`
* Jackrabbit : comme référencé dans `repository.xml`
  {% endhint %}
  {% endstep %}
  {% endstepper %}
  {% endtab %}

{% tab title="3. Tomcat" %}
{% hint style="info" %}

#### **Tomcat**

Après avoir configuré le dépôt, configurez le serveur d'applications web (Tomcat 10) pour se connecter au dépôt en utilisant JDBC/JNDI.
{% endhint %}

{% tabs %}
{% tab title="1. Pilotes de base de données" %}
{% hint style="warning" %}

#### **Pilotes JDBC**

Pour se connecter aux bases de données (y compris le dépôt), installez les pilotes JDBC appropriés. En raison de restrictions de licence, certains pilotes doivent être téléchargés manuellement.
{% endhint %}

{% embed url="<https://docs.pentaho.com/install/jdbc-drivers-reference>" %}

{% embed url="<https://jdbc.postgresql.org/download/postgresql-42.7.8.jar>" %}

1. Vérifiez que le pilote JDBC PostgreSQL est présent dans lib de Tomcat (requis pour le dépôt) :

```bash
ls -1 "$TOMCAT_HOME/lib" | grep -i postgresql || echo "Pilote PostgreSQL introuvable"
```

{% hint style="info" %}
S'il n'est pas trouvé, téléchargez le pilote JDBC PostgreSQL (par exemple, `postgresql-42.7.8.jar`) et distribuez‑le à l'aide du script d'assistance :
{% endhint %}

```bash
sudo cp ~/Downloads/'Database Drivers'/postgresql-*.jar /opt/pentaho/server/jdbc-distribution
cd /opt/pentaho/server/jdbc-distribution
sudo ./distribute-files.sh "$TOMCAT_HOME/lib"
```

2. Copiez tous les pilotes JDBC supplémentaires dans le dossier de préparation et distribuez‑les.

```bash
sudo cp ~/Downloads/'Database Drivers'/* /opt/pentaho/software/db-drivers
cd /opt/pentaho/software/db-drivers
sudo cp mysql-connector-j-9.0.0.jar /opt/pentaho/server/jdbc-distribution
```

3. Distribuez les pilotes vers Tomcat.

```bash
cd /opt/pentaho/server/jdbc-distribution
sudo ./distribute-files.sh "$TOMCAT_HOME/lib"
```

4. Vérifiez que les JARs sont présents dans lib de Tomcat.

```bash
ls -1 "$TOMCAT_HOME/lib" | grep -Ei 'mysql|postgresql' || echo "Introuvable"
```

{% hint style="danger" %}
Vous devez redémarrer le serveur Pentaho (et les outils clients, si en cours d'exécution) pour charger les nouveaux pilotes JDBC. Un redémarrage complet du système n'est pas requis.
{% endhint %}
{% endtab %}

{% tab title="2. context.xml" %}
{% hint style="info" %}

#### **context.xml**

Les informations de connexion à la base de données pour les ressources JNDI utilisées par Pentaho sont stockées dans `context.xml`.
{% endhint %}

1. Ouvrez le fichier et vérifiez les ressources JNDI et les identifiants.

```bash
cd "$TOMCAT_HOME/webapps/pentaho/META-INF"
sudo nano -c context.xml
```

{% hint style="warning" %}
En production, vérifiez que le nom d'utilisateur, le mot de passe, la classe du pilote, l'hôte/IP et le port correspondent à votre environnement. Assurez‑vous que les noms JNDI correspondent aux configurations Quartz, Hibernate et Jackrabbit.
{% endhint %}
{% endtab %}
{% endtabs %}
{% endtab %}

{% tab title="4. Démarrer le serveur" %}
{% hint style="info" %}

#### **Démarrer le serveur Pentaho**

Exécutez le serveur en tant qu'utilisateur `pentaho` pour éviter les problèmes d'autorisation.
{% endhint %}

1. Démarrez le serveur.

```bash
cd
cd "$PENTAHO_SERVER"
./start-pentaho.sh
```

2. Surveillez le journal Tomcat (schéma robuste).

```bash
tail -f "$TOMCAT_HOME/logs/catalina."*.log
```

Les messages attendus incluent :

```
... Starting ProtocolHandler ["http-nio-8080"]
... Server startup in [xxxxx] milliseconds
```

***

{% hint style="info" %}
**Console utilisateur Pentaho (PUC)**

La Console utilisateur Pentaho (PUC) est l'interface web pour créer et consulter le contenu.
{% endhint %}

{% embed url="<http://localhost:8080/pentaho>" %}
Lien vers le serveur Pentaho
{% endembed %}

Identifiants par défaut (changez immédiatement après la première connexion) :

```
Nom d'utilisateur : admin
Mot de passe : password
```

<figure><img src="https://3016379417-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5WjeDOi3MsT9tY3oU6mQ%2Fuploads%2FiCESci3OyqswLQCv6hKf%2Fimage.png?alt=media&#x26;token=89acf79f-9016-489a-9081-16d25751395d" alt=""><figcaption><p>Console utilisateur Pentaho</p></figcaption></figure>

3. Vous avez également la possibilité de passer au nouvel écran de connexion.

{% embed url="<http://localhost:8080/pentaho/content/login/web/index.html>" %}

<figure><img src="https://3016379417-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5WjeDOi3MsT9tY3oU6mQ%2Fuploads%2Fd2ln55miyWQNgciXuT5A%2Fimage.png?alt=media&#x26;token=8c1ec0fc-3c05-460e-b4a7-60111d15045e" alt=""><figcaption><p>NOUVEAU - Console utilisateur Pentaho</p></figcaption></figure>

{% hint style="info" %}
Si vous avez déjà saisi vos informations de licence, vous serez redirigé vers la nouvelle Console utilisateur.
{% endhint %}

***

{% hint style="success" %}
**Validations rapides**
{% endhint %}

* Vérifiez que HTTP répond :

```bash
curl -I http://localhost:8080/pentaho/ | head -n 1
```

* Optionnel (accès distant) : ouvrez le pare-feu et testez depuis une machine cliente (ajustez selon votre politique réseau) :

```bash
sudo ufw allow 8080/tcp || true
```

***

<details>

<summary>Validez le dépôt après la première exécution (cliquez pour développer)</summary>

```sql
-- Exemple Quartz
\c quartz
SELECT COUNT(*) FROM qrtz_scheduler_state;

-- Exemple Hibernate (attendez de nombreuses tables après le premier démarrage)
\c hibuser
\dt
```

</details>

***

{% hint style="info" %}
**Systemd (optionnel)**

Créez un service systemd pour gérer Pentaho au démarrage et en cas d'échec.
{% endhint %}

1. Enregistrez le fichier d'unité en tant que `/etc/systemd/system/pentaho-server.service`.

{% code title="/etc/systemd/system/pentaho-server.service" %}

```ini
[Unit]
Description=Serveur Pentaho
After=network-online.target
Wants=network-online.target

[Service]
Type=forking
User=pentaho
Group=pentaho
EnvironmentFile=-/etc/environment
# Repli optionnel si vous n'utilisez pas PENTAHO_JAVA_HOME dans /etc/environment
# Environment="JAVA_HOME=/usr/lib/jvm/java-21-openjdk-amd64"
WorkingDirectory=/opt/pentaho/server/pentaho-server
ExecStart=/opt/pentaho/server/pentaho-server/start-pentaho.sh
ExecStop=/opt/pentaho/server/pentaho-server/stop-pentaho.sh
TimeoutSec=500
Restart=on-failure
RestartSec=5
SuccessExitStatus=5 6
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
```

{% endcode %}

2. Rechargez et démarrez.

```bash
sudo systemctl daemon-reload
sudo systemctl start pentaho-server
sudo systemctl enable pentaho-server
```

Gérez le service :

```bash
sudo systemctl status pentaho-server
sudo systemctl restart pentaho-server
sudo systemctl stop pentaho-server
```

***

<details>

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

* HTTP 404 sur `/pentaho` après le démarrage : confirmez `"$TOMCAT_HOME/webapps/pentaho"` existe, vérifiez `catalina.*.log` pour les erreurs de déploiement, et vérifiez les permissions des fichiers sous `$PENTAHO_SERVER`.
* Le port 8080 est déjà utilisé : changez le port Tomcat dans `server.xml` ou arrêtez le service en conflit.
* Pilote JDBC introuvable : vérifiez que les JARs du pilote (par ex., `postgresql-*.jar`, `mysql-*.jar`) existent dans `"$TOMCAT_HOME/lib"`.
* L'authentification à PostgreSQL échoue : privilégiez `scram-sha-256`; vérifiez `pg_hba.conf`, redémarrez PostgreSQL, et testez `psql -h 127.0.0.1` avec l'utilisateur cible.
* Problèmes de schéma Jackrabbit : revérifiez que `repository.xml` les sections sont réglées sur `postgresql`.
* Erreurs d'activation de licence : vérifiez les journaux Tomcat dans `tomcat/logs/` pour `license`/`elm` messages.

</details>

***

{% endtab %}

{% tab title="5. Gestionnaire de licences" %}
{% hint style="info" %}

#### **Gestionnaire de licences**

Pentaho Pro Suite 11.x utilise un gestionnaire de licences (cloud ou local) pour gérer les droits PDI & BA et vérifier les plugins EE.
{% endhint %}

<figure><img src="https://3016379417-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5WjeDOi3MsT9tY3oU6mQ%2Fuploads%2FdUg8NEdO9frCIlBaKfrq%2Fimage.png?alt=media&#x26;token=24b7c500-de22-45ea-98d2-8561486c2181" alt=""><figcaption><p>Licences</p></figcaption></figure>

{% tabs %}
{% tab title="Gestionnaire de licences" %}
{% hint style="info" %}

#### **Licence d'essai**

Une licence d'essai de 30 jours est incluse si vous avez téléchargé depuis :  [Essai Pentaho 30 jours](https://pentaho.com/download/)

Si vous avez téléchargé les binaires GA depuis : [Portail client Pentaho](https://support.pentaho.com/hc/en-us), alors vous aurez besoin d'un ID d'activation ou de votre URL de licence.

Si vous avez installé dans un environnement isolé (air‑gapped), vous devrez demander une licence hors ligne.
{% endhint %}

1. Lancez Server Pentaho > Administration > Licences pour ouvrir la boîte de dialogue Ajouter une licence.
2. Cliquez sur le signe +.

<figure><img src="https://3016379417-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5WjeDOi3MsT9tY3oU6mQ%2Fuploads%2F1MkrLTlosJsSy4N89J3Z%2Fimage.png?alt=media&#x26;token=120b7dcd-dd2c-460a-91db-810183367974" alt=""><figcaption><p>Ajouter une licence</p></figcaption></figure>

5. Saisissez le code d'activation ou votre URL de licence :

<figure><img src="https://3016379417-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5WjeDOi3MsT9tY3oU6mQ%2Fuploads%2Fgit-blob-2a4adbdfb67c13663794e0fc8d4d3ec62da60e92%2FLM.png?alt=media" alt="Add License dialog"><figcaption><p>Gestionnaire de licences</p></figcaption></figure>

{% hint style="warning" %}
**Licences Enterprise**

Si vous mettez à niveau depuis la version 9.x ou antérieure, installez la nouvelle version du produit avant d'activer les licences. Ne démarrez pas le serveur avant d'avoir mis à jour les licences.
{% endhint %}
{% endtab %}

{% tab title="Définir le chemin de licence dans l'environnement" %}
{% hint style="info" %}
**Définir la variable d'environnement du chemin de licence**

Créez une `PENTAHO_LICENSE_INFORMATION_PATH` variable d'environnement afin que le serveur Pentaho trouve systématiquement votre fichier de licence.
{% endhint %}

1. Assurez-vous que le répertoire cible existe et est sécurisé.

```bash
sudo -u pentaho mkdir -p /home/pentaho/.pentaho
sudo chown -R pentaho:pentaho /home/pentaho/.pentaho
chmod 700 /home/pentaho/.pentaho
```

2. Éditez `/etc/environment` et ajoutez la ligne ci‑dessous (pas de `export`).

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

Ajoutez (ou mettez à jour) ce qui suit :

```
PENTAHO_LICENSE_INFORMATION_PATH=/home/pentaho/.pentaho/.elmLicInfo.plt
```

3. Déconnectez-vous/reconnectez-vous ou rechargez l'environnement et vérifiez.

```bash
source /etc/environment
env | grep PENTAHO_LICENSE_INFORMATION_PATH
```

La `PENTAHO_LICENSE_INFORMATION_PATH` variable est maintenant définie.
{% endtab %}
{% endtabs %}
{% endtab %}
{% endtabs %}