> 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/contenedores/docker.md). # Docker {% hint style="info" %} #### Contenedor Docker El despliegue de contenedores Docker le permite empaquetar y ejecutar productos Pentaho dentro de contenedores portátiles y listos para producción. La contenedorización garantiza un comportamiento consistente entre los entornos de desarrollo, pruebas y producción, al tiempo que simplifica las operaciones de despliegue y escalado. Puede crear contenedores Docker para el Pentaho Server, que incluye la plataforma completa de Business Analytics y Data Integration con la Pentaho User Console, servicios de programación y gestión del repositorio. El servidor admite bases de datos empresariales de respaldo, incluidas PostgreSQL, MySQL, Oracle y SQL Server. Para el procesamiento ETL distribuido, puede desplegar contenedores del servidor Carte que ejecutan transformaciones y trabajos de forma remota. Las herramientas de línea de comandos Kitchen y Pan también están disponibles como contenedores, lo que permite la integración con pipelines de CI/CD y flujos de trabajo por lotes automatizados. Los despliegues en contenedores son especialmente eficaces para entornos en la nube donde puede escalar recursos rápidamente para ajustarse a las demandas de procesamiento de datos. Al ejecutar cargas de trabajo de Pentaho en contenedores, las organizaciones pueden optimizar los costos de infraestructura manteniendo la flexibilidad para moverse entre plataformas locales y en la nube. {% endhint %}

Arquitectura de contenedores Docker que muestra contenedores Pentaho Server y PostgreSQL

{% tabs %} {% tab title="Contenedor Pentaho Server" %} {% hint style="info" %} Este contenedor ejecuta la plataforma completa de Pentaho Business Analytics y Data Integration sobre Apache Tomcat 10. Incluye la Pentaho User Console (PUC), servicios de programación y todas las capacidades analíticas. {% endhint %} {% endtab %} {% tab title="Contenedor PostgreSQL" %} {% hint style="info" %} Este contenedor proporciona el backend de base de datos relacional usando PostgreSQL 17. Aloja tres bases de datos críticas requeridas por Pentaho: Jackrabbit (repositorio de contenido), Quartz (programador) y Hibernate (seguridad y auditoría). Los datos se persisten mediante un volumen Docker para sobrevivir a reinicios de contenedores. {% endhint %}

Arquitectura de base de datos PostgreSQL

Pentaho Server requiere tres bases de datos separadas, cada una con un propósito distinto:
Base de datosPropietarioPropósito y contenido
jackrabbitjcr_userRepositorio de Contenido Java (JCR) - Almacena todo el contenido de Pentaho, incluidos informes, paneles, orígenes de datos, esquemas de análisis y archivos de usuario. Este es el almacenamiento principal de contenido para el repositorio de Pentaho.
quartzpentaho_userQuartz Scheduler - Administra todos los trabajos programados, triggers y calendarios. Contiene tablas para definiciones de trabajos (QRTZ6_JOB_DETAILS), triggers (QRTZ6_TRIGGERS), historial de ejecución y candados de coordinación de clúster.
hibernatehibuserRepositorio Hibernate - Aloja la configuración de seguridad, el registro de auditoría, los datos de sesión de usuario y contiene dos esquemas adicionales: pentaho_dilogs (registro de ejecución de ETL) y pentaho_operations_mart (data mart de analíticas).
{% hint style="info" %} La base de datos hibernate contiene esquemas especializados para monitoreo operacional: **pentaho\_dilogs**: Captura información detallada de la ejecución de ETL, incluidos registros de trabajos, registros de transformaciones, métricas de rendimiento de pasos y registros de errores. Esencial para depurar flujos de integración de datos y monitorear la salud de las canalizaciones. **pentaho\_operations\_mart**: Un data mart dimensional para análisis del uso de Pentaho. Contiene tablas de dimensión (DIM\_DATE, DIM\_TIME, DIM\_EXECUTOR) y tablas de hechos (FACT\_EXECUTION, FACT\_STEP\_EXECUTION) para analizar la utilización de la plataforma, tendencias de rendimiento y actividad de los usuarios. Para despliegues de producción, implemente copias de seguridad regulares del volumen Docker repository-data. La base de datos jackrabbit es la más crítica ya que contiene todo el contenido de los usuarios. Considere usar pg\_dump para copias lógicas o snapshots de volúmenes para opciones de recuperación completas. {% endhint %} {% endtab %} {% tab title="Red" %} {% hint style="info" %} Puntos clave: * El contenedor Pentaho se conecta a PostgreSQL usando el nombre de servicio 'repository' como nombre de host * PostgreSQL escucha en el puerto 5432 internamente (no expuesto al host por defecto) * Pentaho Server expone el puerto 8080, mapeado al sistema host * Todo el tráfico entre contenedores permanece dentro de la red Docker por seguridad {% endhint %}

Flujo de datos que muestra solicitudes HTTP y conexiones JDBC

