# Contenedores Pentaho

{% hint style="info" %}

#### Contenedores de Pentaho

El servidor Pentaho ofrece opciones de despliegue flexibles para adaptarse a una gama de estrategias de infraestructura. Para **on-premises** entornos, las organizaciones pueden desplegar usando Docker Compose para configuraciones sencillas en un único host, u orquestar en clústeres usando Kubernetes (K8s y K3s) para mayor escalabilidad y resiliencia. 

Para **cloud (hiperescalador)** despliegues, Pentaho proporciona imágenes Docker optimizadas y preconstruidas diseñadas específicamente para Amazon Web Services (EKS/ECR), Microsoft Azure (AKS) y Google Cloud Platform (GKE), permitiendo a los equipos aprovechar servicios Kubernetes gestionados y almacenamiento nativo en la nube como Amazon S3. A partir de Pentaho 11, estas imágenes cuentan con rutas de instalación estandarizadas, variables de entorno y scripts de entrypoint mejorados que soportan anulaciones de configuración en tiempo de ejecución, lo que significa que las licencias y los archivos de configuración pueden inyectarse al iniciar sin reconstruir la imagen. 

Un **híbrido** enfoque también es totalmente compatible, donde las organizaciones pueden ejecutar el servidor Pentaho on-premises para cargas de trabajo sensibles mientras despliegan contenedores del servidor Carte o nodos trabajadores de PDI en la nube para manejar procesamiento por picos, mezclando el control de la infraestructura local con la elasticidad de los recursos en la nube.
{% endhint %}

{% hint style="danger" %}
Los siguientes pasos están destinados a configurar un entorno de laboratorio Pentaho y deben completarse para finalizar los talleres.

Asegúrese de haber descargado el Taller--Instalación:

```bash
cd
git clone https://github.com/jporeilly/Workshop--Installation
```

Para instalar git:

```bash
sudo apt install git
```

{% endhint %}

Seleccione su host de contenedores:

{% tabs %}
{% tab title="Docker" %}
{% hint style="info" %}

#### Docker

Docker es una plataforma que permite a los desarrolladores empaquetar aplicaciones y sus dependencias en contenedores ligeros y portátiles. Los contenedores garantizan que las aplicaciones se ejecuten de forma consistente en diferentes entornos informáticos, desde portátiles de desarrollo hasta servidores de producción. Este taller le guiará a través del proceso completo de instalación del motor Docker en Ubuntu 24.04 LTS (Noble Numbat).
{% endhint %}

1. Antes de instalar Docker, actualice la lista de paquetes existente.

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

2. Instale paquetes que permitan a apt usar repositorios a través de HTTPS.

```bash
sudo apt install -y ca-certificates curl gnupg lsb-release
```

3. Cree un directorio para keyrings y agregue la clave GPG de Docker.

```bash
sudo install -m 0755 -d /etc/apt/keyrings
```

```bash
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
```

```bash
sudo chmod a+r /etc/apt/keyrings/docker.gpg
```

4. Agregue el repositorio de Docker a sus fuentes de apt.

```bash
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
```

5. Ahora que se ha añadido el repositorio de Docker, actualice el índice de paquetes.

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

6. Instale Docker Engine, containerd y Docker Compose.

```bash
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
```

7. Compruebe que Docker está instalado correctamente verificando la versión.

```bash
docker --version
```

Debería ver una salida similar a (Nov 2025):

```
Versión de Docker 29.0.2, build 810xxxx
```

8. Verifique que Docker Engine esté en ejecución.

```bash
sudo systemctl status docker
```

El servicio debería mostrarse como "active (running)".

9. Salir.

```bash
q
```

10. Pruebe su instalación de Docker ejecutando el contenedor hello-world.

```bash
sudo docker run hello-world
```

{% hint style="info" %}
Este comando descarga una imagen de prueba y la ejecuta en un contenedor. Si tiene éxito, verá un mensaje confirmando que Docker funciona correctamente.
{% endhint %}

***

{% hint style="info" %}

#### Sin Sudo

Por defecto, Docker requiere privilegios de sudo. Para ejecutar comandos Docker sin sudo.
{% endhint %}

