# Contêineres Pentaho

{% hint style="info" %}

#### Contêineres Pentaho

O servidor Pentaho oferece opções de implantação flexíveis para atender a uma variedade de estratégias de infraestrutura. Para **on-premises** 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 (hiperescala)** implantações, o Pentaho fornece imagens Docker pré-construídas e otimizadas, concebidas 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 de entrypoint aprimorados que suportam 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, onde as organizações podem executar o servidor Pentaho on-premises para cargas de trabalho sensíveis enquanto implantam contêineres do servidor Carte ou nós worker do PDI na nuvem para lidar com processamento burst, mesclando o controle da infraestrutura local com a elasticidade dos recursos em nuvem.
{% endhint %}

{% hint style="danger" %}
Os passos a seguir destinam-se à configuração de um ambiente Pentaho Lab e precisam ser concluídos 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 aplicações e suas dependências em contêineres leves e portáteis. Contêineres garantem que as aplicações sejam executadas de forma consistente em diferentes ambientes de computação, desde laptops de desenvolvimento até servidores de produção. Este workshop irá guiá-lo 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 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 do 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 do Docker foi adicionado, atualize o índice de pacotes.

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

6. Instale o Docker Engine, containerd e 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 checando a versão.

```bash
docker --version
```

Você deverá ver uma saída similar a (Nov 2025):

```
Versão do Docker 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 bem-sucedido, 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 de grupo (ou faça logout e login novamente).

```bash
newgrp docker
```

3. Verifique se você pode executar Docker sem sudo.

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

4. Garanta que o Docker seja iniciado automaticamente quando o sistema inicializar.

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

***

{% hint style="info" %}

#### Verificação & Testes

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

Verificar versão do Docker:

```bash
docker version
```

Visualizar informações do sistema Docker:

```bash
docker info
```

Listar contêineres em execução:

```bash
docker ps
```

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

```bash
docker ps -a
```

Listar imagens baixadas:

```bash
docker images
```

***

{% hint style="info" %}

#### Comandos Comuns

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

* `docker pull <image>` - Baixar uma imagem do Docker Hub
* `docker images` - Listar todas as imagens locais
* `docker run <image>` - Criar e iniciar um contêiner a partir de uma imagem
* `docker ps` - Listar contêineres em execução
* `docker ps -a` - Listar todos os contêineres
* `docker stop <container>` - Parar um contêiner em execução
* `docker rm <container>` - Remover um contêiner parado
* `docker rmi <image>` - Remover uma imagem
* `docker logs <container>` - Visualizar logs do contêiner
* `docker exec -it <container> bash` - Acessar 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 computação de borda. Ela é empacotada como um único binário ou imagem de contêiner mínima, tornando-a significativamente mais fácil de implantar e gerenciar do que o Kubernetes padrão. A distribuição usa SQLite3 como seu datastore leve padrão, embora também suporte etcd3, MySQL e Postgres para usuários que precisam de opções mais robustas.

A plataforma simplifica as operações do Kubernetes agrupando 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 montagens de cgroup para executar.

O K3s vem "com tudo incluso" com componentes essenciais pré-empacotados, eliminando a necessidade de instalação e configuração separadas. Isso inclui containerd para runtime de contêineres, 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 borda, 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 pacotes que permitem ao apt usar repositórios via HTTPS.

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

3. Desative a swap (recomendado para Kubernetes).

```bash
# Desativar swap imediatamente
sudo swapoff -a

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

# Verificar se a swap está desativada
free -h | grep Swap
```

4. Ativar 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. Configurar Firewall.

```bash
# Verificar 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:

{% hint style="info" %}

{% endhint %}

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

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

{% endhint %}

1. Verifique os requisitos do sistema.

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

2. Instalar K3s.

```bash
# Instalar servidor K3s (inclui 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 (plugin de rede CNI)
- CoreDNS (DNS do cluster)
- Traefik (controlador de ingress)
- Provisionador local-path (armazenamento)
- Metrics server
```

{% endhint %}

2. Configurar acesso ao kubectl.

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

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

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

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

