> 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/containers/docker.md). # Docker {% hint style="info" %} #### Container Docker A implantação de container Docker permite empacotar e executar produtos Pentaho dentro de containers portáteis, prontos para produção. A conteinerização garante comportamento consistente entre ambientes de desenvolvimento, teste e produção, ao mesmo tempo em que simplifica a implantação e as operações de escalonamento. Você pode criar containers 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 oferece suporte a back-ends de banco de dados corporativos, incluindo PostgreSQL, MySQL, Oracle e SQL Server. Para processamento ETL distribuído, você pode implantar containers 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 containers, permitindo integração com pipelines de CI/CD e fluxos de trabalho em lote automatizados. As implantações em containers são especialmente eficazes para ambientes em nuvem, onde você pode escalar recursos rapidamente para atender às demandas de processamento de dados. Ao executar cargas de trabalho Pentaho em containers, as organizações podem otimizar os custos de infraestrutura enquanto mantêm a flexibilidade de migrar entre plataformas locais e em nuvem. {% endhint %}

Arquitetura de Container Docker mostrando containers do Pentaho Server e do PostgreSQL

{% tabs %} {% tab title="Container do Pentaho Server" %} {% hint style="info" %} Este container executa a plataforma completa Pentaho Business Analytics and Data Integration no Apache Tomcat 10. Ele inclui o Pentaho User Console (PUC), serviços de agendamento e todos os recursos de análise. {% endhint %} {% endtab %} {% tab title="Container PostgreSQL" %} {% hint style="info" %} Este container fornece o back-end 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 a reinicializações do container. {% endhint %}

Arquitetura do Banco de Dados PostgreSQL

