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

# Contêineres do Pentaho

{% hint style="info" %}

#### Contêineres do Pentaho

O Pentaho Server oferece opções flexíveis de implantação para atender a uma variedade de estratégias de infraestrutura. Para **local** ambientes, as organizações podem implantar usando Docker Compose para configurações simples em um único host, ou orquestrar em clusters usando Kubernetes (K8s & K3s) para maior escalabilidade e resiliência.

Para **nuvem (hiperescalador)** implantações, o Pentaho fornece imagens Docker otimizadas e pré-construídas, desenvolvidas especificamente para Amazon Web Services (EKS/ECR), Microsoft Azure (AKS) e Google Cloud Platform (GKE), permitindo que as equipes aproveitem serviços Kubernetes gerenciados e armazenamento nativo da nuvem como o Amazon S3. A partir do Pentaho 11, essas imagens apresentam caminhos de instalação padronizados, variáveis de ambiente e scripts entrypoint aprimorados que oferecem suporte a substituições de configuração em tempo de execução - o que significa que licenças e arquivos de configuração podem ser injetados na inicialização sem reconstruir a imagem.

Uma **híbrida** abordagem também é totalmente suportada, na qual as organizações podem executar o Pentaho Server localmente para cargas de trabalho sensíveis enquanto implantam contêineres do servidor Carte ou nós de trabalho do PDI na nuvem para lidar com picos de processamento, combinando o controle da infraestrutura local com a elasticidade dos recursos da nuvem.
{% endhint %}

{% hint style="danger" %}
As etapas a seguir destinam-se à configuração de um ambiente Pentaho Lab e precisam ser concluídas para finalizar os Workshops.

Certifique-se de ter baixado o Workshop--Installation:

```bash
cd
git clone https://github.com/jporeilly/Workshop--Installation
```

Para instalar o git:

```bash
sudo apt install git
```

{% endhint %}

Selecione seu host de contêiner:

{% tabs %}
{% tab title="Docker" %}
{% hint style="info" %}

#### Docker

Docker é uma plataforma que permite aos desenvolvedores empacotar aplicativos e suas dependências em contêineres leves e portáteis. Os contêineres garantem que os aplicativos sejam executados de forma consistente em diferentes ambientes de computação, de laptops de desenvolvimento a servidores de produção. Este workshop orientará você pelo processo completo de instalação do Docker Engine no Ubuntu 24.04 LTS (Noble Numbat).
{% endhint %}

1. Antes de instalar o Docker, atualize sua lista de pacotes existente.

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

2. Instale os pacotes que permitem ao apt usar repositórios via HTTPS.

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

3. Crie um diretório para keyrings e adicione a chave GPG do Docker.

```bash
sudo install -m 0755 -d /etc/apt/keyrings
```

```bash
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
```

```bash
sudo chmod a+r /etc/apt/keyrings/docker.gpg
```

4. Adicione o repositório Docker às suas fontes do apt.

```bash
echo \\
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \\
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \\
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
```

5. Agora que o repositório Docker foi adicionado, atualize o índice de pacotes.

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

6. Instale o Docker Engine, o containerd e o Docker Compose.

```bash
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
```

7. Verifique se o Docker foi instalado corretamente conferindo a versão.

```bash
docker --version
```

Você deverá ver uma saída semelhante a (nov 2025):

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

8. Verifique se o Docker Engine está em execução.

```bash
sudo systemctl status docker
```

O serviço deve aparecer como "active (running)".

9. Sair.

```bash
q
```

10. Teste sua instalação do Docker executando o contêiner hello-world.

```bash
sudo docker run hello-world
```

{% hint style="info" %}
Este comando baixa uma imagem de teste e a executa em um contêiner. Se tiver sucesso, você verá uma mensagem confirmando que o Docker está funcionando corretamente.
{% endhint %}

***

{% hint style="info" %}

#### Sem Sudo

Por padrão, o Docker requer privilégios de sudo. Para executar comandos Docker sem sudo.
{% endhint %}

