> 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-pt-br/instalacao/conteineres/docker.md). # Docker {% hint style="info" %} #### Container Docker O deployment de contêiner Docker permite empacotar e executar produtos Pentaho dentro de contêineres portáteis e prontos para produção. A conteinerização garante comportamento consistente entre ambientes de desenvolvimento, teste e produção, ao mesmo tempo que simplifica as operações de implantação e escalonamento. Você pode criar contêineres Docker para o Pentaho Server, que inclui a plataforma completa de Business Analytics e Data Integration com o Pentaho User Console, serviços de agendamento e gerenciamento de repositório. O servidor suporta backends de banco de dados empresariais, incluindo PostgreSQL, MySQL, Oracle e SQL Server. Para processamento ETL distribuído, você pode implantar contêineres do servidor Carte que executam transformações e jobs remotamente. As ferramentas de linha de comando Kitchen e Pan também estão disponíveis como contêineres, permitindo integração com pipelines CI/CD e fluxos de trabalho em lote automatizados. Implantações em contêineres são particularmente eficazes para ambientes em nuvem, onde você pode dimensionar rapidamente os recursos para atender às demandas de processamento de dados. Ao executar cargas de trabalho Pentaho em contêineres, as organizações podem otimizar os custos de infraestrutura mantendo a flexibilidade de migrar entre plataformas locais e na nuvem. {% endhint %}

Arquitetura de Contêiner Docker mostrando contêineres Pentaho Server e PostgreSQL

{% tabs %} {% tab title="Contêiner do Pentaho Server" %} {% hint style="info" %} Este contêiner executa a plataforma completa Pentaho Business Analytics e Data Integration no Apache Tomcat 10. Inclui o Pentaho User Console (PUC), serviços de agendamento e todas as capacidades analíticas. {% endhint %} {% endtab %} {% tab title="Contêiner PostgreSQL" %} {% hint style="info" %} Este contêiner fornece o backend de banco de dados relacional usando PostgreSQL 17. Ele hospeda três bancos de dados críticos exigidos pelo Pentaho: Jackrabbit (repositório de conteúdo), Quartz (agendador) e Hibernate (segurança e auditoria). Os dados são persistidos por meio de um volume Docker para sobreviver às reinicializações do contêiner. {% endhint %}

Arquitetura do Banco de Dados PostgreSQL

O Pentaho Server requer três bancos de dados separados, cada um servindo a um propósito distinto:
Banco de DadosProprietárioPropósito e Conteúdo
jackrabbitjcr_userJava Content Repository (JCR) - Armazena todo o conteúdo do Pentaho, incluindo relatórios, painéis, fontes de dados, esquemas de análise e arquivos de usuário. Este é o armazenamento principal de conteúdo do repositório Pentaho.
quartzpentaho_userQuartz Scheduler - Gerencia todos os jobs agendados, triggers e calendários. Contém tabelas para definições de jobs (QRTZ6_JOB_DETAILS), triggers (QRTZ6_TRIGGERS), histórico de execução e locks de coordenação de cluster.
hibernatehibuserRepositório Hibernate - Hospeda configuração de segurança, registro de auditoria, dados de sessão de usuário e contém dois esquemas adicionais: pentaho_dilogs (registro de execução ETL) e pentaho_operations_mart (data mart analítico).
{% hint style="info" %} O banco de dados hibernate contém esquemas especializados para monitoramento operacional: **pentaho\_dilogs**: Captura informações detalhadas da execução ETL, incluindo logs de jobs, logs de transformações, métricas de desempenho de etapas e registros de erro. Essencial para depurar fluxos de integração de dados e monitorar a saúde dos pipelines. **pentaho\_operations\_mart**: Um data mart dimensional para análise do uso do Pentaho. Contém tabelas de dimensão (DIM\_DATE, DIM\_TIME, DIM\_EXECUTOR) e tabelas fato (FACT\_EXECUTION, FACT\_STEP\_EXECUTION) para analisar utilização da plataforma, tendências de desempenho e atividade dos usuários. Para implantações de produção, implemente backups regulares do volume Docker repository-data. O banco de dados jackrabbit é o mais crítico, pois contém todo o conteúdo dos usuários. Considere usar pg\_dump para backups lógicos ou snapshots de volume para opções de recuperação completa. {% endhint %} {% endtab %} {% tab title="Rede" %} {% hint style="info" %} Pontos principais: * O contêiner Pentaho se conecta ao PostgreSQL usando o nome de serviço 'repository' como hostname * O PostgreSQL escuta na porta 5432 internamente (não exposta ao host por padrão) * O Pentaho Server expõe a porta 8080, mapeada para o sistema host * Todo o tráfego entre contêineres permanece dentro da rede Docker por segurança {% endhint %}

Fluxo de dados mostrando requisições HTTP e conexões JDBC

