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

# Preparar el entorno

{% hint style="info" %}

#### **Preparar el entorno**

Prepara tu servidor Ubuntu para una instalación desde archivo del servidor Pentaho.

Este proceso hará lo siguiente:

* Cree una `pentaho` usuario de instalación (con sudo)
* Definir rutas de Pentaho - `$PENTAHO_BASE`
* Instalar Java 21 (OpenJDK)
* Definir `PENTAHO_JAVA_HOME`
* Instalar PostgreSQL 17 (15 compatible con Pentaho 11)
* Crear usuario de la base de datos del repositorio - `pentaho` para la configuración
* Instalar pgAdmin 4 (escritorio)
  {% endhint %}

{% hint style="warning" %}
Base Linux compatible para Pentaho 11.x: Ubuntu 24.04 LTS.

Para versiones y compatibilidad, consulta [Referencia de componentes](https://docs.pentaho.com/install/pdia-11.0-installation/components-reference).
{% endhint %}

{% stepper %}
{% step %}
**Requisitos previos**

1. Asegúrate de que unzip esté instalado.

```bash
unzip --version
```

2. Define las variables de ruta de Pentaho.

{% hint style="info" %}
Usa estas variables para simplificar comandos y evitar errores de ruta. Considera añadirlas a tu perfil de shell para mayor comodidad.
{% endhint %}

* Edita el archivo /etc/environment.

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

* Añade las siguientes rutas.

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

{% hint style="warning" %}
Si añades esto a `~/.bashrc` o `/etc/environment`, vuelve a abrir tu shell o `source` el archivo para aplicar los cambios.
{% endhint %}

<figure><img src="/files/54efb7afd745911b7cf6fbba2b46ed24cbfffcbd" alt=""><figcaption><p>Rutas de Pentaho</p></figcaption></figure>
{% endstep %}

{% step %}
**Crear un usuario de instalación de Pentaho**

{% hint style="danger" %}
Para producción, utiliza una cuenta de instalación dedicada con solo los privilegios necesarios y evita compartir credenciales.
{% endhint %}

1. Actualizar paquetes (ejecutar una vez):

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

2. Añade el usuario y establece una contraseña:

```bash
sudo adduser pentaho
```

3. Conceder privilegios sudo:

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

4. Validar acceso:

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

{% endstep %}

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

{% hint style="info" %}
Pentaho 11.x está certificado con Java 21.
{% endhint %}

<details>

<summary>¿Cuál es la diferencia entre Oracle JDK y OpenJDK?</summary>

Oracle JDK y OpenJDK son ambas implementaciones de la plataforma Java, pero tienen algunas diferencias importantes:

**Licencia y costo:**

* **OpenJDK** es completamente gratuito y de código abierto bajo la licencia GPL. Puedes usarlo para cualquier propósito sin restricciones.
* **Oracle JDK** cambió su modelo de licencia en 2019. Ahora es gratuito para desarrollo y uso personal, pero requiere una suscripción de pago para uso comercial en producción (Oracle Java SE Subscription).

**Fuente y desarrollo:**

* **OpenJDK** es la implementación de referencia de Java y sirve como base para la mayoría de las distribuciones JDK. De hecho, Oracle contribuye significativamente al desarrollo de OpenJDK.
* **Oracle JDK** se construye a partir del código fuente de OpenJDK, pero incluye algunos componentes propietarios adicionales y funciones comerciales.

**Rendimiento y funciones:**

* En versiones modernas (Java 11+), las diferencias de rendimiento son insignificantes. Oracle ha contribuido de vuelta a OpenJDK con la mayoría de sus mejoras de rendimiento.
* Oracle JDK históricamente incluía algunas herramientas y funciones adicionales (como Java Flight Recorder y Java Mission Control), pero muchas de ellas se han liberado como código abierto y ahora están disponibles en OpenJDK.

**Soporte y actualizaciones:**

* **OpenJDK** recibe soporte y actualizaciones de la comunidad durante unos 6 meses por versión (excepto las versiones LTS mantenidas por varios proveedores).
* **Oracle JDK** ofrece soporte a largo plazo (LTS) con suscripciones comerciales, proporcionando actualizaciones y parches de seguridad durante períodos prolongados.

**Otras distribuciones:** Muchos proveedores ofrecen sus propias compilaciones de OpenJDK con soporte a largo plazo, incluidos Amazon Corretto, Azul Zulu, Eclipse Temurin (antes AdoptOpenJDK) y Red Hat OpenJDK.

Para la mayoría de los desarrolladores y organizaciones, OpenJDK o las distribuciones de OpenJDK con soporte del proveedor son la opción recomendada, a menos que necesites específicamente el soporte comercial de Oracle.

</details>

1. Instalar Java 21:

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

2. Verificar Java:

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

<figure><img src="/files/4123e7bc64cf51ff434b772dc8b6522e328d615d" alt="Ubuntu apt installed OpenJDK versions list"><figcaption><p>Versiones de OpenJDK</p></figcaption></figure>

<figure><img src="/files/393a11b064cda96fe18d8d95687d916fa29418ac" alt="java -version output showing Java 21"><figcaption><p>Java 21</p></figcaption></figure>

{% hint style="info" %}
Si hay varias versiones de Java instaladas, selecciona la predeterminada:

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

{% endhint %}
{% endstep %}

{% step %}
**Definir `PENTAHO_JAVA_HOME`**

Definir `PENTAHO_JAVA_HOME` globalmente para que el servidor Pentaho use Java 21 de forma coherente.

1. Edite `/etc/environment`:

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

2. Añade (o actualiza) la siguiente línea:

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

<figure><img src="/files/703e6e00f48aee9fb37645a64bd25fc47ee7b985" alt=""><figcaption><p>Definir PENTAHO_JAVA_HOME</p></figcaption></figure>

3. Guarda y recarga el entorno (o cierra sesión y vuelve a iniciarla):

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

4. Verificar:

```bash
echo $PENTAHO_JAVA_HOME
```

***

{% hint style="info" %}
Alternativa: configurar solo para un usuario en `~/.bashrc`.
{% endhint %}

1. Editar:

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

2. Añade y aplica:

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

{% endstep %}

{% step %}
**Instalar PostgreSQL 17**

{% hint style="info" %}
El repositorio predeterminado de Ubuntu 24.04 proporciona PostgreSQL 16, que es más reciente. Para instalar la versión 17, añade el repositorio oficial de PostgreSQL (PGDG).

Si ya hay instalado un PostgreSQL diferente, elimínalo primero para evitar conflictos de puertos y paquetes (consulta la pestaña opcional "Limpiar instalaciones anteriores").

**Requisitos previos**\
Ubuntu 24.04\
Privilegios de root o acceso sudo\
usar `sudo su` para entrar como root en lugar de pentaho (usuario predeterminado)
{% endhint %}

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

1. Antes de instalar PostgreSQL, asegúrate de que tu sistema esté actualizado.

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

2. Instala los paquetes de requisitos previos.

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

3. Importa la clave GPG de PostgreSQL.

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

4. Añadir repositorio de 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. Actualizar la lista de paquetes.

```bash
sudo apt update
```

6. Instala los paquetes del servidor y del cliente de PostgreSQL 17.

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

{% hint style="info" %}
**Qué se instala:**

* `postgresql-17`: Servidor principal de base de datos
* `postgresql-contrib-17`: Utilidades y extensiones adicionales
  {% endhint %}

7. Comprobar el servicio y la versión:

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

<figure><img src="/files/c45c7dab2a556e3b2e7fe14481c233cdbd7437bc" alt=""><figcaption><p>PostgreSQL 17.7</p></figcaption></figure>

8. Limpieza opcional:

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

{% endtab %}

{% tab title="Opcional: Instalar PostgreSQL 16" %}

1. Asegúrate de que tu sistema Ubuntu esté actualizado.

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

2. Para ayudar a instalar el software de base de datos, instala los siguientes paquetes.

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

3. Importa la clave de firma del repositorio.

```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. Crea el archivo de configuración del repositorio.

```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. Actualiza de nuevo la lista de paquetes para incluir el nuevo repositorio.

```bash
sudo apt update
```

6. Ahora, instala el paquete del servidor PostgreSQL 16.

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

{% endtab %}

{% tab title="Opcional: Limpiar instalaciones anteriores" %}
Si hay instalado un PostgreSQL no compatible, elimínalo primero. Ejecuta cada comando por separado y revisa la salida:

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

Comprobar paquetes residuales:

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

{% endtab %}
{% endtabs %}

{% hint style="info" %}
Validación:

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

{% endhint %}
{% endstep %}

{% step %}
**Crear usuario de la base de datos - pentaho**

{% hint style="info" %}
Durante la instalación, PostgreSQL crea un superusuario local `postgres`. Establece su contraseña y (opcionalmente) crea un `pentaho` rol.
{% endhint %}

{% hint style="danger" %}
Para producción, evita un superusuario permanente para el uso de la aplicación. Usa roles con mínimos privilegios y concede solo lo necesario. La ruta del taller siguiente eleva privilegios para simplificar la configuración.
{% endhint %}

1. Cambia al usuario del sistema postgres.

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

2. Entra en el terminal interactivo de PostgreSQL.

```bash
psql
```

3. Deberías ver el prompt de PostgreSQL:

```
postgres=#
```

4. Ver bases de datos actuales.

```
\l
```

{% hint style="info" %}
Esto muestra todas las bases de datos. Deberías ver tres bases de datos predeterminadas: postgres, template0 y template1.
{% endhint %}

5. Salir.

```sql
q
```

6. Comprobar la versión de PostgreSQL desde SQL.

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

7. Salir del prompt de PostgreSQL.

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

8. Y salir de psql.

```sql
exit
```

***

**Crear usuario pentaho**

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

1. Definir `postgres` contraseña:

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

2. Cree una `pentaho` usuario y conceder `SUPERUSER` privilegios:

```sql
sudo -u postgres psql -c "CREATE USER pentaho WITH PASSWORD 'SecurePassword123';"
sudo -u postgres psql -c "ALTER USER pentaho WITH SUPERUSER;" # Solo demostración
```

{% hint style="info" %}

* `sudo -u postgres` - Ejecuta el comando como el usuario del sistema Linux `postgres` (que tiene acceso local a PostgreSQL sin contraseña)
* `psql -c` - Ejecuta un único comando SQL y sale
* `CREATE USER pentaho` - Crea un nuevo rol/usuario de PostgreSQL llamado `pentaho`
* `WITH PASSWORD 'SecurePassword123'` - Establece la contraseña de este usuario

***

* `ALTER USER pentaho` - Modifica el `pentaho` usuario
* `WITH SUPERUSER` - Otorga privilegios completos de superusuario (puede hacer cualquier cosa: crear bases de datos, crear usuarios, omitir todos los permisos, etc.)
* `# Solo demostración` - **Comentario de advertencia** que indica que esto es peligroso para producción
  {% endhint %}

3. Probar conexión como `pentaho`:

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

{% endstep %}

{% step %}
**Opcional: Permitir conexiones remotas**

{% hint style="info" %} <mark style="color:verde;">Solo como referencia al conectar a PostgreSQL mediante localhost</mark>

De forma predeterminada, PostgreSQL solo acepta conexiones locales. En configuraciones de localhost, no necesitas este paso.
{% endhint %}

1. Haz una copia de seguridad de las configuraciones y edita `postgresql.conf` (PostgreSQL 17):

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

2. Establecer: `listen_addresses = '*'` (una interfaz/IP específica en producción)

<figure><img src="/files/ea508366cd10feb291a7f687ab7ba19148659966" alt=""><figcaption><p>Configurar el listener</p></figcaption></figure>

3. Guardar:

```
Ctrl + o
Enter
Ctrl + x
```

{% endstep %}

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

{% hint style="info" %}
La **pg\_hba.conf** el archivo (configuración de autenticación basada en host de PostgreSQL) controla quién puede conectarse a tu base de datos PostgreSQL y cómo se autentica. Lo configuras durante la instalación para definir las reglas de seguridad del acceso a la base de datos.

En producción modificarías la configuración para permitir acceso solo a los usuarios necesarios a las bases de datos en las IP del servidor.
{% endhint %}

1. Configurar PostgreSQL para usar autenticación de contraseña 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. Edita el archivo manualmente:

<figure><img src="/files/0ec79540ab64baa1eba1830bd26bedb6d235439a" alt=""><figcaption></figcaption></figure>

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

2. Ejecuta el siguiente script.

```bash
# Usa la ruta exacta
PG_HBA_PATH=/etc/postgresql/17/main/pg_hba.conf

# Verifica que el archivo exista
ls -la "$PG_HBA_PATH"

# Si eso funciona, entonces ejecuta:
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"

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

<figure><img src="/files/f4f796e623a113bb6a20f6e9ca94355f99004d38" alt=""><figcaption><p>SED: pg_hba.conf</p></figcaption></figure>

{% hint style="info" %}
Preferir `scram-sha-256` sobre `md5` en `pg_hba.conf` para un hash de contraseñas más fuerte en versiones modernas de PostgreSQL.

Asegúrate de que tu controlador JDBC admita SCRAM (por ejemplo, controladores recientes de PostgreSQL). Si surgen problemas de compatibilidad, usa `md5` como alternativa.
{% endhint %}

3. Reinicia el servicio de PostgreSQL.

```bash
cd
systemctl restart postgresql
# Contraseña: password
```

4. Permite el firewall (si está habilitado) y reinicia:

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

{% endstep %}

{% step %}
**Instalar pgAdmin 4 (escritorio)**

Instala el cliente de escritorio pgAdmin 4 usando el repositorio oficial.

1. Añadir repositorio y clave:

```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. Instalar pgAdmin 4 (escritorio):

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

3. Opcional: verificar la entrada del repositorio

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

4. Añadir una conexión de servidor en pgAdmin:

* Clic derecho en Servidores → Registrar → Servidor
* Nombre: `Pentaho`
* Conexión: host, puerto `5432`, usuario `pentaho`, contraseña `SecurePassword123` (no guardar en producción)

<figure><img src="/files/e021d291fe8c2e6471ea0fc157bcf46b2fa1f619" alt="Create server group dialog in pgAdmin"><figcaption><p>Crear grupo de servidores</p></figcaption></figure>

<figure><img src="/files/2089bfe69ed0a7a86bc622f4a0cd1b1929d61b29" alt="pgAdmin server group list"><figcaption><p>Grupo de servidores</p></figcaption></figure>

<figure><img src="/files/721b0ddf81781e5cf9496b98c55c901de47cf42a" alt="pgAdmin new server connection dialog"><figcaption><p>Detalles de conexión</p></figcaption></figure>

{% hint style="danger" %}
No guardes contraseñas en producción. Prefiere llaveros a nivel del sistema operativo o almacenes seguros.
{% endhint %}

<figure><img src="/files/ba10b83b979771e0c885cb59d0d46766b238ff05" alt="pgAdmin 4 main UI window"><figcaption><p>Interfaz de pgAdmin 4</p></figcaption></figure>
{% endstep %}

{% step %}
**Validar el entorno**

1. Comprobaciones rápidas para confirmar que todo está listo para el siguiente paso.

```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/9fa86c89bdf0d1fa100c79d5207e9ed5266c062d" alt=""><figcaption><p>Validar el servicio 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-es/instalacion/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.