1. Adicione seu usuário ao grupo docker.

```bash
sudo usermod -aG docker $USER
```

2. Aplique a nova associação ao grupo (ou saia e entre novamente).

```bash
newgrp docker
```

3. Verifique se você consegue executar o Docker sem sudo.

```bash
docker run hello-world
```

4. Certifique-se de que o Docker inicie automaticamente quando o sistema for inicializado.

```bash
sudo systemctl enable docker.service
sudo systemctl enable containerd.service
```

***

{% hint style="info" %}

#### Verificação e Testes

Para confirmar que tudo está funcionando corretamente, execute os seguintes comandos:
{% endhint %}

Verifique a versão do Docker:

```bash
docker version
```

Veja as informações do sistema Docker:

```bash
docker info
```

Liste os contêineres em execução:

```bash
docker ps
```

Liste todos os contêineres (incluindo os parados):

```bash
docker ps -a
```

Liste as imagens baixadas:

```bash
docker images
```

***

{% hint style="info" %}

#### Comandos Comuns

Aqui estão comandos essenciais do Docker que você usará regularmente:

* `docker pull <image>` - Baixe uma imagem do Docker Hub
* `docker images` - Liste todas as imagens locais
* `docker run <image>` - Crie e inicie um contêiner a partir de uma imagem
* `docker ps` - Liste os contêineres em execução
* `docker ps -a` - Liste todos os contêineres
* `docker stop <container>` - Pare um contêiner em execução
* `docker rm <container>` - Remova um contêiner parado
* `docker rmi <image>` - Remova uma imagem
* `docker logs <container>` - Veja os logs do contêiner
* `docker exec -it <container> bash` - Acesse o shell de um contêiner em execução
  {% endhint %}
  {% endtab %}

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

#### K3s

K3s é uma distribuição Kubernetes leve e totalmente compatível, projetada para ambientes com recursos limitados e de edge computing. Ele é empacotado como um único binário ou uma imagem de contêiner mínima, tornando sua implantação e gerenciamento significativamente mais fáceis do que o Kubernetes padrão. A distribuição usa SQLite3 como seu armazenamento padrão leve, embora também suporte etcd3, MySQL e Postgres para usuários que precisem de opções mais robustas.

A plataforma simplifica as operações do Kubernetes ao reunir todos os componentes do plano de controle em um único binário e processo. Essa abordagem unificada automatiza tarefas complexas como distribuição de certificados e configuração TLS, mantendo a segurança por padrão com configurações sensatas para ambientes leves. O K3s tem dependências externas mínimas, exigindo apenas um kernel Linux moderno e pontos de montagem cgroup para ser executado.

O K3s vem "com tudo incluído" com componentes essenciais pré-empacotados, eliminando a necessidade de instalação e configuração separadas. Isso inclui containerd para runtime de contêiner, Flannel para rede, CoreDNS para descoberta de serviços, Traefik para ingress e vários outros controladores críticos para balanceamento de carga, políticas de rede, armazenamento e gerenciamento de imagens. Esse pacote abrangente torna o K3s ideal para criação rápida de clusters em locais de edge, implantações de IoT, pipelines de CI/CD e ambientes de desenvolvimento.
{% endhint %}

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

1. Antes de instalar o Docker, atualize sua lista de pacotes existente.

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

2. Instale os pacotes que permitem ao apt usar repositórios via HTTPS.

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

3. Desative o swap (recomendado para Kubernetes).

```bash
# Desative o swap imediatamente
sudo swapoff -a

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

# Verifique se o swap está desativado
free -h | grep Swap
```

4. Ative o encaminhamento de IP.

```bash
sudo tee /etc/sysctl.d/k3s.conf <<EOF 
net.ipv4.ip_forward = 1 
net.bridge.bridge-nf-call-iptables = 1 
net.bridge.bridge-nf-call-ip6tables = 1 
EOF 
sudo sysctl --system
```

5. Configure o firewall.

