# Preparar el entorno

{% hint style="info" %}

#### **Preparar el entorno**

Prepare su servidor Ubuntu para una instalación de archivo del servidor Pentaho.

Este proceso hará:

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

{% hint style="warning" %}
Línea base de Linux compatible para Pentaho 11.x: Ubuntu 24.04 LTS.

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

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

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

```bash
unzip --version
```

2. Establezca las variables de ruta de Pentaho.
   {% endstep %}

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

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

1. Actualizar paquetes (ejecutar una vez):

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

2. Agregar el usuario y establecer 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:

**Licencias y costo:**

* **OpenJDK** es completamente gratuito y de código abierto bajo la licencia GPL. Puede 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).

**Origen y desarrollo:**

* **OpenJDK** es la implementación de referencia de Java y sirve como base para la mayoría de las distribuciones de JDK. Oracle en realidad contribuye de forma significativa al desarrollo de OpenJDK.
* **Oracle JDK** se construye a partir del código fuente de OpenJDK pero incluye algunos componentes propietarios adicionales y características comerciales.

**Rendimiento y características:**

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

**Soporte y actualizaciones:**

* **OpenJDK** recibe soporte de la comunidad y actualizaciones durante aproximadamente 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 extendidos.

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

Para la mayoría de los desarrolladores y organizaciones, OpenJDK o las distribuciones de OpenJDK respaldadas por proveedores son la opción preferida a menos que necesite 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 se instalan varias versiones de Java, seleccione la predeterminada:

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

{% endhint %}
{% endstep %}

{% step %}
**Establecer `PENTAHO_JAVA_HOME`**

Establecer `PENTAHO_JAVA_HOME` globalmente para que el servidor Pentaho use consistentemente Java 21.

1. Editar `/etc/environment`:

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

2. Agregar (o actualizar) la siguiente línea:

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

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

3. Guardar y recargar el entorno (o cerrar sesión/iniciar sesión):

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

4. Verificar:

```bash
echo $PENTAHO_JAVA_HOME
```

***

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

1. Editar:

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

2. Agregar al final y aplicar:

```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 un PostgreSQL 16 más reciente. Para instalar 17, agregue el repositorio oficial de PostgreSQL (PGDG).

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

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

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

1. Antes de instalar PostgreSQL, asegúrese de que su sistema esté actualizado.

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

2. Instalar paquetes prerequisitos.

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

3. Importar la clave GPG de PostgreSQL.

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

4. Agregar el 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. Instalar los paquetes del servidor y 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 de base de datos principal
* `postgresql-contrib-17`: Utilidades y extensiones adicionales
  {% endhint %}

7. Comprobar servicio y 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úrese de que su sistema Ubuntu esté actualizado.

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

2. Para ayudar en la instalación del software de base de datos, instale los siguientes paquetes.

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

3. Importar 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. Crear 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. Actualice la lista de paquetes nuevamente para incluir el nuevo repositorio.

```bash
sudo apt update
```

6. Ahora, instale 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ínelo primero. Ejecute cada comando por separado y revise 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 base de datos - pentaho**

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

{% hint style="danger" %}
Para producción, evite un superusuario permanente para el uso por aplicaciones. Use roles con los mínimos privilegios y conceda solo lo necesario. El camino del taller a continuación eleva privilegios para simplificar la configuración.
{% endhint %}

1. Cambiar al usuario del sistema postgres.

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

2. Ingrese al terminal interactivo de PostgreSQL.

```bash
psql
```

3. Debería ver el indicador de PostgreSQL:

```
postgres=#
```

4. Ver bases de datos actuales.

```
\l
```

{% hint style="info" %}
Esto lista todas las bases de datos. Debería ver tres bases de datos por defecto: postgres, template0 y template1.
{% endhint %}

5. Salir.

```sql
q
```

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

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

7. Salir del aviso 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. Establecer `postgres` contraseña:

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

2. Crear un `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` - Ejecutar 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 para este usuario

***

* `ALTER USER pentaho` - Modifica el `pentaho` usuario existente
* `WITH SUPERUSER` - Concede privilegios completos de superusuario (puede hacer cualquier cosa: crear bases de datos, crear usuarios, eludir todos los permisos, etc.)
* `# Solo demostración` - **Comentario de advertencia** indicando 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 ya que conectarse a Postgresql vía localhost</mark>

Por defecto, PostgreSQL acepta solo conexiones locales. Para configuraciones localhost, no necesita este paso.
{% endhint %}

1. Hacer copia de seguridad de las configuraciones y editar `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>Establecer el listener</p></figcaption></figure>

3. Guardar:

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

{% endstep %}

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

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

En producción modificaría la configuración para permitir solo a los usuarios requeridos el acceso a las bases de datos desde las IPs del servidor.
{% endhint %}

1. Configurar PostgreSQL para usar autenticación de contraseña md5 `archivo pg_hba.conf` .

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

2. Editar manualmente el archivo:

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

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

2. Ejecute el siguiente script.&#x20;

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

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

# Si eso funciona, entonces ejecute:
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 `archivo pg_hba.conf` para un hashing de contraseñas más fuerte en versiones modernas de PostgreSQL.

Asegúrese de que su controlador JDBC admita SCRAM (por ejemplo, controladores recientes de PostgreSQL). Si surgen problemas de compatibilidad, use `md5` como solución alternativa.
{% endhint %}

3. Reiniciar el servicio de PostgreSQL.

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

4. Permitir en el firewall (si está habilitado) y reiniciar:

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

{% endstep %}

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

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

1. Agregar 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 entrada del repositorio

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

4. Agregar una conexión de servidor en pgAdmin:

* Clic derecho en Servers → Register → Server
* 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 guarde contraseñas en producción. Prefiera keyrings a nivel de SO o cofres 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 "Verifique 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: 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:

```
GET https://academy.pentaho.com/pentaho-11-installation-en/pentaho-11-installation-es/instalacion/archive-installation/prepare-environment.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.