O Tomcat gerencia pools de conexão definidos em context.xml. Cada pool serve a um propósito específico:
Nome do PoolDestino da ConexãoUsado Para
jdbc/Hibernaterepository:5432/hibernateSegurança, Usuários, Funções
jdbc/Quartzrepository:5432/quartzAgendamento de Jobs
jdbc/jackrabbitrepository:5432/jackrabbitRepositório de Conteúdo
jdbc/Auditrepository:5432/hibernateRegistro de Auditoria
jdbc/live_logging_inforepository:5432/hibernateLogs de Execução ETL
jdbc/PDI_Operations_Martrepository:5432/hibernateAnalytics de Operações
{% hint style="info" %} Quando um usuário acessa o Pentaho Server: 1\. O navegador do usuário envia uma requisição HTTP para localhost:8080 2\. O Docker encaminha a requisição para a porta 8080 do contêiner Pentaho 3\. O Tomcat recebe a requisição e a roteia para a aplicação web pentaho.war 4\. A aplicação recupera/armazen a dados via pools de conexão JDBC 5\. As conexões JDBC roteiam para 'repository:5432' (contêiner PostgreSQL) 6\. A resposta retorna pelo mesmo caminho ao navegador do usuário {% endhint %} {% endtab %} {% tab title="Mapeamento de Volume" %} {% hint style="info" %} #### Mapeamento de Volume A implantação usa tanto volumes Docker nomeados quanto bind mounts para persistência e configuração: {% endhint %} ``` Volumes 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 iniciar o deployment Docker, certifique-se de ter concluído a Configuração: [Contêineres Pentaho](/pentaho-11-installation-en/pentaho-11-installation-pt-br/configuracao/conteineres-do-pentaho.md) {% endhint %} Execute os seguintes passos para implantar o Pentaho Server com repositório PostgreSQL 15. {% tabs %} {% tab title="1. Preparar o Ambiente" %} {% hint style="info" %} #### Preparar o Ambiente Verifique se o Docker está ativo e em execução: * Copiar ativos do Pentaho-Server-PostgreSQL * Copiar para `pentaho-server-ee-11.0.0.0-237.zip` * Verificar Docker & Docker Compose * Verificar portas {% endhint %} {% hint style="danger" %} Certifique-se de ter baixado: `pentaho-server-ee-11.0.0.0-237.zip` {% endhint %} 1. Crie o diretório do projeto e copie os assets. ```bash cd cp -r ~/Workshop--Installation/Pentaho-Containers/On-Prem/Pentaho-Server-PostgreSQL . ``` 2. Copie o pentaho-server-ee-11.0.0.0-237.zip para o diretório /docker/stagedArtefacts. {% hint style="info" %} Se você implantou um Pentaho Server de um arquivo de arquivo (Archive), então copie de: `/opt/pentaho/software/pentaho-server-ee-version` Caso contrário, baixe o pacote do [Portal de Clientes 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 o arquivo. ```bash cd cd ~/Pentaho-Server-PostgreSQL/docker/stagedArtifacts ls -al ``` 4. Verifique a versão do Docker. ```bash docker --version # Saída esperada: Docker versão 29.0.2 ou superior ``` 5. Verifique a versão do Docker Compose. ```bash docker compose --version # Saída esperada: Docker Compose versão 2.40.3 ou superior ``` ```bash sudo apt install docker-compose # instala o Docker Compose ``` 6. Verifique se o daemon do Docker está em execução. ```bash docker info # Deve exibir informações do sistema sem erros ``` 7. Verifique se a porta 8080 / 8090 está disponível no SO host. ```bash sudo lsof -i ::8080 ``` {% hint style="info" %} Se a porta 8080 estiver em uso por outra aplicação, você pode alterar a variável PORT no arquivo .env para qualquer porta disponível (ex.: 8090, 8081, 9090). {% endhint %} 8. O Pentaho Server requer uma licença válida. O `.env` arquivo contém um LICENSE\_URL apontando para o servidor de licenças Flexera. Garanta que seus direitos de licença estejam ativos antes da implantação. {% hint style="warning" %} Sem uma licença válida, o Pentaho Server iniciará, mas muitos recursos ficarão desabilitados. Verifique o status da sua licença antes de prosseguir com implantações em produção. {% endhint %} {% endtab %} {% tab title="2. Layout de Diretórios" %} {% hint style="info" %} #### Layout de Diretórios Esta configuração de implantação fornece várias capacidades importantes: * Implantação totalmente autocontida e portátil. * Inicialização automatizada do banco de dados com scripts SQL. * Verificações de integridade e ordenação adequada de inicialização entre serviços. * Volumes de dados persistentes para banco de dados e conteúdo do Pentaho. * HashiCorp Vault para gerenciamento de segredos com autenticação AppRole. * Contêineres somente leitura com montagens tmpfs para segurança. * Limites de recursos (CPU/memória) para estabilidade. * Rotação de logs para evitar exaustão de disco. * Sistema de override de software para customizar configurações sem modificar arquivos centrais. * Modelos de configuração prontos para produção. * Driver JDBC do PostgreSQL incluído * Procedimentos fáceis de backup e restauração {% endhint %} {% hint style="success" %} Confira as outras opções de implantação de repositório em: ``` ~/Workshop--Installation/Pentaho-Containers/On-Prem/ ``` {% endhint %} *** **Arquivos do Diretório Raiz** ``` Pentaho-Server-PostgreSQL/ ├── README.md # Arquivo principal de documentação ├── ARCHITECTURE.md # Detalhes da arquitetura do sistema ├── CONFIGURATION.md # Guia de referência de configuração ├── TROUBLESHOOTING.md # Guia de resolução de problemas ├── docker-compose.yml # Definições de serviços do Docker Compose ├── Makefile # Alvos de conveniência (make help) ├── deploy.sh # Script de implantação automatizada ├── .env # Configuração de ambiente (criado) ├── .env.template # Template de ambiente com valores padrão ``` {% hint style="info" %} **Arquivos de Documentação:** **README.md** - O documento de entrada principal fornecendo visão geral do projeto, instruções de início rápido, pré-requisitos e informações gerais de uso para o workshop. **ARCHITECTURE.md** - Documentação técnica detalhada cobrindo a arquitetura do sistema, relacionamentos entre componentes, design de contêineres, rede, fluxo de dados e decisões arquiteturais para a implantação baseada em Docker. **CONFIGURATION.md** - Guia de referência de configuração abrangente detalhando todas as variáveis de ambiente disponíveis, opções de configuração, parâmetros de personalização e definições para os componentes Pentaho Server e PostgreSQL. **TROUBLESHOOTING.md** - Guia de resolução de problemas com questões comuns, mensagens de erro, procedimentos de diagnóstico e soluções para problemas de implantação e tempo de execução que você possa encontrar. **Orquestração & Implantação:** **docker-compose.yml** - O arquivo de definições de serviços do Docker Compose que declara todos os contêineres (Pentaho Server, PostgreSQL, potencialmente Vault/outros serviços), suas configurações, rede, volumes e dependências. **Makefile** - Contém alvos de comando de conveniência para operações comuns como construir, iniciar, parar e limpar o ambiente. Usuários podem executar `make help` para ver os comandos disponíveis. **deploy.sh** - Script de implantação automatizado que provavelmente lida com o fluxo completo de implantação, incluindo validação do ambiente, construção de imagens, inicialização de serviços e configuração inicial. **Configuração de Ambiente:** **.env** - O arquivo de configuração de ambiente ativo (criado a partir do template) contendo valores reais para senhas de banco de dados, portas, hostnames e outras configurações específicas do ambiente. Este arquivo normalmente é ignorado pelo git. **.env.template** - O arquivo template com valores padrão e placeholders que os usuários copiam para criar seu `.env` arquivo, fornecendo uma referência para todas as variáveis de ambiente configuráveis. {% endhint %} *** **Contexto de Build Docker** ``` ├── docker/ │ ├── Dockerfile # Build de imagem do Pentaho Server em múltiplas fases │ ├── entrypoint/ │ │ └── docker-entrypoint.sh # Script de inicialização do contêiner │ └── stagedArtifacts/ │ └── pentaho-server-ee-11.0.0.0-237.zip ``` {% hint style="info" %} O **docker/** diretório contém todos os componentes principais necessários para construir e executar a implantação conteinerizada do Pentaho Server: **Dockerfile** - Esta é a configuração principal de build usando uma abordagem de build em múltiplas fases para criar a imagem do contêiner do Pentaho Server. Builds em múltiplas fases ajudam a otimizar o tamanho final da imagem ao separar o ambiente de build do ambiente de runtime. **entrypoint/** o diretório contém o **docker-entrypoint.sh** script, que é o script de inicialização que é executado quando o contêiner inicia. Isso normalmente lida com tarefas como configuração de ambiente, gerenciamento de configuração, verificações de integridade e inicialização dos serviços do Pentaho Server. **stagedArtifacts/** o diretório serve como área de staging para o pacote de instalação do Pentaho Server. Atualmente contém **pentaho-server-ee-11.0.0.0-237.zip**, que é a versão Enterprise Edition 11.0.0.0 build 237 que é extraída e instalada durante o processo de build da imagem Docker. {% endhint %} *** **Inicialização do Banco de Dados de Repositório PostgreSQL** ``` ├── db_init_postgres/ │ ├── 1_create_jcr_postgresql.sql # Repositório de conteúdo Jackrabbit │ ├── 2_create_quartz_postgresql.sql # Quartz scheduler │ ├── 3_create_repository_postgresql.sql # Repositório Hibernate │ ├── 4_pentaho_logging_postgresql.sql # Esquema de logging Audit/DI │ └── 5_pentaho_mart_postgresql.sql # Esquema do Operations mart ``` {% hint style="info" %} O **db\_init\_postgres/** o diretório contém os scripts de inicialização do banco de dados PostgreSQL que configuram todos os esquemas necessários para o Pentaho Server 11. Esses scripts são numerados para executar em uma sequência específica: **1\_create\_jcr\_postgresql.sql** - Cria o **Repositório de Conteúdo Jackrabbit (JCR)** esquema, que armazena o conteúdo do repositório Pentaho incluindo arquivos de solução, agendamentos, relatórios, painéis e metadados. Este é o sistema central de gerenciamento de conteúdo do Pentaho. **2\_create\_quartz\_postgresql.sql** - Configura o **Quartz Scheduler** esquema, que gerencia todos os jobs e tarefas agendadas dentro do Pentaho Server, incluindo geração de relatórios, execuções de ETL e outros processos automatizados. **3\_create\_repository\_postgresql.sql** - Cria o **Repositório Hibernate** esquema, que armazena autenticação de usuário, dados de autorização, papéis, permissões e outras informações relacionadas à segurança gerenciadas pelo subsistema de segurança do Pentaho. **4\_pentaho\_logging\_postgresql.sql** - Estabelece o **Log de Auditoria e Integração de Dados (DI)** esquema para capturar logs de execução, métricas de transformação/job e informações de trilha de auditoria de processos PDI executados no servidor. **5\_pentaho\_mart\_postgresql.sql** - Cria o **Operations Mart** esquema, que armazena dados de análise operacional sobre o uso do Pentaho Server, métricas de desempenho e informações de monitoramento do sistema usadas pelo painel do Pentaho Operations Mart. {% endhint %} *** **Configuração do PostgreSQL e Vault** ``` ├── postgres-config/ │ ├── custom.conf # Ajuste de desempenho do PostgreSQL │ └── pg_hba.conf # Configuração de autenticação de clientes ├── vault/ │ ├── config/ │ │ └── vault.hcl # Configuração do servidor Vault │ └── policies/ │ └── pentaho-policy.hcl # Política de acesso do Pentaho ├── secrets/ │ └── postgres_password.txt # Arquivo de secrets do Docker ``` {% hint style="info" %} **postgres-config/** - Configuração do PostgreSQL **custom.conf** - Parâmetros personalizados de ajuste de desempenho do PostgreSQL otimizados para cargas do Pentaho Server. Isso provavelmente inclui configurações para shared\_buffers, work\_memory, limites de conexão, configurações de checkpoint e outros parâmetros relacionados ao desempenho adaptados para lidar com os requisitos de banco de dados do Pentaho. **pg\_hba.conf** - Arquivo de configuração de Autenticação Baseada em Host do PostgreSQL que controla métodos de autenticação de conexão de clientes, regras de acesso por endereço IP e políticas de segurança para conexões de banco de dados a partir do contêiner do Pentaho Server. *** **vault/** - Integração com HashiCorp Vault Este diretório suporta a incorporação do Vault para gerenciamento de secrets: **config/vault.hcl** - O arquivo de configuração do servidor HashiCorp Vault definindo backend de armazenamento, configurações de listener, endpoints da API, comportamento de selagem/deselagem e parâmetros operacionais gerais do servidor Vault. **policies/pentaho-policy.hcl** - Política de controle de acesso do Vault especificamente para o Pentaho Server, definindo quais caminhos de secrets a aplicação Pentaho pode ler, gravar ou gerenciar. Isso impõe acesso com privilégios mínimos às credenciais sensíveis. *** **secrets/** - Gerenciamento de Secrets do Docker **postgres\_password.txt** - Um arquivo de secrets do Docker contendo a senha do PostgreSQL. Ao usar Docker secrets (ou integração com Vault), este arquivo fornece as credenciais do banco de dados de maneira segura em vez de passá-las como variáveis de ambiente em texto simples. O arquivo deve ter permissões restritas e normalmente é referenciado pelo Docker Compose usando o `secrets:` configuração. {% endhint %}
ChaveDescrição
postgres_passwordSenha do superusuário do PostgreSQL
pentaho_userNome de usuário do banco de dados Pentaho
pentaho_passwordSenha do banco de dados Pentaho
jdbc_urlURL de conexão JDBC
*** **Sobrescritas de Configuração do Pentaho** ``` ├── softwareOverride/ │ ├── 1_drivers/ # Drivers JDBC │ │ └── tomcat/lib/ │ ├── 2_repository/ # Configuração do banco de dados │ │ ├── pentaho-solutions/system/ │ │ │ ├── hibernate/ │ │ │ ├── jackrabbit/ │ │ │ └── scheduler-plugin/quartz/ │ │ └── tomcat/webapps/pentaho/META-INF/ │ ├── 3_security/ # Configurações de autenticação │ │ └── pentaho-solutions/system/ │ └── 4_others/ # Configurações do Tomcat e da aplicação │ ├── pentaho-solutions/system/ │ └── tomcat/ ``` {% hint style="info" %} O **softwareOverride/** diretório contém arquivos de configuração personalizados e componentes que substituem a instalação padrão do Pentaho Server. A estrutura numerada assegura uma organização lógica e potencialmente uma aplicação ordenada durante o processo de build do Docker: *** **1\_drivers/** - Drivers de Banco de Dados JDBC **tomcat/lib/** - Contém arquivos JAR dos drivers JDBC (especificamente o driver JDBC do PostgreSQL) que são copiados para o diretório de bibliotecas do Tomcat, permitindo que o Pentaho Server se conecte aos bancos de dados PostgreSQL. *** **2\_repository/** - Configuração do Repositório de Banco de Dados Esta seção configura a conexão do Pentaho com todos os repositórios com suporte PostgreSQL: **pentaho-solutions/system/hibernate/** - Arquivos de configuração do repositório Hibernate (repository.xml, hibernate-settings.xml) para dados de segurança de usuário/papel **pentaho-solutions/system/jackrabbit/** - Configuração do repositório JCR do Jackrabbit (repository.xml) para armazenamento de conteúdo **pentaho-solutions/system/scheduler-plugin/quartz/** - Configuração do banco de dados do scheduler Quartz (quartz.properties) para agendamento de jobs **tomcat/webapps/pentaho/META-INF/** - Contém context.xml com definições de datasource JNDI para todos os bancos de dados do Pentaho (Quartz, Jackrabbit, Hibernate, Audit, Operations Mart) *** **3\_security/** - Configurações de Autenticação e Segurança **pentaho-solutions/system/** - Arquivos de configuração de segurança incluindo applicationContext-security.xml, security.properties e possivelmente configurações LDAP/SSO para autenticação e autorização. *** **4\_others/** - Configurações Adicionais do Tomcat e da Aplicação **pentaho-solutions/system/** - Outras configurações em nível de sistema como pentaho.xml, pentaho-spring-beans.xml, configurações do log4j e configurações de comportamento da aplicação **tomcat/** - Personalizações do servidor Tomcat incluindo server.xml, web.xml, setenv.sh para parâmetros da JVM e outros ajustes específicos do Tomcat {% endhint %} **Scripts Utilitários** ``` ├── scripts/ │ ├── backup-postgres.sh # Utilitário de backup do banco de dados │ ├── restore-postgres.sh # Utilitário de restauração do banco de dados │ ├── backup-vault.sh # Backup de credenciais do Vault │ ├── restore-vault.sh # Restauração de credenciais do Vault │ ├── rotate-secrets.sh # Script de rotação de senhas │ ├── fetch-secrets.sh # Auxiliar de recuperação de secrets │ ├── vault-init.sh # Inicialização do Vault │ └── validate-deployment.sh # Validação da implantação ``` {% hint style="info" %} O **scripts/** diretório contém utilitários operacionais e de manutenção para gerenciar a implantação do Pentaho Server, organizados por área funcional: *** **Gerenciamento de Banco de Dados:** **backup-postgres.sh** - Utilitário automatizado de backup do PostgreSQL que cria dumps de todos os bancos de dados do Pentaho (JCR, Quartz, Hibernate, Audit, Operations Mart). Provavelmente inclui marcação temporal, compressão e lógica de retenção de backups. **restore-postgres.sh** - Utilitário de restauração de banco de dados para recuperar bancos de dados do Pentaho a partir de arquivos de backup, útil para recuperação de desastres, clonagem de ambiente ou migração de dados entre instâncias. *** **Vault/Gerenciamento de Secrets:** **backup-vault.sh** - Script de backup das credenciais e chaves de deselagem do HashiCorp Vault, garantindo a capacidade de recuperação da instância Vault que contém credenciais sensíveis do Pentaho. **restore-vault.sh** - Utilitário de restauração do Vault para recuperar dados do Vault e reinicializar o sistema de gerenciamento de secrets a partir do backup. **rotate-secrets.sh** - Script automatizado de rotação de senhas que atualiza senhas de banco de dados e outras credenciais sensíveis no Vault, e então propaga as alterações para a configuração do Pentaho Server - apoiando as melhores práticas de segurança. **fetch-secrets.sh** - Utilitário auxiliar para recuperar secrets do Vault programaticamente, útil para scripts que precisam acessar credenciais sem codificá-las diretamente. **vault-init.sh** - Script de configuração inicial do Vault que lida com inicialização do Vault, deselagem, criação da política do Pentaho e armazenamento dos secrets iniciais para a implantação. *** **Operações e Validação:** **validate-deployment.sh** - Script de validação da implantação que realiza verificações de integridade em todos os componentes (conectividade com PostgreSQL, inicialização do Pentaho Server, acessibilidade do Vault, disponibilidade dos serviços), confirmando que o ambiente está devidamente configurado e operacional. {% endhint %} *** **Configuração de Usuário e Armazenamento de Dados** ``` ├── config/ │ ├── .kettle/ # Configuração do PDI/Kettle │ │ └── kettle.properties │ └── .pentaho/ # Configurações de usuário do Pentaho ├── backups/ # Armazenamento de backups de banco de dados │ └── *.sql.gz # Backups SQL comprimidos └── logs/ # Logs da aplicação (opcional) ``` {% hint style="info" %} **config/** - Configuração da Aplicação Este diretório armazena arquivos de configuração em nível de usuário e de aplicação: **`.kettle/`** - Diretório de configuração do PDI (Pentaho Data Integration) / Kettle * **kettle.properties** - Contém variáveis de ambiente do Kettle/PDI, parâmetros de conexão, propriedades do sistema e configurações globais usadas por transformações e execuções de jobs no Pentaho Server. **`.pentaho/`** - Diretório de configurações do usuário do Pentaho para armazenar preferências específicas do usuário, metadados em cache e informações de estado da aplicação. *** **backups/** - Armazenamento de Backups de Banco de Dados **`*.sql.gz`** - Repositório para arquivos de backup comprimidos do banco de dados PostgreSQL criados pelo `backup-postgres.sh` script. A compressão gzip reduz os requisitos de armazenamento mantendo snapshots completos do banco de dados para recuperação de desastres, clonagem de ambiente ou cenários de rollback. Os arquivos de backup provavelmente são marcados com timestamp para controle de versões. *** **logs/** - Registro de Logs da Aplicação Diretório centralizado de logs para capturar logs de runtime de todos os serviços. Isso provavelmente inclui: * Logs da aplicação do Pentaho Server (catalina.out, pentaho.log) * Logs do banco de dados PostgreSQL * Logs do serviço Vault * Logs de contêiner Docker * Logs de execução de ETL Isto suporta a **configuração de rotação de logs** e capacidades de monitoramento que você tem incorporado em sua implantação, tornando a solução de problemas e auditoria mais fáceis durante workshops. {% endhint %} *** **Arquivos Chave**
ArquivoPropósito
docker-compose.ymlDefine todos os serviços (pentaho-server, postgres), redes e volumes
docker/DockerfileBuild multi-stage usando debian:trixie-slim com OpenJDK 21
docker-entrypoint.shProcessa diretórios softwareOverride na inicialização do contêiner
.envConfiguração específica do ambiente (portas, senhas, memória)
deploy.shImplantação automatizada com checagens de pré-voo
db_init_postgres/*.sqlScripts de inicialização do banco de dados PostgreSQL
vault-init.shInicializa o Vault e armazena secrets
rotate-secrets.shRoda a rotação de senhas do banco de dados de forma segura
{% endtab %} {% tab title="3. Tarefas de Pré-voo" %} {% hint style="info" %} #### Tarefas de Pré-voo A seção Tarefas de Pré-voo descreve os passos essenciais de preparação necessários antes de implantar o Pentaho Server 11 em contêineres Docker. Primeiro, você precisa configurar as variáveis de ambiente editando o `.env.template` arquivo com as configurações específicas da sua implantação. Isso inclui definir a versão do Pentaho e detalhes da imagem, credenciais do PostgreSQL e configuração de porta (padrão 5432), portas HTTP e HTTPS do Pentaho (8090 e 8443), alocação de memória da JVM (mínimo 4GB, máximo 8GB), URL do servidor de licença e configurações de porta do Vault. Uma vez configurado, este template é salvo como o `.env` arquivo ativo. O ajuste de desempenho do PostgreSQL é tratado através do arquivo `postgres-config/custom.conf` onde você pode personalizar limites de conexão (padrão 200 conexões máximas), parâmetros de alocação de memória incluindo shared\_buffers e tamanhos de cache, e outras otimizações de desempenho especificamente ajustadas para ambientes containerizados. Finalmente, o `softwareOverride/` diretório fornece um mecanismo opcional para personalizar configurações do Pentaho sem modificar os arquivos principais de instalação. O driver JDBC do PostgreSQL vem incluído por padrão, mas você pode opcionalmente atualizá-lo baixando do Maven Central ou copiando da coleção de drivers de banco de dados do workshop. Esta preparação garante que todos os arquivos, configurações e credenciais necessários estejam devidamente preparados antes de executar o script automatizado de implantação. {% endhint %} *** **Configurar .env** 1. Edite o .env.template ```bash cd cd ~/Pentaho-Server-PostgreSQL nano .env.template ``` 2. Insira os seguintes detalhes:
VariávelPadrãoDescrição
PENTAHO_VERSION11.0.0.0-237Versão do Pentaho Server
PENTAHO_IMAGE_NAMEpentaho/pentaho-serverNome da imagem Docker
PENTAHO_IMAGE_TAG11.0.0.0-237Tag da imagem Docker
POSTGRES_PASSWORDsenhaSenha root do PostgreSQL
POSTGRES_PORT5432Porta exposta do PostgreSQL
PENTAHO_HTTP_PORT8090Porta HTTP do Pentaho
PENTAHO_HTTPS_PORT8443Porta HTTPS do Pentaho
PENTAHO_MIN_MEMORY4096mTamanho mínimo do heap da JVM
PENTAHO_MAX_MEMORY8192mTamanho máximo do heap da JVM
LICENSE_URL(vazio)URL do servidor de licença EE
VAULT_PORT8200Porta da API do Vault
3. Salvar: ``` CTRL + o Enter CTRL + x ``` 4. Criar .env ```bash cd cd ~/Pentaho-Server-PostgreSQL cp .env.template .env ``` *** **Personalizar postgres-config/custom.conf** 1. Edite o .env.template ```bash cd cd ~/Pentaho-Server-PostgreSQL/progres-config nano custom.conf ``` 2. Insira os seguintes detalhes: ```conf # Limites de conexão max_connections = 200 # Memória (ajuste com base na RAM disponível) shared_buffers = 256MB effective_cache_size = 768MB work_mem = 16MB # Desempenho random_page_cost = 1.1 effective_io_concurrency = 200 ``` 3. Salvar: ``` CTRL + o Enter CTRL + x ``` *** **softwareOverride** {% hint style="info" %} O `softwareOverride/` diretório fornece um mecanismo poderoso para personalizar o Pentaho Server sem modificar a instalação principal. Arquivos são copiados para a instalação do Pentaho durante a inicialização do contêiner, processados em ordem alfabética pelo nome do diretório. {% endhint %} ```` ``` softwareOverride/ ├── 1_drivers/ # drivers JDBC e conectores de dados │ ├── tomcat/lib/ │ │ └── postgresql-42.x.x.jar # driver JDBC do PostgreSQL (incluído) │ └── pentaho-solutions/drivers/ # drivers de big data (.kar files) ├── 2_repository/ # configuração do repositório de banco de dados │ ├── pentaho-solutions/system/ │ │ ├── hibernate/hibernate-settings.xml │ │ ├── jackrabbit/repository.xml │ │ └── scheduler-plugin/quartz/quartz.properties │ └── tomcat/webapps/pentaho/META-INF/context.xml ├── 3_security/ # autenticação e autorização │ └── pentaho-solutions/system/ │ ├── applicationContext-spring-security-hibernate.properties │ └── applicationContext-spring-security-memory.xml ├── 4_others/ # Tomcat, padrões e diversos │ ├── pentaho-solutions/system/ │ │ ├── defaultUser.spring.properties │ │ ├── pentaho.xml │ │ └── security.properties │ └── tomcat/ │ ├── bin/startup.sh │ └── webapps/pentaho/WEB-INF/web.xml └── 99_exchange/ # Troca de dados do usuário (não processado automaticamente) ``` ```` O driver JDBC do PostgreSQL está incluído na distribuição do Pentaho. Se precisar atualizar: 1. Faça o download de [Maven Central](https://repo1.maven.org/maven2/org/postgresql/postgresql/) 2. Coloque em `softwareOverride/1_drivers/tomcat/lib/` Ou Copie de 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. Implantação" %} {% hint style="info" %} #### Implantação Esta seção descreve o processo de implantação usando o script automatizado ou comandos manuais. {% endhint %} Selecione a opção de implantação: {% tabs %} {% tab title="Automatizada" %} {% hint style="info" %} #### Implantação automatizada O script deploy.sh automatiza todo o processo de implantação com validação prévia: ./deploy.sh O script executa as seguintes ações: * Valida a instalação do Docker e Docker Compose * Verifica se o pacote do Pentaho existe em: `docker/stagedArtifacts/` * Cria `.env` a partir do modelo se estiver ausente * Verifica espaço em disco (mínimo 10GB) * Verifica se as portas necessárias estão disponíveis * Constrói a imagem Docker do Pentaho Server * Inicia o PostgreSQL e aguarda o health check * Inicia o Pentaho Server e monitora a inicialização * Exibe URLs de acesso e credenciais {% endhint %} 1\. Defina permissões de execução nos scripts de implantação. ```bash cd cd ~/Pentaho-Server-PostgreSQL chmod +x deploy.sh chmod +x scripts/*.sh ``` 2. Implante os contêineres. {% hint style="danger" %} Certifique-se de que você não tenha um serviço postgresql em execução: ```bash systemctl stop postgresql ``` {% endhint %} ```bash cd cd ~/Pentaho-Server-PostgreSQL && ./deploy.sh ``` {% tabs %} {% tab title="Fase de pré-verificação & build" %} {% hint style="info" %} **Verificações prévias ✓** O script valida o ambiente antes de iniciar: * Docker está instalado * Docker Compose está instalado * O daemon do Docker está em execução * Pacote do Pentaho encontrado * `.env` arquivo existe * Espaço em disco suficiente (414GB disponíveis) * Porta 8090 (Pentaho HTTP) está disponível * Porta 5432 (PostgreSQL) está disponível **Fase de build** Uma imagem Docker personalizada é construída com **24 etapas de build** levando aproximadamente **5-10 minutos**: * Imagem base: `debian:trixie-slim` * Instala pacotes do sistema via `apt-get update` e `apt-get upgrade` * Instala **OpenJDK 21 JRE headless** com `curl` e `rm` * Cria um `pentaho` usuário e grupo (GID 5000) * (Opcional) Instala plugins do Pentaho (PAZ, PIR, PDD) * Copia a instalação do Pentaho para `/opt/pentaho/` * Exporta camadas e manifests * **Imagem final**: `pentaho/pentaho-server:11.0.0.0-237` {% endhint %}

Verificações prévias & Build

{% endtab %} {% tab title="Implantação & Status final" %} {% hint style="info" %} **Iniciando o banco de dados PostgreSQL** Realiza pull de **PostgreSQL 15** imagem e camadas relacionadas: * Cria rede: `pentaho-server-postgresql_pentaho-net` * Cria volume: `pentaho-server-postgresql_pentaho_postgres_data` * Cria contêiner: `pentaho-postgres` * Aguarda a prontidão do PostgreSQL: **✓ PostgreSQL está pronto** **Iniciando o Pentaho Server** Esta fase leva **2-3 minutos para inicialização pela primeira vez**: **Realiza pull da imagem HashiCorp Vault 1.15** para gerenciamento de segredos **Cria volumes:** * `pentaho-server-postgresql_pentaho_solutions` * `pentaho-server-postgresql_pentaho_data` * `pentaho-server-postgresql_vault_data` {% endhint %}

Implantar contêineres

{% hint style="info" %} **Status final** 🎉 A implantação foi bem sucedida e fornece a você: **Acesso ao Pentaho Server:** * URL: `http://localhost:8090/pentaho` * Login: `admin` / `senha` **Banco de Dados PostgreSQL:** * Host: `localhost:5432` * Login: `postgres` / `senha` {% endhint %} | Ação | Comando | | ------------------ | ------------------------ | | Ver logs | `docker compose logs -f` | | Parar serviços | `docker compose stop` | | Iniciar serviços | `docker compose start` | | Reiniciar serviços | `docker compose restart` | | Desligar | `docker compose down` | {% hint style="info" %} **Scripts auxiliares fornecidos:** * `./scripts/backup-postgres.sh` -- Fazer backup do banco de dados * `./scripts/restore-postgres.sh ` -- Restaurar banco de dados * `./scripts/validate-deployment.sh` -- Validar implantação {% endhint %}

Auxiliar

{% endtab %} {% endtabs %} {% endtab %} {% tab title="Build manual" %} {% hint style="info" %} #### Build manual {% endhint %} 1. Construa a imagem do Pentaho Server. ```bash docker compose build --no-cache pentaho-server ``` {% hint style="info" %} Este processo leva aproximadamente 5-10 minutos enquanto extrai o pacote do Pentaho e configura a imagem. {% endhint %} 2. Iniciar o banco de dados PostgreSQL ```bash docker compose up -d postgres # Aguarde até o PostgreSQL ficar saudável docker compose logs -f postgres ``` {% hint style="info" %} Observe a mensagem indicando que o PostgreSQL está pronto para aceitar conexões. {% endhint %} 3. Inicie o Pentaho Server. ```bash docker compose up -d pentaho-server # Monitorar o progresso de inicialização docker compose logs -f pentaho-server ``` {% hint style="info" %} O Pentaho Server normalmente leva 2-3 minutos na inicialização pela primeira vez. Observe a mensagem: ``` Server startup in [X] milliseconds ``` {% endhint %} {% endtab %} {% endtabs %} 3. Verifique o status do contêiner. ```bash docker compose ps ``` ```bash cd cd ~/Pentaho-Server-PostgreSQL make status ``` 4. Execute o script de validação. ```bash cd cd ~/Pentaho-Server-PostgreSQL/scripts && ./validate-deployment.sh ```

Validar implantação

5. Abra um navegador e navegue para: {% embed url="" %} 5. Faça login com as credenciais padrão: | Nome de usuário | Admin | | --------------- | ----- | | Senha | senha | 6. Insira a URL do Servidor de Licenciamento

Insira os detalhes de licenciamento

{% endtab %} {% tab title="5. Backup & Recuperação" %} {% hint style="info" %} #### Backup & Recuperação Implemente backups regulares para proteger seus dados e configuração do Pentaho. {% endhint %} 1. Crie um backup compactado dos bancos de dados do Pentaho. ```bash ./scripts/backup-postgres.sh # Backups são salvos no diretório backups/ com timestamp # Exemplo: backups/pentaho-postgres-backup-20260113-143022.sql.gz ```

Script de backup

{% 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-pt-br/instalacao/conteineres/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.