```bash
# Verifique se o UFW está ativo
sudo ufw status

# Se o UFW estiver ativo, permita as portas necessárias
sudo ufw allow 6443/tcp    # API do Kubernetes
sudo ufw allow 8472/udp    # Flannel VXLAN
sudo ufw allow 10250/tcp   # Kubelet
sudo ufw allow 80/tcp      # HTTP
sudo ufw allow 443/tcp     # HTTPS
```

***

Selecione suas opções de implantação:

{% tabs %}
{% tab title="Nó Único" %}
{% hint style="info" %}

#### **Instalação em Nó Único**

{% endhint %}

1. Verifique os requisitos do sistema.

```bash
# Verifique os requisitos do sistema
echo "=== Informações do Sistema ==="
echo "SO: $(lsb_release -d | cut -f2)"
echo "Kernel: $(uname -r)"
echo "Núcleos da CPU: $(nproc)"
echo "RAM Total: $(free -h | awk '/^Mem:/ {print $2}')"
echo "Disco Disponível: $(df -h / | awk 'NR==2 {print $4}')"
```

2. Instale o K3s.

```bash
# Instale o servidor K3s (inclui o agente)
curl -sfL https://get.k3s.io | sh -
```

{% hint style="info" %}
Este comando:

\- Baixa e instala o K3s

\- Inicia o serviço K3s

\- Instala o kubectl

\- Configura o kubeconfig

```
O que é instalado:
- Servidor K3s (plano de controle + worker)
- Containerd (runtime de contêiner)
- Flannel (plug-in de rede CNI)
- CoreDNS (DNS do cluster)
- Traefik (controlador de ingress)
- Provisionador de caminho local (armazenamento)
- Servidor de métricas
```

{% endhint %}

2. Configure o acesso ao kubectl.

```bash
# Crie o diretório de configuração do kube
mkdir -p ~/.kube

# Copie a configuração do K3s para o local padrão
sudo cp /etc/rancher/k3s/k3s.yaml ~/.kube/config

# Corrija as permissões
sudo chown $(id -u):$(id -g) ~/.kube/config
chmod 600 ~/.kube/config

# Defina a variável de ambiente KUBECONFIG
echo 'export KUBECONFIG=~/.kube/config' >> ~/.bashrc
source ~/.bashrc

# Teste o acesso ao kubectl
kubectl version --short
```

4\. Verificar a instalação

```bash
# Verifique o status do nó
kubectl get nodes

# Saída esperada:
# NOME         STATUS   FUNÇÕES                IDADE   VERSÃO
NAME      STATUS   ROLES           AGE     VERSION
pentaho   Pronto    control-plane   5d20h   v1.34.3+k3s1

# Verifique os pods do sistema
kubectl get pods -A
```

<figure><img src="/files/d7f185e9e83da3ed97ef37331742d7626a39abc2" alt=""><figcaption><p>Verifique o K3s</p></figcaption></figure>

5. Verifique a instalação do K3s.

```sh
cd
cd ~/Pentaho-K3s-PostgreSQL
./verify-k3s.sh
```

{% endtab %}

{% tab title="Multi-nó" %}
{% hint style="info" %}

#### Cluster Multi-nó

{% endhint %}

#### Nó do Servidor (Plano de Controle)

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

# Obtenha o token do nó (necessário para os agentes)
sudo cat /var/lib/rancher/k3s/server/node-token
```

#### Nós Agentes (Workers)

Em cada nó worker:

```bash
# Defina as variáveis
K3S_URL="https://<server-ip>:6443"
K3S_TOKEN="<node-token-from-server>"

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

#### Verifique o cluster multi-nó

No nó do servidor:

```bash
kubectl get nodes

# Saída esperada:
# NOME         STATUS   FUNÇÕES                IDADE   VERSÃO
# server-01    Pronto    control-plane,master   5m    v1.29.0+k3s1
# worker-01    Pronto    <none>                 2m    v1.29.0+k3s1
# worker-02    Pronto    <none>                 1m    v1.29.0+k3s1
```

