> 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/configuracion/pentaho-containers.md).

# Contenedores Pentaho

{% hint style="info" %}

#### Contenedores de Pentaho

Pentaho Server ofrece opciones de despliegue flexibles para adaptarse a una variedad de estrategias de infraestructura. Para **locales** entornos, las organizaciones pueden desplegar usando Docker Compose para configuraciones sencillas de un solo host, u orquestar en clústeres usando Kubernetes (K8s y K3s) para mayor escalabilidad y resiliencia.

Para **nube (hiperescalador)** implementaciones, Pentaho ofrece imágenes Docker optimizadas y preconstruidas, diseñadas específicamente para Amazon Web Services (EKS/ECR), Microsoft Azure (AKS) y Google Cloud Platform (GKE), lo que permite a los equipos aprovechar servicios de Kubernetes administrados y almacenamiento nativo de 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 entrada mejorados que admiten anulaciones de la configuración en tiempo de ejecución: esto significa que las licencias y los archivos de configuración pueden inyectarse al inicio sin reconstruir la imagen.

Un **híbrido** también está totalmente admitido, donde las organizaciones podrían ejecutar el Pentaho Server localmente para cargas de trabajo sensibles mientras despliegan contenedores del servidor Carte o nodos de trabajo PDI en la nube para manejar procesamiento en ráfagas, combinando 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 de Pentaho y deben completarse en orden 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 coherente en distintos 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 de Docker Engine en Ubuntu 24.04 LTS (Noble Numbat).
{% endhint %}

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

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

2. Instale los paquetes que permiten a apt usar repositorios sobre HTTPS.

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

3. Cree un directorio para los keyrings y añada 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. Añada el repositorio de Docker a sus fuentes 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 (noviembre de 2025):

```
Docker version 29.0.2, build 810xxxx
```

8. Verifique que Docker Engine se está ejecutando.

```bash
sudo systemctl status docker
```

El servicio debería mostrarse como "activo (en ejecución)".

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 que confirma que Docker funciona correctamente.
{% endhint %}

***

{% hint style="info" %}

#### Sin Sudo

De forma predeterminada, Docker requiere privilegios sudo. Para ejecutar comandos de Docker sin sudo.
{% endhint %}

1. Añada 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 %}

Compruebe la 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 las imágenes descargadas:

```bash
docker images
```

***

{% hint style="info" %}

#### Comandos comunes

Estos son comandos esenciales de Docker que usará con regularidad:

* `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 a partir de 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 los 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 de Kubernetes ligera y totalmente compatible, diseñada para entornos con recursos limitados y de computación en el borde. Se distribuye como un único binario o una imagen de contenedor mínima, lo que hace que su despliegue y administración sean significativamente más sencillos que los de Kubernetes estándar. La distribución utiliza SQLite3 como su almacén ligero predeterminado, aunque también admite etcd3, MySQL y Postgres para usuarios que necesiten opciones más robustas.

La plataforma simplifica las operaciones de Kubernetes al agrupar 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 de TLS, al tiempo que mantiene una seguridad predeterminada con ajustes sensatos para entornos ligeros. K3s tiene dependencias externas mínimas y solo requiere un kernel Linux moderno y montajes cgroup para ejecutarse.

K3s viene "con todo incluido" con componentes esenciales preempaquetados, eliminando la necesidad de instalación y configuración por separado. Esto incluye containerd para el tiempo de ejecución de contenedores, Flannel para la red, CoreDNS para el 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 periféricas, despliegues de IoT, canalizaciones de CI/CD y entornos de desarrollo.
{% endhint %}

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

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

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

2. Instale los paquetes que permiten a apt usar repositorios sobre HTTPS.

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

3. Desactive swap (recomendado para Kubernetes).

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

# Desactivar swap permanentemente
sudo sed -i '/ swap / s/^/#/' /etc/fstab

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

4. Active el reenvío de 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. Configure el firewall.

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

# Si UFW está activo, permita 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:

{% tabs %}
{% tab title="Un solo nodo" %}
{% hint style="info" %}

#### **Instalación de un solo nodo**

{% endhint %}

1. Compruebe los requisitos del sistema.

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

2. Instale K3s.

```bash
# Instalar el servidor K3s (incluye el 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 (tiempo de ejecución 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. Configure el acceso de kubectl.

