> 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/containers/docker.md). # Docker {% hint style="info" %} #### Contenedor Docker La implementación de contenedores Docker te permite empaquetar y ejecutar productos Pentaho dentro de contenedores portátiles y listos para producción. La contenerización garantiza un comportamiento consistente entre los entornos de desarrollo, pruebas y producción, al tiempo que simplifica las operaciones de despliegue y escalado. Puedes crear contenedores Docker para Pentaho Server, que incluye la plataforma completa de Business Analytics e Integración de Datos con la Consola de Usuario de Pentaho, servicios de programación y gestión de repositorios. El servidor admite bases de datos empresariales, incluidas PostgreSQL, MySQL, Oracle y SQL Server. Para el procesamiento ETL distribuido, puedes 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 canalizaciones CI/CD y flujos de trabajo por lotes automatizados. Los despliegues en contenedores son especialmente eficaces para entornos en la nube, donde puedes escalar rápidamente los recursos para adaptarlos a las demandas de procesamiento de datos. Al ejecutar cargas de trabajo de Pentaho en contenedores, las organizaciones pueden optimizar los costos de infraestructura y, al mismo tiempo, mantener la flexibilidad para moverse entre plataformas locales y en la nube. {% endhint %}

Arquitectura de contenedores Docker que muestra los contenedores de Pentaho Server y PostgreSQL

{% tabs %} {% tab title="Contenedor de Pentaho Server" %} {% hint style="info" %} Este contenedor ejecuta la plataforma completa de Pentaho Business Analytics e Integración de Datos sobre Apache Tomcat 10. Incluye la Pentaho User Console (PUC), los servicios de programación y todas las capacidades de análisis. {% endhint %} {% endtab %} {% tab title="Contenedor PostgreSQL" %} {% hint style="info" %} Este contenedor proporciona el backend de base de datos relacional utilizando 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 conservan mediante un volumen Docker para sobrevivir a los reinicios del contenedor. {% endhint %}