{% endtab %}

{% tab title="Aliases do Kubectl" %}

1. Adicione aliases úteis.

```bash
# Adicione aliases úteis
cat >> ~/.bashrc << 'EOF'

# Aliases do Kubernetes
alias k='kubectl'
alias kgp='kubectl get pods'
alias kgs='kubectl get svc'
alias kgn='kubectl get nodes'
alias kga='kubectl get all'
alias kd='kubectl describe'
alias kl='kubectl logs'
alias kaf='kubectl apply -f'
alias kdf='kubectl delete -f'

# Ative o autocompletar do kubectl
source <(kubectl completion bash)
complete -F __start_kubectl k
EOF

source ~/.bashrc
```

{% endtab %}

{% tab title="Pós-instalação" %}
{% hint style="info" %}

### Configuração Pós-instalação

{% endhint %}

1. Verifique a StorageClass padrão

```bash
# Verifique a StorageClass
kubectl get storageclass
```

```
# Saída esperada:
NAME                   PROVISIONER             RECLAIMPOLICY   VOLUMEBINDINGMODE      ALLOWVOLUMEEXPANSION   AGE
local-path (default)   rancher.io/local-path   Delete          WaitForFirstConsumer   false                  5d21h
```

2. Configure o Ingress do Traefik

```bash
kubectl get pods -n kube-system -l app.kubernetes.io/name=traefik
```

3. Instale o Helm (opcional, mas recomendado)

```bash
# Instale o Helm
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

# Verifique
helm version
```

4\. Instale o k9s (opcional - interface de terminal)

```bash
# Instale o k9s para facilitar o gerenciamento do cluster
curl -sS https://webinstall.dev/k9s | bash

# Execute o k9s
k9s
```

<figure><img src="/files/385ce46337ce9e4a4214a511223726e98383bd4c" alt=""><figcaption><p>K9s</p></figcaption></figure>

5\. Verifique a instalação do K3s.

```bash
cd
cd ~/Pentaho-K3s-PostgreSQL

# Torne o script executável
chmod +x scripts/verify-k3s.sh

# Execute a verificação
./scripts/verify-k3s.sh
```

<figure><img src="/files/a864f94fdc80ed08f226e7fbc536d25371c5ac5c" alt=""><figcaption><p>Verifique o K3s</p></figcaption></figure>
{% endtab %}
{% endtabs %}
{% endtab %}

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

#### Charts do Helm

Helm é o gerenciador de pacotes do Kubernetes, frequentemente chamado de "apt/yum para Kubernetes". Ele simplifica a implantação e o gerenciamento de aplicativos Kubernetes por meio de:

**Empacotamento**: Agrupando recursos relacionados do Kubernetes

**Modelagem**: Parametrizando manifestos para reutilização entre ambientes

**Versionamento**: Gerenciando versões e atualizações do aplicativo

**Gerenciamento de Releases**: Acompanhando implantações e permitindo reversões
{% endhint %}

1. Execute o seguinte script de instalação.

```bash
cd
cd ~/Pentaho-K3s-PostgreSQL/helm-chart
./install-helm.sh
```

<figure><img src="/files/9232438f57c3aba36799f3d61931a317766efc72" alt=""><figcaption><p>Instale o Helm</p></figcaption></figure>

ou

1. Adicione a chave GPG do Helm.

```bash
# Adicione a chave GPG do Helm
curl https://baltocdn.com/helm/signing.asc | gpg --dearmor | sudo tee /usr/share/keyrings/helm.gpg > /dev/null# Instale o pacote apt-transport-https
```

2. Instale as dependências

```bash
# Instale o pacote apt-transport-https:
sudo apt-get install apt-transport-https --yes
```

3. Adicione o repositório Helm.

```bash
# Adicione o repositório Helm
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/helm.gpg] https://baltocdn.com/helm/stable/debian/ all main" | sudo tee /etc/apt/sources.list.d/helm-stable-debian.list

```

4. Atualize a lista de pacotes e instale.