Tomcat gestiona pools de conexión definidos en context.xml. Cada pool sirve un propósito específico:
Nombre del poolDestino de la conexiónUsado para
jdbc/Hibernaterepository:5432/hibernateSeguridad, usuarios, roles
jdbc/Quartzrepository:5432/quartzProgramación de trabajos
jdbc/jackrabbitrepository:5432/jackrabbitRepositorio de contenido
jdbc/Auditrepository:5432/hibernateRegistro de auditoría
jdbc/live_logging_inforepository:5432/hibernateRegistros en tiempo de ejecución de ETL
jdbc/PDI_Operations_Martrepository:5432/hibernateAnalítica de operaciones
{% hint style="info" %} Cuando un usuario accede a Pentaho Server: 1\. El navegador del usuario envía una solicitud HTTP a localhost:8080 2\. Docker reenvía la solicitud al puerto 8080 del contenedor Pentaho 3\. Tomcat recibe la solicitud y la enruta a la aplicación web pentaho.war 4\. La aplicación recupera/almacena datos a través de los pools de conexiones JDBC 5\. Las conexiones JDBC se enrutan a 'repository:5432' (contenedor PostgreSQL) 6\. La respuesta fluye de regreso por la misma ruta al navegador del usuario {% endhint %} {% endtab %} {% tab title="Mapeo de volúmenes" %} {% hint style="info" %} #### Mapeo de volúmenes El despliegue usa tanto volúmenes Docker con nombre como bind mounts para persistencia y configuración: {% endhint %} ``` Volúmenes Docker: vault_data -> /vault/data pentaho_postgres_data -> /var/lib/postgresql/data pentaho_solutions -> /opt/pentaho/pentaho-server/pentaho-solutions pentaho_data -> /opt/pentaho/pentaho-server/data Bind mounts: ./softwareOverride -> /docker-entrypoint-init (ro) ./db_init_postgres -> /docker-entrypoint-initdb.d (ro) ./postgres-config -> /etc/postgresql/conf.d (ro) ./config/.kettle -> /home/pentaho/.kettle ./config/.pentaho -> /home/pentaho/.pentaho ./vault/config -> /vault/config (ro) ./scripts -> /scripts (ro) ``` {% endtab %} {% endtabs %} *** {% hint style="danger" %} Antes de comenzar el despliegue Docker, asegúrese de haber completado la configuración: [Contenedores Pentaho](/pentaho-11-installation-en/pentaho-11-installation-es/configuracion/contenedores-de-pentaho.md) {% endhint %} Siga los pasos siguientes para desplegar Pentaho Server con el repositorio PostgreSQL 15. {% tabs %} {% tab title="1. Preparar el entorno" %} {% hint style="info" %} #### Preparar el entorno Compruebe que Docker esté en funcionamiento: * Copiar los assets de Pentaho-Server-PostgreSQL * Copiar `pentaho-server-ee-11.0.0.0-237.zip` * Verificar Docker y Docker Compose * Comprobar puertos {% endhint %} {% hint style="danger" %} Asegúrese de haber descargado: `pentaho-server-ee-11.0.0.0-237.zip` {% endhint %} 1. Crear directorio del proyecto y copiar los assets. ```bash cd cp -r ~/Workshop--Installation/Pentaho-Containers/On-Prem/Pentaho-Server-PostgreSQL . ``` 2. Copie el pentaho-server-ee-11.0.0.0-237.zip en el directorio /docker/stagedArtefacts. {% hint style="info" %} Si ha desplegado previamente un Pentaho Server de archivo, entonces copie desde: `/opt/pentaho/software/pentaho-server-ee-version` De lo contrario, descargue el paquete desde el [Portal de clientes de Pentaho](https://support.pentaho.com/hc/en-us). {% endhint %} ```bash cd cd ~/Pentaho-Server-PostgreSQL/docker/stagedArtifacts cp /opt/pentaho/software/server/pentaho-server-ee-11.0.0.0-237.zip . ``` 3. Verifique que el archivo. ```bash cd cd ~/Pentaho-Server-PostgreSQL/docker/stagedArtifacts ls -al ``` 4. Compruebe la versión de Docker. ```bash docker --version # Salida esperada: Docker version 29.0.2 o superior ``` 5. Comprobar la versión de Docker Compose. ```bash docker compose --version # Salida esperada: Docker Compose version 2.40.3 o superior ``` ```bash sudo apt install docker-compose # instala Docker Compose ``` 6. Verifique que el daemon de Docker esté en ejecución. ```bash docker info # Debe mostrar información del sistema sin errores ``` 7. Compruebe que el puerto 8080 / 8090 esté disponible en el sistema host. ```bash sudo lsof -i ::8080 ``` {% hint style="info" %} Si el puerto 8080 está en uso por otra aplicación, puede cambiar la variable PORT en el archivo .env a cualquier puerto disponible (p. ej. 8090, 8081, 9090). {% endhint %} 8. Pentaho Server requiere una licencia válida. El `.env` archivo contiene un LICENSE\_URL que apunta al servidor de licencias de Flexera. Asegúrese de que sus derechos de licencia estén activos antes del despliegue. {% hint style="warning" %} Sin una licencia válida, Pentaho Server se iniciará pero muchas funciones estarán deshabilitadas. Verifique el estado de su licencia antes de proceder con despliegues de producción. {% endhint %} {% endtab %} {% tab title="2. Estructura de directorios" %} {% hint style="info" %} #### Estructura de directorios Esta configuración de despliegue proporciona varias capacidades importantes: * Despliegue completamente autónomo y portátil. * Inicialización automatizada de la base de datos con scripts SQL. * Controles de salud y orden correcto de inicio entre servicios. * Volúmenes de datos persistentes para la base de datos y el contenido de Pentaho. * HashiCorp Vault para la gestión de secretos con autenticación AppRole. * Contenedores de solo lectura con montajes tmpfs para seguridad. * Límites de recursos (CPU/memoria) para estabilidad. * Rotación de logs para prevenir el agotamiento del disco. * Sistema de anulación de software para personalizar configuraciones sin modificar archivos principales. * Plantillas de configuración listas para producción. * Controlador JDBC de PostgreSQL incluido * Procedimientos sencillos de copia de seguridad y restauración {% endhint %} {% hint style="success" %} Consulte las otras opciones de despliegue de repositorio en: ``` ~/Workshop--Installation/Pentaho-Containers/On-Prem/ ``` {% endhint %} *** **Archivos del directorio raíz** ``` Pentaho-Server-PostgreSQL/ ├── README.md # Archivo principal de documentación ├── ARCHITECTURE.md # Detalles de la arquitectura del sistema ├── CONFIGURATION.md # Guía de referencia de configuración ├── TROUBLESHOOTING.md # Guía de resolución de problemas ├── docker-compose.yml # Definiciones de servicios de Docker Compose ├── Makefile # Objetivos de conveniencia (make help) ├── deploy.sh # Script de despliegue automatizado ├── .env # Configuración de entorno (creado) ├── .env.template # Plantilla de entorno con valores por defecto ``` {% hint style="info" %} **Archivos de documentación:** **README.md** - El punto de entrada principal de la documentación que proporciona una visión general del proyecto, instrucciones de inicio rápido, prerequisitos e información general de uso para el taller. **ARCHITECTURE.md** - Documentación técnica detallada que cubre la arquitectura del sistema, relaciones entre componentes, diseño de contenedores, redes, flujo de datos y decisiones arquitectónicas para el despliegue basado en Docker. **CONFIGURATION.md** - Guía de referencia de configuración completa que detalla todas las variables de entorno disponibles, opciones de configuración, parámetros de personalización y ajustes tanto para Pentaho Server como para los componentes de PostgreSQL. **TROUBLESHOOTING.md** - Guía de resolución de problemas con problemas comunes, mensajes de error, procedimientos de diagnóstico y soluciones para problemas de despliegue y tiempo de ejecución que pueda encontrar. **Orquestación y despliegue:** **docker-compose.yml** - El archivo de definiciones de servicios de Docker Compose que declara todos los contenedores (Pentaho Server, PostgreSQL, potencialmente Vault/otros servicios), sus configuraciones, redes, volúmenes y dependencias. **Makefile** - Contiene objetivos de comandos de conveniencia para operaciones comunes como construir, iniciar, detener y limpiar el entorno. Los usuarios pueden ejecutar `make help` para ver los comandos disponibles. **deploy.sh** - Script de despliegue automatizado que probablemente maneja el flujo completo de despliegue, incluida la validación del entorno, la construcción de imágenes, el inicio de servicios y la configuración inicial. **Configuración de entorno:** **.env** - El archivo de configuración de entorno activo (creado a partir de la plantilla) que contiene valores reales para contraseñas de base de datos, puertos, nombres de host y otras configuraciones específicas del entorno. Este archivo normalmente está ignorado por git. **.env.template** - El archivo plantilla con valores por defecto y marcadores de posición que los usuarios copian para crear su `.env` archivo, proporcionando una referencia para todas las variables de entorno configurables. {% endhint %} *** **Contexto de compilación de Docker** ``` ├── docker/ │ ├── Dockerfile # Construcción de la imagen Pentaho Server en varias etapas │ ├── entrypoint/ │ │ └── docker-entrypoint.sh # Script de inicio del contenedor │ └── stagedArtifacts/ │ └── pentaho-server-ee-11.0.0.0-237.zip ``` {% hint style="info" %} El **docker/** directorio contiene todos los componentes principales necesarios para construir y ejecutar el despliegue contenedorizado de Pentaho Server: **Dockerfile** - Esta es la configuración principal de compilación que utiliza un enfoque de compilación en varias etapas para crear la imagen del contenedor Pentaho Server. Las compilaciones en varias etapas ayudan a optimizar el tamaño final de la imagen separando el entorno de compilación del entorno de ejecución. **entrypoint/** directorio contiene el **docker-entrypoint.sh** script, que es el script de inicialización que se ejecuta cuando el contenedor se inicia. Normalmente maneja tareas como configuración del entorno, gestión de la configuración, comprobaciones de salud y el inicio de los servicios de Pentaho Server. **stagedArtifacts/** directorio sirve como área de preparación para el paquete de instalación de Pentaho Server. Actualmente contiene **pentaho-server-ee-11.0.0.0-237.zip**, que es la edición Enterprise versión 11.0.0.0 compilación 237 que se extrae e instala durante el proceso de construcción de la imagen Docker. {% endhint %} *** **Inicialización de la base de datos del repositorio PostgreSQL** ``` ├── db_init_postgres/ │ ├── 1_create_jcr_postgresql.sql # Repositorio de contenido Jackrabbit │ ├── 2_create_quartz_postgresql.sql # Programador Quartz │ ├── 3_create_repository_postgresql.sql # Repositorio Hibernate │ ├── 4_pentaho_logging_postgresql.sql # Esquema de registro de auditoría/DI │ └── 5_pentaho_mart_postgresql.sql # Esquema del mart de operaciones ``` {% hint style="info" %} El **db\_init\_postgres/** directorio contiene los scripts de inicialización de la base de datos PostgreSQL que configuran todos los esquemas requeridos para Pentaho Server 11. Estos scripts están numerados para ejecutarse en una secuencia específica: **1\_create\_jcr\_postgresql.sql** - Crea el **Repositorio de Contenido Jackrabbit (JCR)** esquema, que almacena el contenido del repositorio de Pentaho, incluidos archivos de solución, programaciones, informes, paneles y metadatos. Este es el sistema central de gestión de contenido para Pentaho. **2\_create\_quartz\_postgresql.sql** - Configura el **Quartz Scheduler** esquema, que gestiona todos los trabajos y tareas programadas dentro de Pentaho Server, incluida la generación de informes, ejecuciones ETL y otros procesos automatizados. **3\_create\_repository\_postgresql.sql** - Crea el **Hibernate Repository** esquema, que almacena la autenticación de usuarios, datos de autorización, roles, permisos y otra información relacionada con la seguridad gestionada por el subsistema de seguridad de Pentaho. **4\_pentaho\_logging\_postgresql.sql** - Establece el **Registro de Auditoría y de Data Integration (DI)** esquema para capturar registros de ejecución, métricas de transformaciones/ trabajos e información de la pista de auditoría de los procesos PDI que se ejecutan en el servidor. **5\_pentaho\_mart\_postgresql.sql** - Crea el **Operations Mart** esquema, que almacena datos analíticos operacionales sobre el uso de Pentaho Server, métricas de rendimiento e información de monitoreo del sistema utilizada por el panel Pentaho Operations Mart. {% endhint %} *** **Configuración de PostgreSQL y Vault** ``` ├── postgres-config/ │ ├── custom.conf # Ajustes de rendimiento de PostgreSQL │ └── pg_hba.conf # Configuración de autenticación de clientes ├── vault/ │ ├── config/ │ │ └── vault.hcl # Configuración del servidor Vault │ └── policies/ │ └── pentaho-policy.hcl # Política de acceso de Pentaho ├── secrets/ │ └── postgres_password.txt # Archivo de secrets de Docker ``` {% hint style="info" %} **postgres-config/** - Configuración de PostgreSQL **custom.conf** - Parámetros personalizados de ajuste de rendimiento de PostgreSQL optimizados para las cargas de trabajo de Pentaho Server. Esto probablemente incluye configuraciones para shared\_buffers, work\_mem, límites de conexiones, configuraciones de checkpoint y otros parámetros relacionados con el rendimiento adaptados para manejar los requisitos de base de datos de Pentaho. **pg\_hba.conf** - Archivo de configuración de autenticación basada en host de PostgreSQL que controla los métodos de autenticación de clientes, reglas de acceso por dirección IP y políticas de seguridad para conexiones de base de datos desde el contenedor Pentaho Server. *** **vault/** - Integración con HashiCorp Vault Este directorio facilita la incorporación de Vault para la gestión de secretos: **config/vault.hcl** - El archivo de configuración del servidor HashiCorp Vault que define el backend de almacenamiento, la configuración del listener, endpoints de API, comportamiento de sellado/desellado y parámetros operativos generales del servidor Vault. **policies/pentaho-policy.hcl** - Política de control de acceso de Vault específicamente para Pentaho Server, que define qué rutas de secretos la aplicación Pentaho puede leer, escribir o gestionar. Esto hace cumplir el acceso de mínimo privilegio a credenciales sensibles. *** **secrets/** - Gestión de secrets de Docker **postgres\_password.txt** - Un archivo de secrets de Docker que contiene la contraseña de PostgreSQL. Al usar Docker secrets (o integración con Vault), este archivo proporciona las credenciales de la base de datos de manera segura en lugar de pasarlas como variables de entorno en texto plano. El archivo debe tener permisos restringidos y normalmente es referenciado por Docker Compose usando la `secrets:` configuración. {% endhint %}
ClaveDescripción
postgres_passwordContraseña del superusuario de PostgreSQL
pentaho_userNombre de usuario de la base de datos de Pentaho
pentaho_passwordContraseña de la base de datos de Pentaho
jdbc_urlURL de conexión JDBC
*** **Anulaciones de configuración de Pentaho** ``` ├── softwareOverride/ │ ├── 1_drivers/ # Controladores JDBC │ │ └── tomcat/lib/ │ ├── 2_repository/ # Configuración de la base de datos │ │ ├── pentaho-solutions/system/ │ │ │ ├── hibernate/ │ │ │ ├── jackrabbit/ │ │ │ └── scheduler-plugin/quartz/ │ │ └── tomcat/webapps/pentaho/META-INF/ │ ├── 3_security/ # Configuraciones de autenticación │ │ └── pentaho-solutions/system/ │ └── 4_others/ # Configuraciones de Tomcat y la aplicación │ ├── pentaho-solutions/system/ │ └── tomcat/ ``` {% hint style="info" %} El **softwareOverride/** directorio contiene archivos de configuración y componentes personalizados que anulan la instalación predeterminada de Pentaho Server. La estructura numerada asegura una organización lógica y potencialmente una aplicación ordenada durante el proceso de compilación de Docker: *** **1\_drivers/** - Controladores JDBC de base de datos **tomcat/lib/** - Contiene archivos JAR de los controladores JDBC (específicamente el controlador JDBC de PostgreSQL) que se copian en el directorio de librerías de Tomcat, permitiendo que Pentaho Server se conecte a bases de datos PostgreSQL. *** **2\_repository/** - Configuración del repositorio de base de datos Esta sección configura la conexión de Pentaho a todos los repositorios respaldados por PostgreSQL: **pentaho-solutions/system/hibernate/** - Archivos de configuración del repositorio Hibernate (repository.xml, hibernate-settings.xml) para datos de seguridad de usuarios/roles **pentaho-solutions/system/jackrabbit/** - Configuración del repositorio JCR de Jackrabbit (repository.xml) para el almacenamiento de contenido **pentaho-solutions/system/scheduler-plugin/quartz/** - Configuración de la base de datos del programador Quartz (quartz.properties) para la programación de trabajos **tomcat/webapps/pentaho/META-INF/** - Contiene context.xml con definiciones JNDI de fuentes de datos para todas las bases de datos de Pentaho (Quartz, Jackrabbit, Hibernate, Audit, Operations Mart) *** **3\_security/** - Configuraciones de autenticación y seguridad **pentaho-solutions/system/** - Archivos de configuración de seguridad que incluyen applicationContext-security.xml, security.properties y potencialmente configuraciones LDAP/SSO para autenticación y autorización. *** **4\_others/** - Ajustes adicionales de Tomcat y de la aplicación **pentaho-solutions/system/** - Otras configuraciones a nivel de sistema como pentaho.xml, pentaho-spring-beans.xml, configuraciones de log4j y configuraciones de comportamiento de la aplicación **tomcat/** - Personalizaciones del servidor Tomcat que incluyen server.xml, web.xml, setenv.sh para parámetros JVM y otros ajustes específicos de Tomcat {% endhint %} **Scripts utilitarios** ``` ├── scripts/ │ ├── backup-postgres.sh # Utilidad de copia de seguridad de la base de datos │ ├── restore-postgres.sh # Utilidad de restauración de la base de datos │ ├── backup-vault.sh # Copia de seguridad de credenciales de Vault │ ├── restore-vault.sh # Restauración de credenciales de Vault │ ├── rotate-secrets.sh # Script de rotación de contraseñas │ ├── fetch-secrets.sh # Ayudante para recuperación de secretos │ ├── vault-init.sh # Inicialización de Vault │ └── validate-deployment.sh # Validación del despliegue ``` {% hint style="info" %} El **scripts/** directorio contiene utilidades operativas y de mantenimiento para gestionar el despliegue de Pentaho Server, organizadas por área funcional: *** **Gestión de base de datos:** **backup-postgres.sh** - Utilidad automatizada de copia de seguridad de PostgreSQL que crea volcados de todas las bases de datos de Pentaho (JCR, Quartz, Hibernate, Audit, Operations Mart). Probablemente incluye timestamping, compresión y lógica de retención de backups. **restore-postgres.sh** - Utilidad de restauración de base de datos para recuperar las bases de datos de Pentaho desde archivos de copia de seguridad, útil para recuperación ante desastres, clonación de entornos o migración de datos entre instancias. *** **Vault/Gestión de secrets:** **backup-vault.sh** - Script de copia de seguridad de credenciales y claves de desellado de HashiCorp Vault, asegurando la capacidad de recuperación para la instancia de Vault que contiene credenciales sensibles de Pentaho. **restore-vault.sh** - Utilidad de restauración de Vault para recuperar datos de Vault y re-inicializar el sistema de gestión de secretos a partir de una copia de seguridad. **rotate-secrets.sh** - Script automatizado de rotación de contraseñas que actualiza las contraseñas de bases de datos y otras credenciales sensibles en Vault, y luego propaga los cambios a la configuración de Pentaho Server, soportando las mejores prácticas de seguridad. **fetch-secrets.sh** - Utilidad auxiliar para recuperar secretos de Vault de forma programática, útil para scripts que necesitan acceder a credenciales sin codificarlas. **vault-init.sh** - Script de configuración inicial de Vault que maneja la inicialización de Vault, el desellado, la creación de la política de Pentaho y el almacenamiento de secretos iniciales para el despliegue. *** **Operaciones y validación:** **validate-deployment.sh** - Script de validación del despliegue que realiza comprobaciones de salud en todos los componentes (conectividad PostgreSQL, inicio de Pentaho Server, accesibilidad de Vault, disponibilidad de servicios), confirmando que el entorno está correctamente configurado y operativo. {% endhint %} *** **Configuración de usuario y almacenamiento de datos** ``` ├── config/ │ ├── .kettle/ # Configuración PDI/Kettle │ │ └── kettle.properties │ └── .pentaho/ # Ajustes de usuario de Pentaho ├── backups/ # Almacenamiento de copias de seguridad de bases de datos │ └── *.sql.gz # Backups SQL comprimidos └── logs/ # Logs de la aplicación (opcional) ``` {% hint style="info" %} **config/** - Configuración de la aplicación Este directorio almacena archivos de configuración a nivel de usuario y de aplicación: **`.kettle/`** - Directorio de configuración de PDI (Pentaho Data Integration) / Kettle * **kettle.properties** - Contiene variables de entorno de Kettle/PDI, parámetros de conexión, propiedades del sistema y ajustes globales utilizados por las ejecuciones de transformaciones y trabajos que se ejecutan en Pentaho Server. **`.pentaho/`** - Directorio de ajustes de usuario de Pentaho para almacenar preferencias específicas del usuario, metadatos en caché e información del estado de la aplicación. *** **backups/** - Almacenamiento de copias de seguridad de la base de datos **`*.sql.gz`** - Repositorio para archivos de copia de seguridad comprimidos de la base de datos PostgreSQL creados por el `backup-postgres.sh` script. La compresión gzip reduce los requisitos de almacenamiento mientras mantiene instantáneas completas de la base de datos para recuperación ante desastres, clonación de entornos o escenarios de reversión. Es probable que los archivos de backup tengan marcas de tiempo para el seguimiento de versiones. *** **logs/** - Registro de la aplicación Directorio centralizado de logs para capturar registros de tiempo de ejecución de todos los servicios. Esto probablemente incluye: * Registros de la aplicación Pentaho Server (catalina.out, pentaho.log) * Registros de la base de datos PostgreSQL * Registros del servicio Vault * Logs de contenedores Docker * Registros de ejecución de ETL Esto respalda la **configuración de rotación de logs** y las capacidades de monitoreo que ha estado incorporando en su despliegue, facilitando la resolución de problemas y la auditoría durante los talleres. {% endhint %} *** **Archivos clave**
ArchivoPropósito
docker-compose.ymlDefine todos los servicios (pentaho-server, postgres), redes y volúmenes
docker/DockerfileConstrucción en varias etapas usando debian:trixie-slim con OpenJDK 21
docker-entrypoint.shProcesa directorios softwareOverride al inicio del contenedor
.envConfiguración específica del entorno (puertos, contraseñas, memoria)
deploy.shDespliegue automatizado con comprobaciones de validación previas
db_init_postgres/*.sqlScripts de inicialización de la base de datos PostgreSQL
vault-init.shInicializa Vault y almacena secretos
rotate-secrets.shRota contraseñas de bases de datos de forma segura
{% endtab %} {% tab title="3. Tareas previas al vuelo" %} {% hint style="info" %} #### Tareas previas al vuelo La sección de Tareas previas al vuelo describe los pasos de preparación esenciales necesarios antes de desplegar Pentaho Server 11 en contenedores Docker. Primero, debe configurar las variables de entorno editando el `.env.template` archivo con sus ajustes específicos de despliegue. Esto incluye definir la versión e información de la imagen de Pentaho, credenciales y configuración de puerto de PostgreSQL (por defecto 5432), puertos HTTP y HTTPS de Pentaho (8090 y 8443), asignación de memoria JVM (mínimo 4GB, máximo 8GB), la URL del servidor de licencias y la configuración del puerto de Vault. Una vez configurada, esta plantilla se guarda como el `.env` archivo activo. El ajuste del rendimiento de PostgreSQL se maneja mediante el archivo `postgres-config/custom.conf` donde puede personalizar los límites de conexión (por defecto 200 conexiones máximas), parámetros de asignación de memoria incluyendo shared\_buffers y tamaños de caché, y otras optimizaciones de rendimiento específicamente ajustadas para entornos contenedorizados. Finalmente, el `softwareOverride/` directorio proporciona un mecanismo opcional para personalizar las configuraciones de Pentaho sin modificar los archivos principales de la instalación. El controlador JDBC de PostgreSQL viene incluido por defecto, pero opcionalmente puede actualizarlo descargándolo desde Maven Central o copiándolo desde la colección de drivers de base de datos del taller. Esta preparación garantiza que todos los archivos, configuraciones y credenciales requeridos estén correctamente preparados antes de ejecutar el script de despliegue automatizado. {% endhint %} *** **Configurar .env** 1. Editar el .env.template ```bash cd cd ~/Pentaho-Server-PostgreSQL nano .env.template ``` 2. Introduzca los siguientes detalles:
VariablePor defectoDescripción
PENTAHO_VERSION11.0.0.0-237Versión de Pentaho Server
PENTAHO_IMAGE_NAMEpentaho/pentaho-serverNombre de la imagen Docker
PENTAHO_IMAGE_TAG11.0.0.0-237Etiqueta de la imagen Docker
POSTGRES_PASSWORDcontraseñaContraseña root de PostgreSQL
POSTGRES_PORT5432Puerto expuesto de PostgreSQL
PENTAHO_HTTP_PORT8090Puerto HTTP de Pentaho
PENTAHO_HTTPS_PORT8443Puerto HTTPS de Pentaho
PENTAHO_MIN_MEMORY4096mTamaño mínimo del heap de la JVM
PENTAHO_MAX_MEMORY8192mTamaño máximo del heap de la JVM
LICENSE_URL(vacío)URL del servidor de licencias EE
VAULT_PORT8200Puerto de la API de Vault
3. Guardar: ``` CTRL + o Enter CTRL + x ``` 4. Crear .env ```bash cd cd ~/Pentaho-Server-PostgreSQL cp .env.template .env ``` *** **Personalizar postgres-config/custom.conf** 1. Editar el .env.template ```bash cd cd ~/Pentaho-Server-PostgreSQL/progres-config nano custom.conf ``` 2. Introduzca los siguientes detalles: ```conf # Límites de conexión max_connections = 200 # Memoria (ajustar según la RAM disponible) shared_buffers = 256MB effective_cache_size = 768MB work_mem = 16MB # Rendimiento random_page_cost = 1.1 effective_io_concurrency = 200 ``` 3. Guardar: ``` CTRL + o Enter CTRL + x ``` *** **softwareOverride** {% hint style="info" %} El `softwareOverride/` El directorio proporciona un mecanismo poderoso para personalizar Pentaho Server sin modificar la instalación principal. Los archivos se copian en la instalación de Pentaho durante el arranque del contenedor, procesados en orden alfabético por nombre de directorio. {% endhint %} ```` ``` softwareOverride/ ├── 1_drivers/ # Controladores JDBC y conectores de datos │ ├── tomcat/lib/ │ │ └── postgresql-42.x.x.jar # Controlador JDBC de PostgreSQL (incluido) │ └── pentaho-solutions/drivers/ # Controladores de big data (.kar files) ├── 2_repository/ # Configuración del repositorio de la base de datos │ ├── pentaho-solutions/system/ │ │ ├── hibernate/hibernate-settings.xml │ │ ├── jackrabbit/repository.xml │ │ └── scheduler-plugin/quartz/quartz.properties │ └── tomcat/webapps/pentaho/META-INF/context.xml ├── 3_security/ # Autenticación y autorización │ └── pentaho-solutions/system/ │ ├── applicationContext-spring-security-hibernate.properties │ └── applicationContext-spring-security-memory.xml ├── 4_others/ # Tomcat, valores predeterminados y miscelánea │ ├── pentaho-solutions/system/ │ │ ├── defaultUser.spring.properties │ │ ├── pentaho.xml │ │ └── security.properties │ └── tomcat/ │ ├── bin/startup.sh │ └── webapps/pentaho/WEB-INF/web.xml └── 99_exchange/ # Intercambio de datos del usuario (no procesado automáticamente) ``` ```` El controlador JDBC de PostgreSQL está incluido en la distribución de Pentaho. Si necesita actualizar: 1. Descargar desde [Maven Central](https://repo1.maven.org/maven2/org/postgresql/postgresql/) 2. Colocar en `softwareOverride/1_drivers/tomcat/lib/` O Copiar desde Workshop--Installation/'Database Drivers'/ ```bash cd cd ~/Workshop--Installation/'Database Drivers' cp postgresql-42.7.8.jar ~/Pentaho-Server-PostgreSQL/softwareOverride/1_drivers/tomcat/lib ``` {% endtab %} {% tab title="4. Despliegue" %} {% hint style="info" %} #### Despliegue Esta sección recorre el proceso de despliegue usando el script automático o comandos manuales. {% endhint %} Seleccionar opción de despliegue: {% tabs %} {% tab title="Automatizado" %} {% hint style="info" %} #### Despliegue automatizado El script deploy.sh automatiza todo el proceso de despliegue con validación previa: ./deploy.sh El script realiza las siguientes acciones: * Valida la instalación de Docker y Docker Compose * Verifica que el paquete de Pentaho exista en: `docker/stagedArtifacts/` * Crea `.env` desde la plantilla si falta * Comprueba el espacio en disco (10GB mínimo) * Verifica que los puertos requeridos estén disponibles * Construye la imagen Docker de Pentaho Server * Inicia PostgreSQL y espera la comprobación de salud * Inicia Pentaho Server y monitorea el arranque * Muestra las URLs de acceso y las credenciales {% endhint %} 1\. Establecer permisos de ejecución en los scripts de despliegue. ```bash cd cd ~/Pentaho-Server-PostgreSQL chmod +x deploy.sh chmod +x scripts/*.sh ``` 2. Desplegar los contenedores. {% hint style="danger" %} Asegúrese de no tener un servicio postgresql en ejecución: ```bash systemctl stop postgresql ``` {% endhint %} ```bash cd cd ~/Pentaho-Server-PostgreSQL && ./deploy.sh ``` {% tabs %} {% tab title="Fase de pre-vuelo y construcción" %} {% hint style="info" %} **Comprobaciones previas ✓** El script valida el entorno antes de iniciar: * Docker está instalado * Docker Compose está instalado * El demonio de Docker está en ejecución * Paquete de Pentaho encontrado * `.env` el archivo existe * Espacio en disco suficiente (414GB disponibles) * Puerto 8090 (Pentaho HTTP) está disponible * Puerto 5432 (PostgreSQL) está disponible **Fase de construcción** Se construye una imagen Docker personalizada con **24 pasos de construcción** tomando aproximadamente **5-10 minutos**: * Imagen base: `debian:trixie-slim` * Instala paquetes del sistema vía `apt-get update` y `apt-get upgrade` * Instala **OpenJDK 21 JRE headless** con `curl` y `rm` * Crea un `pentaho` usuario y grupo (GID 5000) * (Opcional) Instala plugins de Pentaho (PAZ, PIR, PDD) * Copia la instalación de Pentaho a `/opt/pentaho/` * Exporta capas y manifiestos * **Imagen final**: `pentaho/pentaho-server:11.0.0.0-237` {% endhint %}

Comprobaciones previas y construcción

{% endtab %} {% tab title="Despliegue y estado final" %} {% hint style="info" %} **Iniciando la base de datos PostgreSQL** Extrae **PostgreSQL 15** imagen y capas relacionadas: * Crea la red: `pentaho-server-postgresql_pentaho-net` * Crea el volumen: `pentaho-server-postgresql_pentaho_postgres_data` * Crea el contenedor: `pentaho-postgres` * Espera la disponibilidad de PostgreSQL: **✓ PostgreSQL está listo** **Iniciando Pentaho Server** Esta fase toma **2-3 minutos para la inicialización por primera vez**: **Extrae la imagen de HashiCorp Vault 1.15** para la gestión de secretos **Crea volúmenes:** * `pentaho-server-postgresql_pentaho_solutions` * `pentaho-server-postgresql_pentaho_data` * `pentaho-server-postgresql_vault_data` {% endhint %}

Desplegar contenedores

{% hint style="info" %} **Estado final** 🎉 El despliegue fue exitoso y le proporciona: **Acceso a Pentaho Server:** * URL: `http://localhost:8090/pentaho` * Inicio de sesión: `admin` / `contraseña` **Base de datos PostgreSQL:** * Host: `localhost:5432` * Inicio de sesión: `postgres` / `contraseña` {% endhint %} | Acción | Comando | | ------------------- | ------------------------ | | Ver logs | `docker compose logs -f` | | Detener servicios | `docker compose stop` | | Iniciar servicios | `docker compose start` | | Reiniciar servicios | `docker compose restart` | | Apagar | `docker compose down` | {% hint style="info" %} **Scripts auxiliares proporcionados:** * `./scripts/backup-postgres.sh` -- Respaldar la base de datos * `./scripts/restore-postgres.sh ` -- Restaurar la base de datos * `./scripts/validate-deployment.sh` -- Validar el despliegue {% endhint %}

Ayudante

{% endtab %} {% endtabs %} {% endtab %} {% tab title="Construcción manual" %} {% hint style="info" %} #### Construcción manual {% endhint %} 1. Construir la imagen de Pentaho Server. ```bash docker compose build --no-cache pentaho-server ``` {% hint style="info" %} Este proceso toma aproximadamente 5-10 minutos mientras extrae el paquete de Pentaho y configura la imagen. {% endhint %} 2. Iniciar la base de datos PostgreSQL ```bash docker compose up -d postgres # Esperar a que PostgreSQL esté saludable docker compose logs -f postgres ``` {% hint style="info" %} Observe el mensaje que indica que PostgreSQL está listo para aceptar conexiones. {% endhint %} 3. Iniciar el Pentaho Server. ```bash docker compose up -d pentaho-server # Monitorear el progreso del arranque docker compose logs -f pentaho-server ``` {% hint style="info" %} El Pentaho Server normalmente tarda 2-3 minutos en la inicialización por primera vez. Observe el mensaje: ``` Inicio del servidor en [X] milisegundos ``` {% endhint %} {% endtab %} {% endtabs %} 3. Verificar el estado del contenedor. ```bash docker compose ps ``` ```bash cd cd ~/Pentaho-Server-PostgreSQL make status ``` 4. Ejecutar el script de validación. ```bash cd cd ~/Pentaho-Server-PostgreSQL/scripts && ./validate-deployment.sh ```

Validar despliegue

5. Abra un navegador web y navegue a: {% embed url="" %} 5. Inicie sesión con las credenciales predeterminadas: | Nombre de usuario | Admin | | ----------------- | ---------- | | Contraseña | contraseña | 6. Ingrese la URL del servidor de licencias

Ingrese los detalles de la licencia

{% endtab %} {% tab title="5. Respaldo y recuperación" %} {% hint style="info" %} #### Respaldo y recuperación Implemente respaldos regulares para proteger sus datos y configuración de Pentaho. {% endhint %} 1. Crear una copia de seguridad comprimida de las bases de datos de Pentaho. ```bash ./scripts/backup-postgres.sh # Las copias de seguridad se guardan en el directorio backups/ con marca de tiempo # Ejemplo: backups/pentaho-postgres-backup-20260113-143022.sql.gz ```

Script de respaldo

{% 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: ``` GET https://academy.pentaho.com/pentaho-11-installation-en/pentaho-11-installation-es/instalacion/contenedores/docker.md?ask= ``` 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.