# Testar acesso ao kubectl
kubectl version --short
```

4\. Verificar Instalação

```bash
# Verificar status dos nós
kubectl get nodes

# Saída esperada:
# NAME         STATUS   ROLES                  AGE   VERSION
NAME      STATUS   ROLES           AGE     VERSION
pentaho   Ready    control-plane   5d20h   v1.34.3+k3s1

# Verificar pods do sistema
kubectl get pods -A
```

<figure><img src="/files/d7f185e9e83da3ed97ef37331742d7626a39abc2" alt=""><figcaption><p>Verificar 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ó Servidor (Plano de Controle)

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

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

#### Nós Agentes (Workers)

Em cada nó worker:

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

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

#### Verificar Cluster Multi-Nó

No nó servidor:

```bash
kubectl get nodes

# Saída esperada:
# NAME         STATUS   ROLES                  AGE   VERSION
# server-01    Ready    control-plane,master   5m    v1.29.0+k3s1
# worker-01    Ready    <none>                 2m    v1.29.0+k3s1
# worker-02    Ready    <none>                 1m    v1.29.0+k3s1
```

{% endtab %}

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

1. Adicione aliases úteis.

```bash
# Adicionar 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'

# Habilitar 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. Verificar Classe de Armazenamento Padrão

```bash
# Verificar storage class
kubectl get storageclass
```

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

2. Configurar Ingress do Traefik

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

3. Instalar Helm (Opcional, mas Recomendado)

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

# Verificar
helm version
```

4\. Instalar k9s (Opcional - UI no Terminal)

```bash
# Instalar k9s para gerenciamento de cluster mais fácil
curl -sS https://webinstall.dev/k9s | bash

# Executar k9s
k9s
```

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

5\. Verificar Instalação do K3s.

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

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

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

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

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

#### Charts do Helm

Helm é o gerenciador de pacotes para Kubernetes, frequentemente referido como "apt/yum para Kubernetes." Ele simplifica a implantação e o gerenciamento de aplicações Kubernetes por meio de:

**Empacotamento**: Agrupar recursos relacionados do Kubernetes

**Template**: Parametrizar manifests para reutilização entre ambientes

**Versionamento**: Gerenciar versões e atualizações de aplicações

**Gerenciamento de Releases**: Rastrear implantações e permitir rollback
{% 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>Instalar Helm</p></figcaption></figure>

ou

1. Adicione a chave GPG do Helm.

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

2. Instalar dependências

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

3. Adicionar repositório do Helm.

```bash
# Adicionar o repositório do 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
# Atualizar lista de pacotes:
sudo apt-get update

# instalar Helm:
sudo apt-get install helm
```

5. Verificar instalação.

```sh
# Verificar Instalação do Helm:
helm version --client
```

***

**Comandos do Helm**

```bash
# Verifica seu chart do Helm em busca de problemas antes de implantar.
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 realmente implantá-lo, permitindo verificar mudanças.
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 manutenção e atualização de aplicações.
helm --help

# Lista todas as releases do Helm no namespace atual, útil para rastrear aplicações implantadas.
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 retornar a um estado estável se uma atualização causar problemas.
helm rollback RELEASE_NAME REVISION

# Adiciona um repositório de charts do 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 do Helm em um arquivo .tgz, que pode ser compartilhado ou enviado a um repositório.
helm package CHART_PATH

# Envia um chart empacotado para um repositório Helm, facilitando a distribuição e 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 para projetos pessoais.
{% endhint %}

1. A opção mais simples é baixar e instalar a partir do Snapstore.

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

Ou

Vá para a 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. Fixar o DBeaver no Dash - barra de ferramentas inferior.
   {% endtab %}

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

#### Make

Um makefile é simplesmente uma forma de associar nomes curtos, chamados targets, a uma série de comandos a executar quando a ação é solicitada. Por exemplo, um target comum de makefile é “clean”, que geralmente executa ações que limpam após o compilador - removendo arquivos objeto e o executável resultante.

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

1. Atualizar 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: 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/configuracao/conteineres-pentaho.md?ask=<question>
```

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.