```sh
# Atualize a lista de pacotes:
sudo apt-get update

# instale o Helm:
sudo apt-get install helm
```

5. Verifique a instalação.

```sh
# Verifique a instalação do Helm:
helm version --client
```

***

**Comandos do Helm**

```bash
# Verifica se o seu chart Helm tem problemas antes da implantação.
helm lint

# Renderiza os templates do seu chart Helm localmente e exibe a saída, útil para depuração.
helm template

# Simula a instalação do chart sem implantá-lo de fato, permitindo que você verifique as alterações.
helm install my-chart . --dry-run

# Fornece uma lista de todos os comandos e opções do Helm disponíveis.
helm --help

# Atualiza uma release existente com uma nova versão do chart, essencial para manter e atualizar aplicativos.
helm --help

# Lista todas as releases do Helm no namespace atual, útil para acompanhar aplicativos implantados.
helm list

# Recupera os valores usados para uma release específica, permitindo revisar ou modificar configurações.
helm get values RELEASE_NAME

# Exclui uma release do Helm do cluster, removendo os recursos Kubernetes associados.
helm delete RELEASE_NAME

# Reverte uma release para uma versão anterior, útil para voltar a um estado estável se uma atualização causar problemas.
helm rollback RELEASE_NAME REVISION

# Adiciona um repositório de charts Helm, permitindo baixar charts de diferentes fontes.
helm repo add REPO_NAME REPO_URL

# Atualiza o cache local dos repositórios de charts, garantindo que você tenha as versões mais recentes disponíveis.
helm repo update

# Empacota um chart Helm em um arquivo .tgz, que pode ser compartilhado ou enviado para um repositório.
helm package CHART_PATH

# Envia um chart empacotado para um repositório Helm, facilitando a distribuição e a implantação.
helm push CHART_PATH REPO_NAME
```

{% endtab %}

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

#### DBeaver

Você vai precisar de uma ferramenta de gerenciamento de banco de dados. O DBeaver Community é uma ferramenta gratuita e de código aberto para gerenciamento de bancos de dados, ideal para projetos pessoais.
{% endhint %}

1. A opção mais simples é baixar e instalar pela Snap Store.

```bash
cd
sudo apt update && sudo apt upgrade
sudo apt install snapd
sudo snap install dbeaver-ce
```

Ou

Acesse a página oficial [página de download do DBeaver](https://dbeaver.io/download/)

{% embed url="<https://dbeaver.io/files/dbeaver-ce_latest_amd64.deb>" %}

Ou

Para instalar esse arquivo DEB.

```bash
wget https://dbeaver.io/debs/dbeaver.gpg.key -O /tmp/dbeaver.gpg.key
sudo gpg --dearmor -o /usr/share/keyrings/dbeaver.gpg /tmp/dbeaver.gpg.key
echo "deb [signed-by=/usr/share/keyrings/dbeaver.gpg] https://dbeaver.io/debs/dbeaver-ce /" | sudo tee /etc/apt/sources.list.d/dbeaver.list
sudo apt update
sudo apt install dbeaver-ce
```

4. Fixe o DBeaver no Dash - barra inferior.
   {% endtab %}

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

#### Fazer

Um makefile é simplesmente uma forma de associar nomes curtos, chamados de alvos, a uma série de comandos a serem executados quando a ação é solicitada. Por exemplo, um alvo comum de makefile é “clean”, que geralmente executa ações para fazer a limpeza após o compilador — removendo arquivos objeto e o executável resultante.

Usaremos scripts auxiliares do Make para agilizar o processo de implantação.
{% endhint %}

1. Atualize o sistema operacional.

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

2. Verifique se o make já está instalado.

```bash
make -version
```

3. Instale o pacote make.

```bash
sudo apt install make
```

4. Verifique a instalação.

```bash
ls /usr/bin/make
```

{% endtab %}
{% endtabs %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://academy.pentaho.com/pentaho-11-installation-en/pentaho-11-installation-pt-br/configuracao/pentaho-containers.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.