```bash
# Crear directorio de configuración de kube
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 el acceso a kubectl
kubectl version --short
```

4\. Verificar la instalación

```bash
# Comprobar el estado del nodo
kubectl get nodes

# Salida esperada:
# NOMBRE         ESTADO   ROLES                  EDAD   VERSIÓN
NOMBRE    ESTADO   ROLES           EDAD     VERSIÓN
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="Multinodo" %}
{% hint style="info" %}

#### Clúster multinodo

{% endhint %}

#### Nodo servidor (plano de control)

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

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

#### Nodos agente (trabajadores)

En cada nodo trabajador:

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

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

#### Verificar el clúster multinodo

En el nodo servidor:

```bash
kubectl get nodes

# Salida esperada:
# NOMBRE         ESTADO   ROLES                  EDAD   VERSIÓN
# 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. Añada alias útiles.

```bash
# Añadir 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'

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

source ~/.bashrc
```

{% endtab %}

{% tab title="Posterior a la instalación" %}
{% hint style="info" %}

### Configuración posterior a la instalación

{% endhint %}

1. Verificar la clase de almacenamiento predeterminada

```bash
# Verificar la clase de almacenamiento
kubectl get storageclass
```

```
# Salida esperada:
NOMBRE                   PROVISIONADOR         POLÍTICADERETENCIÓN   MODODEENLACEDEVOLUMEN   PERMITIREXPANSIÓNDEVOLUMEN   EDAD
local-path (default)   rancher.io/local-path   Delete          WaitForFirstConsumer   false                  5d21h
```

2. Configurar Traefik Ingress

```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 - interfaz de terminal)

```bash
# Instalar k9s para una gestión más sencilla del clúster
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 ejecutable el script
chmod +x scripts/verify-k3s.sh

# Ejecutar la 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" %}

#### Charts de Helm

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

**Empaquetado**: Agrupar recursos relacionados de Kubernetes

**Plantillas**: Parametrizar manifiestos para su reutilización entre entornos

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

**Gestión de lanzamientos**: Seguir despliegues y permitir reversiones
{% 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. Añada la clave GPG de Helm.

```bash
# Añadir la clave GPG de Helm
curl https://baltocdn.com/helm/signing.asc | gpg --dearmor | sudo tee /usr/share/keyrings/helm.gpg > /dev/null# Instalar el paquete apt-transport-https
```

2. Instalar dependencias

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

3. Añada el repositorio de Helm.

```bash
# Añadir 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 la lista de paquetes:
sudo apt-get update

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

5. Verifique la instalación.

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

***

**Comandos de Helm**

```bash
# Comprueba tu chart de Helm en busca de problemas antes de desplegarlo.
helm lint

# Renderiza localmente las plantillas de tu chart de Helm y muestra la salida, útil para depurar.
helm template

# Simula la instalación del chart sin desplegarlo realmente, lo que te permite verificar los cambios.
helm install my-chart . --dry-run

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

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

# Muestra todos los lanzamientos de Helm en el espacio de nombres actual, útil para hacer seguimiento de las aplicaciones desplegadas.
helm list

# Obtiene los valores utilizados para un lanzamiento específico, lo que te permite revisar o modificar la configuración.
helm get values RELEASE_NAME

# Elimina un lanzamiento de Helm del clúster, quitando los recursos de Kubernetes asociados.
helm delete RELEASE_NAME

# Revierte un lanzamiento 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, lo que te permite descargar charts de distintas fuentes.
helm repo add REPO_NAME REPO_URL

# Actualiza la caché local de repositorios de charts, asegurando que dispongas de las últimas versiones 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

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

{% endtab %}

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

#### DBeaver

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

1. La opción más sencilla es descargarlo e instalarlo 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 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. Fije DBeaver en Dash - barra inferior.
   {% endtab %}

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

#### Hacer

Un makefile es simplemente una forma de asociar nombres cortos, llamados objetivos, con una serie de comandos que se ejecutan 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: eliminando archivos objeto y el ejecutable resultante.

Usaremos scripts auxiliares de 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
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/configuracion/pentaho-containers.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.