1. Agregue su usuario al grupo docker.

```bash
sudo usermod -aG docker $USER
```

2. Aplique la nueva pertenencia al grupo (o cierre sesión y vuelva a iniciarla).

```bash
newgrp docker
```

3. Verifique que puede ejecutar Docker sin sudo.

```bash
docker run hello-world
```

4. Asegúrese de que Docker se inicie automáticamente cuando el sistema arranque.

```bash
sudo systemctl enable docker.service
sudo systemctl enable containerd.service
```

***

{% hint style="info" %}

#### Verificación y pruebas

Para confirmar que todo funciona correctamente, ejecute los siguientes comandos:
{% endhint %}

Comprobar versión de Docker:

```bash
docker version
```

Ver información del sistema Docker:

```bash
docker info
```

Listar contenedores en ejecución:

```bash
docker ps
```

Listar todos los contenedores (incluidos los detenidos):

```bash
docker ps -a
```

Listar imágenes descargadas:

```bash
docker images
```

***

{% hint style="info" %}

#### Comandos comunes

Aquí están los comandos esenciales de Docker que usará regularmente:

* `docker pull <image>` - Descargar una imagen de Docker Hub
* `docker images` - Listar todas las imágenes locales
* `docker run <image>` - Crear e iniciar un contenedor desde una imagen
* `docker ps` - Listar contenedores en ejecución
* `docker ps -a` - Listar todos los contenedores
* `docker stop <container>` - Detener un contenedor en ejecución
* `docker rm <container>` - Eliminar un contenedor detenido
* `docker rmi <image>` - Eliminar una imagen
* `docker logs <container>` - Ver registros del contenedor
* `docker exec -it <container> bash` - Acceder a la shell de un contenedor en ejecución
  {% endhint %}
  {% endtab %}

{% tab title="K3s" %}
{% hint style="info" %}

#### K3s

K3s es una distribución ligera y totalmente compatible de Kubernetes diseñada para entornos con recursos limitados y computación en el borde. Se empaqueta como un único binario o una imagen de contenedor mínima, lo que la hace significativamente más fácil de desplegar y gestionar que Kubernetes estándar. La distribución usa SQLite3 como su almacén de datos ligero por defecto, aunque también soporta etcd3, MySQL y Postgres para usuarios que necesiten opciones más robustas.

La plataforma simplifica las operaciones de Kubernetes agrupando todos los componentes del plano de control en un único binario y proceso. Este enfoque unificado automatiza tareas complejas como la distribución de certificados y la configuración TLS, al tiempo que mantiene la seguridad por defecto con ajustes sensatos para entornos ligeros. K3s tiene dependencias externas mínimas, requiriendo solo un kernel Linux moderno y montajes de cgroup para ejecutarse.

K3s viene "con todo incluido" con componentes esenciales preempaquetados, eliminando la necesidad de instalaciones y configuraciones separadas. Esto incluye containerd como runtime de contenedores, Flannel para redes, CoreDNS para descubrimiento de servicios, Traefik para ingress y varios otros controladores críticos para balanceo de carga, políticas de red, almacenamiento y gestión de imágenes. Este paquete integral hace que K3s sea ideal para la creación rápida de clústeres en ubicaciones edge, despliegues IoT, pipelines CI/CD y entornos de desarrollo.
{% endhint %}

{% embed url="<https://docs.k3s.io/>" %}

1. Antes de instalar Docker, actualice la lista de paquetes existente.

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

2. Instale paquetes que permitan a apt usar repositorios a través de HTTPS.

```bash
sudo apt install -y ca-certificates curl gnupg lsb-release
```

3. Deshabilitar swap (recomendado para Kubernetes).

```bash
# Deshabilitar swap inmediatamente
sudo swapoff -a

# Deshabilitar swap de forma permanente
sudo sed -i '/ swap / s/^/#/' /etc/fstab

# Verificar que swap está deshabilitado
free -h | grep Swap
```

4. Habilitar el reenvío IP.

```bash
sudo tee /etc/sysctl.d/k3s.conf <<EOF 
net.ipv4.ip_forward = 1 
net.bridge.bridge-nf-call-iptables = 1 
net.bridge.bridge-nf-call-ip6tables = 1 
EOF 
sudo sysctl --system
```