Arquitectura de la 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_userJava Content Repository (JCR) - Almacena todo el contenido de Pentaho, incluidos informes, paneles, fuentes 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 - Gestiona todos los trabajos programados, desencadenadores y calendarios. Contiene tablas para definiciones de trabajos (QRTZ6_JOB_DETAILS), desencadenadores (QRTZ6_TRIGGERS), historial de ejecución y bloqueos de coordinación de clúster.
hibernatehibuserHibernate Repository - 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 ETL) y pentaho_operations_mart (marter de datos analíticos).
{% hint style="info" %} La base de datos hibernate contiene esquemas especializados para el monitoreo operativo: **pentaho\_dilogs**: Captura información detallada de ejecución ETL, incluidos registros de trabajos, registros de transformaciones, métricas de rendimiento de pasos y registros de errores. Esencial para depurar flujos de trabajo de integración de datos y supervisar el estado de la canalización. **pentaho\_operations\_mart**: Un mart de datos dimensional para analítica sobre el uso de Pentaho. Contiene tablas de dimensiones (DIM\_DATE, DIM\_TIME, DIM\_EXECUTOR) y tablas de hechos (FACT\_EXECUTION, FACT\_STEP\_EXECUTION) para analizar la utilización de la plataforma, las tendencias de rendimiento y la actividad de los usuarios. Para los despliegues en producción, implementa copias de seguridad periódicas del volumen Docker repository-data. La base de datos jackrabbit es la más crítica, ya que contiene todo el contenido del usuario. Considera usar pg\_dump para copias de seguridad lógicas o instantáneas del volumen para opciones de recuperación completas. {% endhint %} {% endtab %} {% tab title="Red" %} {% hint style="info" %} Puntos clave: * El contenedor de Pentaho se conecta a PostgreSQL usando el nombre del servicio 'repository' como nombre de host * PostgreSQL escucha internamente en el puerto 5432 (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 grupos de conexiones definidos en context.xml. Cada grupo cumple un propósito específico:
Nombre del grupoDestino 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 de ejecución 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 de Pentaho 3\. Tomcat recibe la solicitud y la enruta a la aplicación web pentaho.war 4\. La aplicación recupera/almacena datos mediante grupos de conexiones JDBC 5\. Las conexiones JDBC se enrutan a 'repository:5432' (contenedor PostgreSQL) 6\. La respuesta fluye de vuelta 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 utiliza tanto volúmenes Docker con nombre como montajes vinculados para la persistencia y la 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 Montajes vinculados: ./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 de Docker, asegúrate de haber completado la configuración: [Contenedores Pentaho](/pentaho-11-installation-en/pentaho-11-installation-es/configuracion/pentaho-containers.md) {% endhint %} Sigue 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 Comprueba que Docker está en ejecución: * Copiar activos 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úrate de haber descargado: `pentaho-server-ee-11.0.0.0-237.zip` {% endhint %} 1. Crea el directorio del proyecto y copia los activos. ```bash cd cp -r ~/Workshop--Installation/Pentaho-Containers/On-Prem/Pentaho-Server-PostgreSQL . ``` 2. Copia el directorio /docker/stagedArtefacts con pentaho-server-ee-11.0.0.0-237.zip. {% hint style="info" %} Si has desplegado un Pentaho Server archivado, entonces copia desde: `/opt/pentaho/software/pentaho-server-ee-version` De lo contrario, descarga el paquete desde el [Portal del cliente 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. Verifica que el archivo. ```bash cd cd ~/Pentaho-Server-PostgreSQL/docker/stagedArtifacts ls -al ``` 4. Comprueba la versión de Docker. ```bash docker --version # Salida esperada: versión de Docker 29.0.2 o superior ``` 5. Comprueba la versión de Docker Compose. ```bash docker compose --version # Salida esperada: versión de Docker Compose 2.40.3 o superior ``` ```bash sudo apt install docker-compose # instala Docker Compose ``` 6. Verifica que el demonio de Docker esté en ejecución. ```bash docker info # Debería mostrar información de todo el sistema sin errores ``` 7. Comprueba 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, puedes cambiar la variable PORT en el archivo .env por cualquier puerto disponible (por ejemplo, 8090, 8081, 9090). {% endhint %} 8. Pentaho Server requiere una licencia válida. El `.env` archivo contiene una LICENSE\_URL que apunta al servidor de licencias de Flexera. Asegúrate de que tus 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. Verifica el estado de tu licencia antes de continuar con los despliegues de producción. {% endhint %} {% endtab %} {% tab title="2. Estructura del directorio" %} {% hint style="info" %} #### Estructura del directorio Esta configuración de despliegue ofrece varias capacidades importantes: * Despliegue completamente autónomo y portátil. * Inicialización automatizada de la base de datos con scripts SQL. * Comprobaciones de estado y orden de inicio adecuado 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 mayor seguridad. * Límites de recursos (CPU/memoria) para estabilidad. * Rotación de registros para evitar el agotamiento del disco. * Sistema de sustitución de software para personalizar configuraciones sin modificar archivos principales. * Plantillas de configuración listas para producción. * Controlador JDBC de PostgreSQL incluido * Procedimientos fáciles de copia de seguridad y restauración {% endhint %} {% hint style="success" %} Consulta las otras opciones de despliegue del 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 automatizado de despliegue ├── .env # Configuración del entorno (creado) ├── .env.template # Plantilla de entorno con valores predeterminados ``` {% hint style="info" %} **Archivos de documentación:** **README.md** - La documentación principal de entrada que proporciona una visión general del proyecto, instrucciones de inicio rápido, requisitos previos e información general de uso para el taller. **ARCHITECTURE.md** - Documentación técnica detallada que abarca la arquitectura del sistema, las relaciones entre componentes, el diseño de contenedores, la red, el flujo de datos y las 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 incidencias comunes, mensajes de error, procedimientos de diagnóstico y soluciones para problemas de despliegue y tiempo de ejecución que podrías 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 y otros servicios), sus configuraciones, red, 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 automatizado de despliegue que probablemente gestiona 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 del entorno:** **.env** - El archivo de configuración del entorno activo (creado a partir de la plantilla) que contiene valores reales para contraseñas de bases de datos, puertos, nombres de host y otros ajustes específicos del entorno. Este archivo normalmente se ignora en Git. **.env.template** - El archivo de plantilla con valores predeterminados 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 # Compilación de imagen de 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" %} La **docker/** el directorio contiene todos los componentes principales necesarios para construir y ejecutar el despliegue en contenedores 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 de Pentaho Server. Las compilaciones en varias etapas ayudan a optimizar el tamaño final de la imagen al separar el entorno de compilación del entorno de ejecución. **entrypoint/** el directorio contiene el **docker-entrypoint.sh** script, que es el script de inicialización que se ejecuta cuando el contenedor se inicia. Normalmente se encarga de tareas como la configuración del entorno, la gestión de la configuración, las comprobaciones de estado y el inicio de los servicios de Pentaho Server. **stagedArtifacts/** el 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 versión Enterprise Edition 11.0.0.0 compilación 237 que se extrae e instala durante el proceso de compilació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" %} La **db\_init\_postgres/** el 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 principal de gestión de contenido para Pentaho. **2\_create\_quartz\_postgresql.sql** - Configura el **Programador Quartz** esquema, que gestiona todos los trabajos y tareas programados dentro de Pentaho Server, incluida la generación de informes, las ejecuciones ETL y otros procesos automatizados. **3\_create\_repository\_postgresql.sql** - Crea el **Repositorio Hibernate** esquema, que almacena la autenticación de usuarios, los 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 e Integración de Datos (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 **Mart de operaciones** esquema, que almacena datos analíticos operativos sobre el uso de Pentaho Server, métricas de rendimiento e información de supervisión del sistema utilizada por el panel de Pentaho Operations Mart. {% endhint %} *** **Configuración de PostgreSQL y Vault** ``` ├── postgres-config/ │ ├── custom.conf # Ajuste del 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 secretos de Docker ``` {% hint style="info" %} **postgres-config/** - Configuración de PostgreSQL **custom.conf** - Parámetros personalizados de ajuste del rendimiento de PostgreSQL optimizados para las cargas de trabajo de Pentaho Server. Esto probablemente incluye configuraciones para buffers compartidos, memoria de trabajo, límites de conexión, configuraciones de puntos de control 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 conexión de clientes, las reglas de acceso por dirección IP y las políticas de seguridad para las conexiones a la base de datos desde el contenedor de Pentaho Server. *** **vault/** - Integración de HashiCorp Vault Este directorio admite 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, los ajustes del oyente, los extremos de la API, el comportamiento de sellado/desellado y los 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 puede leer, escribir o gestionar la aplicación Pentaho. Esto aplica el principio de mínimo privilegio para las credenciales sensibles. *** **secrets/** - Gestión de secretos de Docker **postgres\_password.txt** - Un archivo de secretos de Docker que contiene la contraseña de PostgreSQL. Cuando se usan secretos de Docker (o integración con Vault), este archivo proporciona las credenciales de la base de datos de forma segura en lugar de pasarlas como variables de entorno en texto plano. El archivo debe tener permisos restringidos y normalmente se referencia mediante Docker Compose usando `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/ # Ajustes de autenticación │ │ └── pentaho-solutions/system/ │ └── 4_others/ # Ajustes de Tomcat y de la aplicación │ ├── pentaho-solutions/system/ │ └── tomcat/ ``` {% hint style="info" %} La **softwareOverride/** el directorio contiene archivos de configuración y componentes personalizados que anulan la instalación predeterminada de Pentaho Server. La estructura numerada garantiza una organización lógica y potencialmente una aplicación ordenada durante el proceso de compilación de Docker: *** **1\_drivers/** - Controladores de base de datos JDBC **tomcat/lib/** - Contiene archivos JAR de controladores JDBC (específicamente el controlador JDBC de PostgreSQL) que se copian al directorio de bibliotecas de Tomcat, permitiendo que Pentaho Server se conecte a bases de datos PostgreSQL. *** **2\_repository/** - Configuración del repositorio de bases 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 Jackrabbit JCR (repository.xml) para 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 de fuentes de datos JNDI para todas las bases de datos de Pentaho (Quartz, Jackrabbit, Hibernate, Audit, Operations Mart) *** **3\_security/** - Ajustes 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, ajustes de log4j y configuraciones del comportamiento de la aplicación **tomcat/** - Personalizaciones del servidor Tomcat, incluidas server.xml, web.xml, setenv.sh para parámetros de JVM y otros ajustes específicos de Tomcat {% endhint %} **Scripts de utilidad** ``` ├── 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" %} La **scripts/** el directorio contiene utilidades operativas y de mantenimiento para gestionar el despliegue de Pentaho Server, organizadas por área funcional: *** **Gestión de bases de datos:** **backup-postgres.sh** - Utilidad automatizada de copias de seguridad de PostgreSQL que crea volcados de todas las bases de datos de Pentaho (JCR, Quartz, Hibernate, Audit, Operations Mart). Probablemente incluye lógica de marcas de tiempo, compresión y retención de copias de seguridad. **restore-postgres.sh** - Utilidad de restauración de bases 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. *** **Gestión de Vault/secretos:** **backup-vault.sh** - Script de copia de seguridad de las credenciales de HashiCorp Vault y de las claves de unseal, que garantiza la capacidad de recuperación de la instancia de Vault que contiene credenciales sensibles de Pentaho. **restore-vault.sh** - Utilidad de restauración de Vault para recuperar los datos de Vault y reinicializar el sistema de gestión de secretos desde 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, apoyando 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 se encarga de la inicialización de Vault, el desbloqueo, la creación de la política de Pentaho y el almacenamiento de los secretos iniciales para la implementación. *** **Operaciones y validación:** **validate-deployment.sh** - Script de validación del despliegue que realiza comprobaciones de estado en todos los componentes (conectividad de PostgreSQL, arranque 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 de PDI/Kettle │ │ └── kettle.properties │ └── .pentaho/ # Configuración de usuario de Pentaho ├── backups/ # Almacenamiento de copias de seguridad de la base de datos │ └── *.sql.gz # Copias de seguridad SQL comprimidas └── logs/ # Registros 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 configuraciones globales utilizadas por las ejecuciones de transformaciones y trabajos que se ejecutan en Pentaho Server. **`.pentaho/`** - Directorio de configuración de usuario de Pentaho para almacenar preferencias específicas del usuario, metadatos en caché e información de estado de la aplicación. *** **backups/** - Almacenamiento de copias de seguridad de la base de datos **`*.sql.gz`** - Repositorio de archivos comprimidos de copias de seguridad 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 copia de seguridad lleven marcas de tiempo para el control de versiones. *** **logs/** - Registro de la aplicación Directorio centralizado de registro para capturar los 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 * Registros de los contenedores Docker * Registros de ejecución de ETL Esto admite la **configuración de rotación de registros** y las capacidades de monitorización que has ido incorporando a tu despliegue, haciendo que la resolución de problemas y la auditoría sean más fáciles durante los talleres. {% endhint %} *** **Archivos clave**
ArchivoPropósito
docker-compose.ymlDefine todos los servicios (pentaho-server, postgres), redes y volúmenes
docker/DockerfileCompilación multietapa usando debian:trixie-slim con OpenJDK 21
docker-entrypoint.shProcesa los directorios softwareOverride al iniciar el 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 los secretos
rotate-secrets.shRota las contraseñas de la base de datos de forma segura
{% endtab %} {% tab title="3. Tareas previas al despliegue" %} {% hint style="info" %} #### Tareas previas al despliegue La sección Tareas previas al despliegue describe los pasos esenciales de preparación necesarios antes de desplegar Pentaho Server 11 en contenedores Docker. Primero, debes configurar las variables de entorno editando el `.env.template` archivo con la configuración específica de tu despliegue. Esto incluye definir la versión de Pentaho y los detalles de la imagen, las credenciales de PostgreSQL y la configuración del puerto (por defecto 5432), los puertos HTTP y HTTPS de Pentaho (8090 y 8443), la asignación de memoria JVM (mínimo 4 GB, máximo 8 GB), la URL del servidor de licencias y la configuración del puerto de Vault. Una vez configurado, esta plantilla se guarda como el `.env` archivo activo. La optimización del rendimiento de PostgreSQL se gestiona a través del `postgres-config/custom.conf` archivo, donde puedes personalizar los límites de conexión (por defecto 200 conexiones máximas), los parámetros de asignación de memoria, incluidos los buffers compartidos y los tamaños de caché, y otras optimizaciones de rendimiento específicamente ajustadas para entornos contenerizados. Finalmente, el `softwareOverride/` directorio ofrece un mecanismo opcional para personalizar las configuraciones de Pentaho sin modificar los archivos de instalación principales. El controlador JDBC de PostgreSQL viene incluido de forma predeterminada, pero puedes actualizarlo opcionalmente descargándolo desde Maven Central o copiándolo desde la colección de controladores de base de datos del taller. Esta preparación garantiza que todos los archivos, configuraciones y credenciales necesarios estén correctamente preparados antes de ejecutar el script de despliegue automatizado. {% endhint %} *** **Configurar .env** 1. Editar el archivo .env.template ```bash cd cd ~/Pentaho-Server-PostgreSQL nano .env.template ``` 2. Introduce los siguientes detalles:
VariablePredeterminadoDescripció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_PASSWORDpasswordContraseña raíz 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 archivo .env.template ```bash cd cd ~/Pentaho-Server-PostgreSQL/progres-config nano custom.conf ``` 2. Introduce 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" %} La `softwareOverride/` directorio proporciona un poderoso mecanismo para personalizar Pentaho Server sin modificar la instalación principal. Los archivos se copian en la instalación de Pentaho durante el inicio del contenedor y se procesan 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 (archivos .kar) ├── 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 varios │ ├── 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 de usuario (no se procesa automáticamente) ``` ```` El controlador JDBC de PostgreSQL está incluido en la distribución de Pentaho. Si necesitas actualizarlo: 1. Descárgalo desde [Maven Central](https://repo1.maven.org/maven2/org/postgresql/postgresql/) 2. Colócalo en `softwareOverride/1_drivers/tomcat/lib/` O Copia 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 automatizado o comandos manuales. {% endhint %} Selecciona la 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` a partir de la plantilla si falta * Comprueba el espacio en disco (mínimo 10 GB) * Verifica que los puertos requeridos estén disponibles * Construye la imagen Docker de Pentaho Server * Inicia PostgreSQL y espera la comprobación de estado * Inicia Pentaho Server y supervisa el arranque * Muestra las URL de acceso y las credenciales {% endhint %} 1\. Establece permisos de ejecución en los scripts de despliegue. ```bash cd cd ~/Pentaho-Server-PostgreSQL chmod +x deploy.sh chmod +x scripts/*.sh ``` 2. Despliega los contenedores. {% hint style="danger" %} Asegúrate de no tener un servicio de postgresql en ejecución: ```bash systemctl stop postgresql ``` {% endhint %} ```bash cd cd ~/Pentaho-Server-PostgreSQL && ./deploy.sh ``` {% tabs %} {% tab title="Fase de comprobación previa y compilación" %} {% hint style="info" %} **Comprobaciones previas ✓** El script valida el entorno antes de comenzar: * 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 (414 GB disponibles) * El puerto 8090 (HTTP de Pentaho) está disponible * El puerto 5432 (PostgreSQL) está disponible **Fase de compilación** Se construye una imagen Docker personalizada con **24 pasos de compilación** que tarda aproximadamente **5-10 minutos**: * Imagen base: `debian:trixie-slim` * Instala paquetes del sistema mediante `apt-get update` y `apt-get upgrade` * Instala **OpenJDK 21 JRE sin interfaz gráfica** con `curl` y `rm` * Crea un `pentaho` usuario y grupo (GID 5000) * (Opcional) Instala complementos 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 compilación

{% endtab %} {% tab title="Despliegue y estado final" %} {% hint style="info" %} **Iniciando la base de datos PostgreSQL** Descarga **PostgreSQL 15** la imagen y las 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 a que PostgreSQL esté listo: **✓ PostgreSQL está listo** **Iniciando Pentaho Server** Esta fase tarda **2-3 minutos para la inicialización por primera vez**: **Descarga la imagen de HashiCorp Vault 1.15** para la gestión de secretos **Crea los 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 se ha realizado correctamente y te proporciona: **Acceso a Pentaho Server:** * URL: `http://localhost:8090/pentaho` * Inicio de sesión: `admin` / `password` **Base de datos PostgreSQL:** * Host: `localhost:5432` * Inicio de sesión: `postgres` / `password` {% endhint %} | Acción | Comando | | ------------------- | ------------------------ | | Ver registros | `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` -- Copia de seguridad de la base de datos * `./scripts/restore-postgres.sh ` -- Restaurar la base de datos * `./scripts/validate-deployment.sh` -- Validar despliegue {% endhint %}

Auxiliar

{% endtab %} {% endtabs %} {% endtab %} {% tab title="Compilación manual" %} {% hint style="info" %} #### Compilación manual {% endhint %} 1. Compila la imagen de Pentaho Server. ```bash docker compose build --no-cache pentaho-server ``` {% hint style="info" %} Este proceso tarda aproximadamente entre 5 y 10 minutos, ya que extrae el paquete de Pentaho y configura la imagen. {% endhint %} 2. Iniciar la base de datos PostgreSQL ```bash docker compose up -d postgres # Espera a que PostgreSQL esté saludable docker compose logs -f postgres ``` {% hint style="info" %} Busca el mensaje que indique que PostgreSQL está listo para aceptar conexiones. {% endhint %} 3. Inicia Pentaho Server. ```bash docker compose up -d pentaho-server # Supervisa el progreso del arranque docker compose logs -f pentaho-server ``` {% hint style="info" %} Pentaho Server suele tardar 2-3 minutos en la inicialización por primera vez. Busca el mensaje: ``` Inicio del servidor en [X] milisegundos ``` {% endhint %} {% endtab %} {% endtabs %} 3. Verifica el estado del contenedor. ```bash docker compose ps ``` ```bash cd cd ~/Pentaho-Server-PostgreSQL make status ``` 4. Ejecuta el script de validación. ```bash cd cd ~/Pentaho-Server-PostgreSQL/scripts && ./validate-deployment.sh ```

Validar despliegue

5. Abre un navegador web y navega a: {% embed url="" %} 5. Inicia sesión con las credenciales predeterminadas: | Nombre de usuario | Administrador | | ----------------- | ------------- | | Contraseña | password | 6. Ingrese la URL del servidor de licencias

Ingrese los detalles de la licencia

{% endtab %} {% tab title="5. Copia de seguridad y recuperación" %} {% hint style="info" %} #### Copia de seguridad y recuperación Implemente copias de seguridad periódicas para proteger sus datos y configuración de Pentaho. {% endhint %} 1. Cree 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 copia de seguridad

{% 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/instalacion/containers/docker.md?ask=&goal= ``` `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.