O Pentaho Server requer três bancos de dados separados, cada um atendendo a uma finalidade distinta:
Banco de DadosProprietárioFinalidade 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 do usuário. Este é o principal armazenamento de conteúdo do repositório Pentaho.
quartzpentaho_userQuartz Scheduler - Gerencia todos os jobs, gatilhos e calendários agendados. Contém tabelas para definições de jobs (QRTZ6_JOB_DETAILS), gatilhos (QRTZ6_TRIGGERS), histórico de execução e locks de coordenação de cluster.
hibernatehibuserHibernate Repository - Hospeda a configuração de segurança, logs de auditoria, dados de sessão do usuário e contém dois esquemas adicionais: pentaho_dilogs (log 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 de execução ETL, incluindo logs de jobs, logs de transformações, métricas de desempenho de etapas e registros de erros. Essencial para depurar fluxos de trabalho de integração de dados e monitorar a saúde do pipeline. **pentaho\_operations\_mart**: Um data mart dimensional para análises sobre o 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 a utilização da plataforma, tendências de desempenho e atividade do usuário. Para implantações em 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 do usuário. Considere usar pg\_dump para backups lógicos ou snapshots do volume para opções completas de recuperação. {% endhint %} {% endtab %} {% tab title="Rede" %} {% hint style="info" %} Pontos-chave: * O container Pentaho se conecta ao PostgreSQL usando o nome do serviço 'repository' como hostname * O PostgreSQL escuta internamente na porta 5432 (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 containers permanece dentro da rede Docker por segurança {% endhint %}

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

O Tomcat gerencia pools de conexão definidos no context.xml. Cada pool atende a uma finalidade específica:
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 Runtime ETL
jdbc/PDI_Operations_Martrepository:5432/hibernateAnálises Operacionais
{% hint style="info" %} Quando um usuário acessa o Pentaho Server: 1\. O navegador do usuário envia uma solicitação HTTP para localhost:8080 2\. O Docker encaminha a solicitação para a porta 8080 do container Pentaho 3\. O Tomcat recebe a solicitação e a direciona para a aplicação web pentaho.war 4\. A aplicação recupera/armazena dados por meio de pools de conexão JDBC 5\. As conexões JDBC são direcionadas para 'repository:5432' (container PostgreSQL) 6\. A resposta retorna pelo mesmo caminho até o navegador do usuário {% endhint %} {% endtab %} {% tab title="Mapeamento de Volumes" %} {% hint style="info" %} #### Mapeamento de Volumes A implantação usa tanto volumes nomeados do Docker 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 começar a implantação Docker, certifique-se de ter concluído a Configuração: [Containers Pentaho](/pentaho-11-installation-en/pentaho-11-installation-pt-br/configuracao/pentaho-containers.md) {% endhint %} Siga as etapas abaixo para implantar o Pentaho Server com o repositório PostgreSQL 15. {% tabs %} {% tab title="1. Preparar Ambiente" %} {% hint style="info" %} #### Preparar o Ambiente Verifique se o Docker está em execução: * Copiar artefatos Pentaho-Server-PostgreSQL * Copiar `pentaho-server-ee-11.0.0.0-237.zip` * Verificar Docker e 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 artefatos. ```bash cd cp -r ~/Workshop--Installation/Pentaho-Containers/On-Prem/Pentaho-Server-PostgreSQL . ``` 2. Copie o arquivo 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 arquivo, então copie de: `/opt/pentaho/software/pentaho-server-ee-version` Caso contrário, baixe o pacote de [Portal do Cliente 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: versão do Docker 29.0.2 ou superior ``` 5. Verifique a versão do Docker Compose. ```bash docker compose --version # Saída esperada: versão do Docker Compose 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 de todo o sistema sem erros ``` 7. Verifique se a porta 8080 / 8090 está disponível no sistema host. ```bash sudo lsof -i ::8080 ``` {% hint style="info" %} Se a porta 8080 estiver em uso por outro aplicativo, você pode alterar a variável PORT no arquivo .env para qualquer porta disponível (por exemplo, 8090, 8081, 9090). {% endhint %} 8. O Pentaho Server requer uma licença válida. O `.env` arquivo contém uma LICENSE\_URL apontando para o servidor de licença Flexera. Certifique-se de que seus direitos de licença estejam ativos antes da implantação. {% hint style="warning" %} Sem uma licença válida, o Pentaho Server será iniciado, mas muitos recursos serão desativados. Verifique o status da sua licença antes de prosseguir com implantações em produção. {% endhint %} {% endtab %} {% tab title="2. Layout do Diretório" %} {% hint style="info" %} #### Layout do Diretório Esta configuração de implantação oferece vários recursos importantes: * Implantação completamente autônoma e portátil. * Inicialização automatizada do banco de dados com scripts SQL. * Verificações de integridade e ordem correta de inicialização entre os serviços. * Volumes de dados persistentes para o banco de dados e o conteúdo Pentaho. * HashiCorp Vault para gerenciamento de segredos com autenticação AppRole. * Containers somente leitura com mounts tmpfs para segurança. * Limites de recursos (CPU/memória) para estabilidade. * Rotação de logs para evitar esgotamento do disco. * Sistema de override de software para personalizar configurações sem modificar arquivos principais. * 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 do 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 soluçã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 (criada) ├── .env.template # Modelo de ambiente com padrões ``` {% hint style="info" %} **Arquivos de Documentação:** **README.md** - A principal documentação de entrada, 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 containers, rede, fluxo de dados e decisões arquiteturais para a implantação baseada em Docker. **CONFIGURATION.md** - Guia abrangente de referência de configuração detalhando todas as variáveis de ambiente, opções de configuração, parâmetros de personalização e definições para os componentes Pentaho Server e PostgreSQL. **TROUBLESHOOTING.md** - Guia de soluçã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ê pode encontrar. **Orquestração e Implantação:** **docker-compose.yml** - O arquivo de definições de serviços do Docker Compose que declara todos os containers (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. Os usuários podem executar `make help` para ver os comandos disponíveis. **deploy.sh** - Script automatizado de implantação 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 do Ambiente:** **.env** - O arquivo de configuração de ambiente ativo (criado a partir do modelo) contendo valores reais para senhas de banco de dados, portas, hostnames e outras configurações específicas do ambiente. Este arquivo geralmente é ignorado pelo git. **.env.template** - O arquivo de modelo 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 do Docker** ``` ├── docker/ │ ├── Dockerfile # Build multiestágio da imagem do Pentaho Server │ ├── entrypoint/ │ │ └── docker-entrypoint.sh # Script de inicialização do container │ └── stagedArtifacts/ │ └── pentaho-server-ee-11.0.0.0-237.zip ``` {% hint style="info" %} A **docker/** o diretório contém todos os componentes principais necessários para construir e executar a implantação containerizada do Pentaho Server: **Dockerfile** - Esta é a principal configuração de build usando uma abordagem de build multiestágio para criar a imagem do container do Pentaho Server. Builds multiestágio ajudam a otimizar o tamanho final da imagem ao separar o ambiente de build do ambiente de execução. **entrypoint/** o diretório contém o **docker-entrypoint.sh** script, que é o script de inicialização executado quando o container 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 preparação 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 build 237 da versão 11.0.0.0 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 # Agendador Quartz │ ├── 3_create_repository_postgresql.sql # Repositório Hibernate │ ├── 4_pentaho_logging_postgresql.sql # Esquema de logging de auditoria/DI │ └── 5_pentaho_mart_postgresql.sql # Esquema do data mart de operações ``` {% hint style="info" %} A **db\_init\_postgres/** o diretório contém os scripts de inicialização do banco de dados PostgreSQL que configuram todos os esquemas exigidos pelo Pentaho Server 11. Esses scripts são numerados para serem executados em uma sequência específica: **1\_create\_jcr\_postgresql.sql** - Cria o **Jackrabbit Content Repository (JCR)** esquema, que armazena o conteúdo do repositório Pentaho, incluindo arquivos de solução, agendas, 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 agendados dentro do Pentaho Server, incluindo geração de relatórios, execuções ETL e outros processos automatizados. **3\_create\_repository\_postgresql.sql** - Cria o **Hibernate Repository** esquema, que armazena autenticação de usuários, dados de autorização, funções, permissões e outras informações relacionadas à segurança gerenciadas pelo subsistema de segurança do Pentaho. **4\_pentaho\_logging\_postgresql.sql** - Estabelece o **Audit and Data Integration (DI) Logging** esquema para capturar logs de execução, métricas de jobs/transformações e informações de trilha de auditoria dos processos PDI em execução no servidor. **5\_pentaho\_mart\_postgresql.sql** - Cria o **Operations Mart** esquema, que armazena dados analíticos operacionais sobre o uso do Pentaho Server, métricas de desempenho e informações de monitoramento do sistema usadas pelo painel Pentaho Operations Mart. {% endhint %} *** **Configuração do PostgreSQL e do Vault** ``` ├── postgres-config/ │ ├── custom.conf # Ajuste de desempenho do PostgreSQL │ └── pg_hba.conf # Configuração de autenticação do cliente ├── 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 de trabalho 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, ajustados 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 do cliente, regras de acesso por endereço IP e políticas de segurança para conexões de banco de dados a partir do container Pentaho Server. *** **vault/** - Integração com o HashiCorp Vault Este diretório oferece suporte à incorporação do Vault para gerenciamento de segredos: **config/vault.hcl** - O arquivo de configuração do servidor HashiCorp Vault que define o backend de armazenamento, as configurações do listener, os endpoints da API, o comportamento de seal/unseal e os 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 segredos a aplicação Pentaho pode ler, gravar ou gerenciar. Isso impõe acesso de menor privilégio a 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 secrets do Docker (ou integração com Vault), este arquivo fornece as credenciais do banco de dados de forma segura, em vez de passá-las como variáveis de ambiente em texto simples. O arquivo deve ter permissões restritas e geralmente é 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
*** **Substituições 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" %} A **softwareOverride/** o diretório contém arquivos de configuração personalizados e componentes que substituem a instalação padrão do Pentaho Server. A estrutura numerada garante 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 de 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 a 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 baseados em 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ários/funções **pentaho-solutions/system/jackrabbit/** - Configuração do repositório Jackrabbit JCR (repository.xml) para armazenamento de conteúdo **pentaho-solutions/system/scheduler-plugin/quartz/** - Configuração do banco de dados do agendador Quartz (quartz.properties) para agendamento de jobs **tomcat/webapps/pentaho/META-INF/** - Contém context.xml com definições de datasources JNDI para todos os bancos de dados 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 segredos │ ├── vault-init.sh # Inicialização do Vault │ └── validate-deployment.sh # Validação da implantação ``` {% hint style="info" %} A **scripts/** o 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 lógica de carimbo de data/hora, compressão e retenção de backups. **restore-postgres.sh** - Utilitário de restauração de banco de dados para recuperar os 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. *** **Gerenciamento de Vault/Segredos:** **backup-vault.sh** - Script de backup das credenciais e chaves de unseal do HashiCorp Vault, garantindo capacidade de recuperação para a instância do Vault que contém credenciais sensíveis do Pentaho. **restore-vault.sh** - Utilitário de restauração do Vault para recuperar os dados do Vault e reinicializar o sistema de gerenciamento de segredos a partir do backup. **rotate-secrets.sh** - Script automatizado de rotação de senhas que atualiza as senhas do 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 segredos do Vault programaticamente, útil para scripts que precisam acessar credenciais sem codificá-las diretamente. **vault-init.sh** - Script inicial de configuração do Vault que lida com a inicialização do Vault, unseal, criação da política do Pentaho e armazenamento dos segredos iniciais para a implantação. *** **Operações e Validação:** **validate-deployment.sh** - Script de validação da implantação que executa 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á configurado corretamente e operacional. {% endhint %} *** **Configuração do Usuário e Armazenamento de Dados** ``` ├── config/ │ ├── .kettle/ # Configuração do PDI/Kettle │ │ └── kettle.properties │ └── .pentaho/ # Configurações do usuário Pentaho ├── backups/ # Armazenamento de backups do banco de dados │ └── *.sql.gz # Backups SQL compactados └── logs/ # Logs da aplicação (opcional) ``` {% hint style="info" %} **config/** - Configuração da Aplicação Este diretório armazena arquivos de configuração no nível do usuário e da 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 execuções de transformações e jobs em execução no Pentaho Server. **`.pentaho/`** - Diretório de configurações do usuário Pentaho para armazenar preferências específicas do usuário, metadados em cache e informações de estado da aplicação. *** **backups/** - Armazenamento de Backup do Banco de Dados **`*.sql.gz`** - Repositório para arquivos compactados de backup do banco de dados PostgreSQL criados pelo `backup-postgres.sh` script. A compressão gzip reduz os requisitos de armazenamento enquanto mantém snapshots completos do banco de dados para cenários de recuperação de desastres, clonagem de ambiente ou reversão. Os arquivos de backup provavelmente usam carimbo de data/hora para controle de versão. *** **logs/** - Registro da Aplicação Diretório centralizado de logs para capturar logs de tempo de execução 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 dos contêineres Docker * logs de execução de ETL Isso oferece suporte à **configuração de rotação de logs** e aos recursos de monitoramento que você vem incorporando à sua implantação, facilitando a resolução de problemas e a auditoria durante os workshops. {% endhint %} *** **Arquivos Principais**
ArquivoFinalidade
docker-compose.ymlDefine todos os serviços (pentaho-server, postgres), redes e volumes
docker/DockerfileBuild em várias etapas 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 verificações de validação pré-execução
db_init_postgres/*.sqlScripts de inicialização do banco de dados PostgreSQL
vault-init.shInicializa o Vault e armazena os segredos
rotate-secrets.shRotaciona senhas do banco de dados com segurança
{% endtab %} {% tab title="3. Tarefas Pré-implantação" %} {% hint style="info" %} #### Tarefas Pré-implantação A seção de Tarefas Pré-implantação descreve as etapas essenciais de preparação necessárias 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 os detalhes da imagem, as credenciais do PostgreSQL e a configuração da porta (com padrão 5432), as portas HTTP e HTTPS do Pentaho (8090 e 8443), a alocação de memória da JVM (mínimo 4GB, máximo 8GB), a URL do servidor de licença e as configurações da porta do Vault. Uma vez configurado, este modelo é salvo como o `.env` arquivo ativo. O ajuste de desempenho do PostgreSQL é tratado pelo `postgres-config/custom.conf` arquivo, onde você pode personalizar limites de conexão (com padrão de 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 ajustadas especificamente para ambientes conteinerizados. Por fim, o `softwareOverride/` diretório fornece um mecanismo opcional para personalizar as configurações do Pentaho sem modificar os arquivos principais de instalação. O driver JDBC do PostgreSQL já vem incluído por padrão, mas você pode atualizá-lo opcionalmente 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 de implantação automatizada. {% 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_PASSWORDpasswordsenha 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" %} A `softwareOverride/` diretório fornece um mecanismo poderoso para personalizar o Pentaho Server sem modificar a instalação principal. Os 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 do 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 você precisar atualizar: 1. Baixe em [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 orienta você pelo 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é-execução: ./deploy.sh O script executa as seguintes ações: * Valida a instalação do Docker e do Docker Compose * Verifica se o pacote Pentaho existe em: `docker/stagedArtifacts/` * Cria `.env` a partir do modelo, se estiver ausente * Verifica o espaço em disco (mínimo de 10GB) * Verifica se as portas necessárias estão disponíveis * Compila a imagem Docker do Pentaho Server * Inicia o PostgreSQL e aguarda a verificação de integridade * Inicia o Pentaho Server e monitora a inicialização * Exibe URLs de acesso e credenciais {% endhint %} 1\. Defina as 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é-implantação e Build" %} {% hint style="info" %} **Verificações Pré-implantação ✓** O script valida o ambiente antes de iniciar: * Docker está instalado * Docker Compose está instalado * O daemon do Docker está em execução * Pacote Pentaho encontrado * `.env` o arquivo existe * Espaço em disco suficiente (414GB disponíveis) * A porta 8090 (HTTP do Pentaho) está disponível * A porta 5432 (PostgreSQL) está disponível **Fase de Build** Uma imagem Docker personalizada é criada 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 manifestos * **Imagem final**: `pentaho/pentaho-server:11.0.0.0-237` {% endhint %}

Verificações de pré-implantação e Build

{% endtab %} {% tab title="Implantação e Status Final" %} {% hint style="info" %} **Iniciando o Banco de Dados PostgreSQL** Baixa a imagem **PostgreSQL 15** e camadas relacionadas: * Cria a rede: `pentaho-server-postgresql_pentaho-net` * Cria o volume: `pentaho-server-postgresql_pentaho_postgres_data` * Cria o contêiner: `pentaho-postgres` * Aguarda a prontidão do PostgreSQL: **✓ PostgreSQL está pronto** **Iniciando o Pentaho Server** Esta fase leva **2-3 minutos para a inicialização na primeira vez**: **Baixa a imagem do 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` / `password` **Banco de Dados PostgreSQL:** * Host: `localhost:5432` * Login: `postgres` / `password` {% 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. Compile a imagem do Pentaho Server. ```bash docker compose build --no-cache pentaho-server ``` {% hint style="info" %} Este processo leva aproximadamente 5-10 minutos, pois extrai o pacote Pentaho e configura a imagem. {% endhint %} 2. Iniciar banco de dados PostgreSQL ```bash docker compose up -d postgres # Aguarde até que o PostgreSQL esteja 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 # Monitore o progresso da inicialização docker compose logs -f pentaho-server ``` {% hint style="info" %} O Pentaho Server normalmente leva 2-3 minutos para a inicialização na primeira vez. Procure a mensagem: ``` Inicialização do servidor em [X] milissegundos ``` {% 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 da web e navegue até: {% embed url="" %} 5. Faça login com as credenciais padrão: | Nome de usuário | Administrador | | --------------- | ------------- | | Senha | password | 6. Insira a URL do Servidor de Licenciamento

Insira os detalhes da licença

{% endtab %} {% tab title="5. Backup e Restauração" %} {% hint style="info" %} #### Backup e Restauração Implemente backups regulares para proteger seus dados e configurações do Pentaho. {% endhint %} 1. Crie um backup compactado dos bancos de dados do Pentaho. ```bash ./scripts/backup-postgres.sh # Os backups são salvos no diretório backups/ com carimbo de data e hora # 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, and the optional `goal` query parameter: ``` GET https://academy.pentaho.com/pentaho-11-installation-en/pentaho-11-installation-pt-br/instalacao/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.