5. Configurar el firewall.

```bash
# Comprobar si UFW está activo
sudo ufw status

# Si UFW está activo, permitir los puertos necesarios
sudo ufw allow 6443/tcp    # API de Kubernetes
sudo ufw allow 8472/udp    # Flannel VXLAN
sudo ufw allow 10250/tcp   # Kubelet
sudo ufw allow 80/tcp      # HTTP
sudo ufw allow 443/tcp     # HTTPS
```

***

Seleccione sus opciones de despliegue:

{% hint style="info" %}

{% endhint %}

{% tabs %}
{% tab title="Nodo único" %}
{% hint style="info" %}

#### **Instalación en nodo único**

{% endhint %}

1. Comprobar requisitos del sistema.

```bash
# Comprobar requisitos del sistema
echo "=== Información del sistema ==="
echo "SO: $(lsb_release -d | cut -f2)"
echo "Kernel: $(uname -r)"
echo "Núcleos CPU: $(nproc)"
echo "RAM total: $(free -h | awk '/^Mem:/ {print $2}')"
echo "Disco disponible: $(df -h / | awk 'NR==2 {print $4}')"
```

2. Instalar K3s.

```bash
# Instalar servidor K3s (incluye agente)
curl -sfL https://get.k3s.io | sh -
```

{% hint style="info" %}
Este comando:

\- Descarga e instala K3s

\- Inicia el servicio K3s

\- Instala kubectl

\- Configura kubeconfig

```
Qué se instala:
- Servidor K3s (plano de control + trabajador)
- Containerd (runtime de contenedores)
- Flannel (plugin de red CNI)
- CoreDNS (DNS del clúster)
- Traefik (controlador de ingress)
- Provisionador local-path (almacenamiento)
- Servidor de métricas
```

{% endhint %}

2. Configurar acceso a kubectl.

```bash
# Crear directorio de kube config
mkdir -p ~/.kube

# Copiar la configuración de K3s a la ubicación estándar
sudo cp /etc/rancher/k3s/k3s.yaml ~/.kube/config

# Corregir permisos
sudo chown $(id -u):$(id -g) ~/.kube/config
chmod 600 ~/.kube/config

# Establecer la variable de entorno KUBECONFIG
echo 'export KUBECONFIG=~/.kube/config' >> ~/.bashrc
source ~/.bashrc

# Probar acceso a kubectl
kubectl version --short
```

4\. Verificar instalación

```bash
# Comprobar estado de los nodos
kubectl get nodes

# Salida esperada:
# NAME         STATUS   ROLES                  AGE   VERSION
NAME      STATUS   ROLES           AGE     VERSION
pentaho   Ready    control-plane   5d20h   v1.34.3+k3s1

# Comprobar los pods del sistema
kubectl get pods -A
```

<figure><img src="/files/fd73cccd477586c08c93a9ccfbb5676148df3bb0" alt=""><figcaption><p>Verificar K3s</p></figcaption></figure>

5. Verifique la instalación de K3s.

```sh
cd
cd ~/Pentaho-K3s-PostgreSQL
./verify-k3s.sh
```

{% endtab %}

{% tab title="Multi-nodo" %}
{% hint style="info" %}

#### Clúster multi-nodo

{% endhint %}

#### Nodo servidor (plano de control)

```bash
# Instalar servidor K3s
curl -sfL https://get.k3s.io | sh -

# Obtener el token del nodo (necesario para agentes)
sudo cat /var/lib/rancher/k3s/server/node-token
```

#### Nodos agentes (trabajadores)

En cada nodo trabajador:

```bash
# Establecer variables
K3S_URL="https://<server-ip>:6443"
K3S_TOKEN="<node-token-from-server>"

# Instalar agente K3s
curl -sfL https://get.k3s.io | K3S_URL=$K3S_URL K3S_TOKEN=$K3S_TOKEN sh -
```

#### Verificar clúster multi-nodo

En el nodo servidor:

```bash
kubectl get nodes

# Salida esperada:
# NAME         STATUS   ROLES                  AGE   VERSION
# server-01    Ready    control-plane,master   5m    v1.29.0+k3s1
# worker-01    Ready    <none>                 2m    v1.29.0+k3s1
# worker-02    Ready    <none>                 1m    v1.29.0+k3s1
```

{% endtab %}

{% tab title="Alias de kubectl" %}

1. Agregar alias útiles.

```bash
# Agregar alias útiles
cat >> ~/.bashrc << 'EOF'

# Alias de Kubernetes
alias k='kubectl'
alias kgp='kubectl get pods'
alias kgs='kubectl get svc'
alias kgn='kubectl get nodes'
alias kga='kubectl get all'
alias kd='kubectl describe'
alias kl='kubectl logs'
alias kaf='kubectl apply -f'
alias kdf='kubectl delete -f'

# Habilitar autocompletado de kubectl
source <(kubectl completion bash)
complete -F __start_kubectl k
EOF

source ~/.bashrc
```

{% endtab %}

{% tab title="Post-instalación" %}
{% hint style="info" %}

### Configuración post-instalación

{% endhint %}

1. Verificar la clase de almacenamiento por defecto

```bash
# Verificar storage class
kubectl get storageclass
```

```
# Salida esperada:
NAME                   PROVISIONER             RECLAIMPOLICY   VOLUMEBINDINGMODE      ALLOWVOLUMEEXPANSION   AGE
local-path (default)   rancher.io/local-path   Delete          WaitForFirstConsumer   false                  5d21h
```

2. Configurar ingress Traefik

```bash
kubectl get pods -n kube-system -l app.kubernetes.io/name=traefik
```

3. Instalar Helm (opcional pero recomendado)

```bash
# Instalar Helm
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

# Verificar
helm version
```

4\. Instalar k9s (Opcional - UI en terminal)

```bash
# Instalar k9s para gestionar el clúster con mayor facilidad
curl -sS https://webinstall.dev/k9s | bash

# Ejecutar k9s
k9s
```

<figure><img src="/files/a063e0329e0d8eff6817201bfdbfcb0ba4a9da37" alt=""><figcaption><p>K9s</p></figcaption></figure>

5\. Verificar la instalación de K3s.

```bash
cd
cd ~/Pentaho-K3s-PostgreSQL

# Hacer el script ejecutable
chmod +x scripts/verify-k3s.sh

# Ejecutar verificación
./scripts/verify-k3s.sh
```

<figure><img src="/files/31cfc13c1a0a67df5eedfcd3f3d8ddeb4ab4b0b1" alt=""><figcaption><p>Verificar K3s</p></figcaption></figure>
{% endtab %}
{% endtabs %}
{% endtab %}

{% tab title="Helm" %}
{% hint style="info" %}

#### Gráficos de Helm

Helm es el gestor de paquetes para Kubernetes, a menudo referido como "apt/yum para Kubernetes." Simplifica el despliegue y la gestión de aplicaciones Kubernetes mediante:

**Empaquetado**: Agrupar recursos relacionados de Kubernetes

**Templado**: Parametrizar manifiestos para reutilizarlos en diferentes entornos

**Versionado**: Gestionar versiones y actualizaciones de aplicaciones

**Gestión de lanzamientos**: Rastrear despliegues y permitir revertir cambios
{% endhint %}

1. Ejecute el siguiente script de instalación.

```bash
cd
cd ~/Pentaho-K3s-PostgreSQL/helm-chart
./install-helm.sh
```

<figure><img src="/files/2226ceeb0438bc7f3510cef570ab60dfec1e203a" alt=""><figcaption><p>Instalar Helm</p></figcaption></figure>

o

1. Agregar la clave GPG de Helm.

```bash
# Agregar la clave GPG de Helm
curl https://baltocdn.com/helm/signing.asc | gpg --dearmor | sudo tee /usr/share/keyrings/helm.gpg > /dev/null# Install apt-transport-https package
```

2. Instalar dependencias

```bash
# Instalar paquete apt-transport-https:
sudo apt-get install apt-transport-https --yes
```

3. Agregar el repositorio de Helm.

```bash
# Agregar el repositorio de Helm
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/helm.gpg] https://baltocdn.com/helm/stable/debian/ all main" | sudo tee /etc/apt/sources.list.d/helm-stable-debian.list

```

4. Actualice la lista de paquetes e instale.

```sh
# Actualizar lista de paquetes:
sudo apt-get update

# instalar Helm:
sudo apt-get install helm
```

5. Verificar la instalación.

```sh
# Verificar instalación de Helm:
helm version --client
```

***

**Comandos de Helm**

```bash
# Comprueba su chart de Helm en busca de problemas antes de desplegar.
helm lint

# Renderiza las plantillas de su chart de Helm localmente y muestra la salida, útil para depuración.
helm template

# Simula la instalación del chart sin desplegarlo realmente, permitiéndole verificar cambios.
helm install my-chart . --dry-run

# Proporciona una lista de todos los comandos y opciones de Helm disponibles.
helm --help

# Actualiza una release existente con una nueva versión del chart, esencial para mantener y actualizar aplicaciones.
helm --help

# Lista todas las releases de Helm en el namespace actual, útil para rastrear aplicaciones desplegadas.
helm list

# Recupera los valores usados para una release específica, permitiéndole revisar o modificar la configuración.
helm get values RELEASE_NAME

# Elimina una release de Helm del clúster, eliminando los recursos de Kubernetes asociados.
helm delete RELEASE_NAME

# Revierte una release a una versión anterior, útil para volver a un estado estable si una actualización causa problemas.
helm rollback RELEASE_NAME REVISION

# Añade un repositorio de charts de Helm, habilitándole descargar charts desde diferentes fuentes.
helm repo add REPO_NAME REPO_URL

# Actualiza la caché local de repositorios de charts, asegurando que tiene las versiones más recientes disponibles.
helm repo update

# Empaqueta un chart de Helm en un archivo .tgz, que puede compartirse o subirse a un repositorio.
helm package CHART_PATH

# Envía un chart empaquetado a un repositorio Helm, facilitando la distribución y el despliegue.
helm push CHART_PATH REPO_NAME
```

{% endtab %}

{% tab title="DBeaver" %}
{% hint style="info" %}

#### DBeaver

Vas a necesitar una herramienta de gestión de bases de datos. DBeaver Community es una herramienta de gestión de bases de datos gratuita y de código abierto para proyectos personales.
{% endhint %}

1. La opción más sencilla es descargar e instalar desde Snapstore.

```bash
cd
sudo apt update && sudo apt upgrade
sudo apt install snapd
sudo snap install dbeaver-ce
```

O

Vaya a la página oficial [página de descargas de DBeaver](https://dbeaver.io/download/)

{% embed url="<https://dbeaver.io/files/dbeaver-ce_latest_amd64.deb>" %}

O

Para instalar ese archivo DEB.

```bash
wget https://dbeaver.io/debs/dbeaver.gpg.key -O /tmp/dbeaver.gpg.key
sudo gpg --dearmor -o /usr/share/keyrings/dbeaver.gpg /tmp/dbeaver.gpg.key
echo "deb [signed-by=/usr/share/keyrings/dbeaver.gpg] https://dbeaver.io/debs/dbeaver-ce /" | sudo tee /etc/apt/sources.list.d/dbeaver.list
sudo apt update
sudo apt install dbeaver-ce
```

4. Fijar DBeaver al Dash - barra de herramientas inferior.
   {% endtab %}

{% tab title="Make" %}
{% hint style="info" %}

#### Make

Un makefile es simplemente una forma de asociar nombres cortos, llamados objetivos, con una serie de comandos a ejecutar cuando se solicita la acción. Por ejemplo, un objetivo común de un makefile es “clean”, que generalmente realiza acciones que limpian después del compilador: eliminar archivos objeto y el ejecutable resultante.

Usaremos scripts auxiliares Make para agilizar el proceso de despliegue.
{% endhint %}

1. Actualizar el sistema operativo.

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

2. Comprobar si make ya está instalado.

```bash
make -version
```

3. Instalar el paquete make.

```bash
sudo apt install make
```

4. Verificar la instalación.

```bash
ls /usr/bin/make
```

{% endtab %}
{% endtabs %}


---

# 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/configuracion/contenedores-pentaho.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.