# Preparar o Ambiente

{% hint style="info" %}

#### **Preparar Ambiente**

Prepare seu servidor Ubuntu para uma instalação por Arquivo do Pentaho Server.

Este processo irá:

* Crie um `pentaho` usuário de instalação (com sudo)
* Definir caminhos do Pentaho - `$PENTAHO_BASE`
* Instalar Java 21 (OpenJDK)
* Definir `PENTAHO_JAVA_HOME`
* Instalar PostgreSQL 17 (15 suportado para Pentaho 11)
* Criar usuário de banco de dados do repositório - `pentaho` para configuração
* Instalar pgAdmin 4 (desktop)
  {% endhint %}

{% hint style="warning" %}
Base Linux suportada para Pentaho 11.x: Ubuntu 24.04 LTS.

Para versões e compatibilidade, veja [Referência de Componentes](https://docs.pentaho.com/install/pdia-11.0-installation/components-reference).
{% endhint %}

{% stepper %}
{% step %}
**Pré-requisitos**

1. Certifique-se de que unzip está instalado.

```bash
unzip --version
```

2. Defina as variáveis de caminho do Pentaho.
   {% endstep %}

{% step %}
**Crie um usuário de instalação do Pentaho**

{% hint style="danger" %}
Para produção, use uma conta de instalação dedicada com apenas os privilégios necessários e evite compartilhar credenciais.
{% endhint %}

1. Atualize os pacotes (execute uma vez):

```bash
sudo apt update -y && sudo apt upgrade -y
```

2. Adicione o usuário e defina uma senha:

```bash
sudo adduser pentaho
```

3. Conceda privilégios sudo:

```bash
sudo usermod -aG sudo pentaho
```

4. Valide o acesso:

```bash
su - pentaho
groups
sudo -v
```

{% endstep %}

{% step %}
**Instalar Java 21 (OpenJDK)**

{% hint style="info" %}
Pentaho 11.x é certificado com Java 21.
{% endhint %}

<details>

<summary>Qual é a diferença entre Oracle JDK e OpenJDK?</summary>

Oracle JDK e OpenJDK são ambas implementações da Plataforma Java, mas têm algumas diferenças importantes:

**Licenciamento e Custo:**

* **OpenJDK** é completamente livre e de código aberto sob a licença GPL. Você pode usá-lo para qualquer propósito sem restrições.
* **Oracle JDK** mudou seu modelo de licenciamento em 2019. Agora é gratuito para desenvolvimento e uso pessoal, mas requer uma assinatura paga para uso comercial em produção (Oracle Java SE Subscription).

**Fonte e Desenvolvimento:**

* **OpenJDK** é a implementação de referência do Java e serve de base para a maioria das distribuições JDK. A Oracle contribui de forma significativa para o desenvolvimento do OpenJDK.
* **Oracle JDK** é construído a partir do código-fonte do OpenJDK, mas inclui alguns componentes proprietários adicionais e recursos comerciais.

**Desempenho e Recursos:**

* Em versões modernas (Java 11+), as diferenças de desempenho são insignificantes. A Oracle retornou a maior parte de suas melhorias de desempenho para o OpenJDK.
* Historicamente, o Oracle JDK incluía algumas ferramentas e recursos adicionais (como Java Flight Recorder e Java Mission Control), mas muitos desses foram liberados como código aberto e agora estão disponíveis no OpenJDK.

**Suporte e Atualizações:**

* **OpenJDK** recebe suporte e atualizações da comunidade por cerca de 6 meses por lançamento (exceto versões LTS mantidas por vários fornecedores).
* **Oracle JDK** oferece Suporte de Longo Prazo (LTS) com assinaturas comerciais, fornecendo atualizações e patches de segurança por períodos estendidos.

**Outras Distribuições:** Muitos fornecedores oferecem suas próprias builds do OpenJDK com suporte de longo prazo, incluindo Amazon Corretto, Azul Zulu, Eclipse Temurin (antigo AdoptOpenJDK) e Red Hat OpenJDK.

Para a maioria dos desenvolvedores e organizações, o OpenJDK ou distribuições OpenJDK com suporte de fornecedores são a escolha recomendada, a menos que você precise especificamente do suporte comercial da Oracle.

</details>

1. Instalar Java 21:

```bash
sudo apt install -y openjdk-21-jre-headless
```

2. Verificar Java:

```bash
java -version
which java
readlink -f $(which java)
```

<figure><img src="/files/d342fd797f18b577674d2ecce34c6c3134d024a7" alt="Ubuntu apt installed OpenJDK versions list"><figcaption><p>Versões do OpenJDK</p></figcaption></figure>

<figure><img src="/files/93bca2b70f294c565745c8c8246eb07ec7526342" alt="java -version output showing Java 21"><figcaption><p>Java 21</p></figcaption></figure>

{% hint style="info" %}
Se várias versões do Java estiverem instaladas, selecione a padrão:

```bash
sudo update-alternatives --config java
```

{% endhint %}
{% endstep %}

{% step %}
**Definir `PENTAHO_JAVA_HOME`**

Definir `PENTAHO_JAVA_HOME` globalmente para que o Pentaho Server use consistentemente o Java 21.

1. Edite `/etc/environment`:

```bash
sudo nano /etc/environment
```

2. Adicione (ou atualize) a seguinte linha:

```bash
# set PENTAHO_JAVA_HOME
PENTAHO_JAVA_HOME=/usr/lib/jvm/java-21-openjdk-amd64
```

<figure><img src="/files/ac86416e971bcd0593a9f530b42eca149f6f5787" alt=""><figcaption><p>Definir PENTAHO_JAVA_HOME</p></figcaption></figure>

3. Salve e recarregue o ambiente (ou saia e entre novamente):

```bash
source /etc/environment
```

4. Verificar:

```bash
echo $PENTAHO_JAVA_HOME
```

***

{% hint style="info" %}
Alternativa: definir apenas para um único usuário em `~/.bashrc`.
{% endhint %}

1. Editar:

```bash
nano ~/.bashrc
```

2. Anexar e aplicar:

```bash
export PENTAHO_JAVA_HOME=/usr/lib/jvm/java-21-openjdk-amd64
. ~/.bashrc
```

{% endstep %}

{% step %}
**Instalar PostgreSQL 17**

{% hint style="info" %}
O repositório padrão do Ubuntu 24.04 fornece um PostgreSQL 16 mais novo. Para instalar o 17, adicione o repositório oficial do PostgreSQL (PGDG).

Se um PostgreSQL diferente já estiver presente, remova-o primeiro para evitar conflitos de porta e pacote (veja a guia opcional "Limpar instalações anteriores").

**Pré-requisitos**\
Ubuntu 24.04\
Privilégios de root ou acesso sudo\
use `sudo su` para entrar como root em vez de pentaho (usuário padrão)
{% endhint %}

{% tabs %}
{% tab title="Instalar PostgreSQL 17" %}

1. Antes de instalar o PostgreSQL, certifique-se de que seu sistema está atualizado.

```bash
sudo apt update && sudo apt upgrade -y
```

2. Instale pacotes pré-requisito.

```bash
sudo apt install -y wget ca-certificates
```

3. Importar chave GPG do PostgreSQL.

```bash
wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -
```

4. Adicionar Repositório do PostgreSQL

```bash
sudo sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
```

5. Atualizar Lista de Pacotes.

```bash
sudo apt update
```

6. Instalar pacotes do servidor e cliente PostgreSQL 17.

```bash
sudo apt update -y && sudo apt upgrade -y
sudo apt install -y postgresql-17 postgresql-contrib-17
```

{% hint style="info" %}
**O que é instalado:**

* `postgresql-17`: Servidor principal de banco de dados
* `postgresql-contrib-17`: Utilitários e extensões adicionais
  {% endhint %}

7. Verificar serviço e versão:

```bash
sudo systemctl status postgresql --no-pager
psql --version
```

<figure><img src="/files/513cdcd94281a72d3088e2221a8aeca334b26479" alt=""><figcaption><p>PostgreSQL 17.7</p></figcaption></figure>

8. Limpeza opcional:

```bash
sudo apt autoremove -y
```

{% endtab %}

{% tab title="Opcional: Instalar PostgreSQL 16" %}

1. Certifique-se de que seu sistema Ubuntu esteja atualizado.

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

2. Para auxiliar na instalação do software de banco de dados, instale os seguintes pacotes.

```bash
sudo apt install dirmngr ca-certificates software-properties-common apt-transport-https lsb-release curl -y
```

3. Importe a chave de assinatura do repositório.

```bash
sudo apt install curl ca-certificates gnupg
curl https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/apt.postgresql.org.gpg >/dev/null
```

4. Crie o arquivo de configuração do repositório.

```bash
echo "deb [signed-by=/etc/apt/trusted.gpg.d/apt.postgresql.org.gpg] http://apt.postgresql.org/pub/repos/apt/ noble-pgdg main" | sudo tee /etc/apt/sources.list.d/pgdg.list
```

5. Atualize sua lista de pacotes novamente para incluir o novo repositório.

```bash
sudo apt update
```

6. Agora, instale o pacote do servidor PostgreSQL 16.

```bash
sudo apt install -y postgresql-16 postgresql-client-16
psql --version
```

{% endtab %}

{% tab title="Opcional: Limpar instalações anteriores" %}
Se um PostgreSQL não suportado estiver instalado, remova-o primeiro. Execute cada comando separadamente e revise a saída:

```bash
sudo apt-get --purge remove postgresql
sudo apt-get purge postgresql*
sudo apt-get --purge remove postgresql postgresql-doc postgresql-common
sudo apt autoremove -y
```

Verifique pacotes residuais:

```bash
dpkg -l | grep -i postgres
```

{% endtab %}
{% endtabs %}

{% hint style="info" %}
Validação:

```bash
sudo systemctl is-enabled postgresql
sudo ss -ltnp | grep 5432 || true
sudo -u postgres psql -c "SELECT version();"
```

{% endhint %}
{% endstep %}

{% step %}
**Criar usuário de banco de dados - pentaho**

{% hint style="info" %}
Durante a instalação, o PostgreSQL cria um superusuário local `postgres`. Defina sua senha e (opcionalmente) crie um `pentaho` papel.
{% endhint %}

{% hint style="danger" %}
Para produção, evite um superusuário permanente para uso da aplicação. Use papéis com o menor privilégio e conceda apenas o necessário. O caminho do workshop abaixo eleva privilégios para simplificar a configuração.
{% endhint %}

1. Mude para o usuário do sistema postgres.

```bash
sudo -i -u postgres
```

2. Entre no terminal interativo do PostgreSQL.

```bash
psql
```

3. Você deverá ver o prompt do PostgreSQL:

```
postgres=#
```

4. Visualizar bancos de dados atuais.

```
\l
```

{% hint style="info" %}
Isso lista todos os bancos de dados. Você deverá ver três bancos padrão: postgres, template0 e template1.
{% endhint %}

5. Sair.

```sql
q
```

6. Verificar versão do PostgreSQL via SQL.

```sql
SELECT version();
```

7. Sair do Prompt do PostgreSQL.

<pre class="language-sql"><code class="lang-sql"><strong>\q
</strong></code></pre>

8. E sair do psql.

```sql
exit
```

***

**Criar usuário pentaho**

<figure><img src="/files/73617698cf0fd2f3502c872dc696aa0b05086f08" alt=""><figcaption></figcaption></figure>

1. Definir `postgres` senha:

```bash
sudo -u postgres psql -c "ALTER USER postgres WITH PASSWORD 'SecurePassword123';"
```

2. Crie um `pentaho` usuário e conceder `SUPERUSER` privilégios:

```sql
sudo -u postgres psql -c "CREATE USER pentaho WITH PASSWORD 'SecurePassword123';"
sudo -u postgres psql -c "ALTER USER pentaho WITH SUPERUSER;" # Apenas demonstração
```

{% hint style="info" %}

* `sudo -u postgres` - Execute o comando como o usuário do sistema Linux `postgres` (que tem acesso local ao PostgreSQL sem senha)
* `psql -c` - Executa um único comando SQL e sai
* `CREATE USER pentaho` - Cria um novo papel/usuário do PostgreSQL chamado `pentaho`
* `WITH PASSWORD 'SecurePassword123'` - Define a senha para este usuário

***

* `ALTER USER pentaho` - Modifica o `pentaho` usuário existente
* `WITH SUPERUSER` - Concede privilégios completos de superusuário (pode fazer qualquer coisa: criar bancos de dados, criar usuários, contornar todas as permissões, etc.)
* `# Apenas demonstração` - **Comentário de aviso** indicando que isto é perigoso para produção
  {% endhint %}

3. Testar conexão como `pentaho`:

```bash
sudo -u pentaho psql -d postgres -c "\conninfo"
```

{% endstep %}

{% step %}
**Opcional: Permitir conexões remotas**

{% hint style="info" %} <mark style="color:verde;">Apenas para referência, pois conectar ao Postgresql via localhost</mark>

Por padrão, o PostgreSQL aceita apenas conexões locais. Para configurações em localhost, você não precisa deste passo.
{% endhint %}

1. Faça backup das configs e edite `postgresql.conf` (PostgreSQL 17):

```bash
sudo cp /etc/postgresql/17/main/postgresql.conf{,.bak}
sudo nano /etc/postgresql/17/main/postgresql.conf
```

2. Defina: `listen_addresses = '*'` (uma interface/IP específico em produção)

<figure><img src="/files/6aab8b1f0a9c79805d593bdebcf5c78a6135c7d4" alt=""><figcaption><p>Definir listener</p></figcaption></figure>

3. Salvar:

```
Ctrl + o
Enter
Ctrl + x
```

{% endstep %}

{% step %}
**Configurar pg\_hba.conf**

{% hint style="info" %}
A **pg\_hba.conf** arquivo (configuração de Autenticação baseada em host do PostgreSQL) controla quem pode conectar ao seu banco de dados PostgreSQL e como eles se autenticam. Você o configura durante a instalação para definir regras de segurança para o acesso ao banco de dados.

Em produção, você modificaria as configurações para permitir apenas que os usuários necessários acessem os bancos de dados nos IPs dos servidores.
{% endhint %}

1. Configure o PostgreSQL para usar autenticação de senha md5 `pg_hba.conf` .

```bash
sudo cp /etc/postgresql/17/main/pg_hba.conf{,.bak}
sudo nano /etc/postgresql/17/main/pg_hba.conf
```

2. Edite o arquivo manualmente:

<figure><img src="/files/fcd4b93bf785d90067c7d710ff02bc925ef507da" alt=""><figcaption></figcaption></figure>

<mark style="color:$primary;">Ou</mark>

2. Execute o script a seguir.&#x20;

```bash
# Use o caminho exato
PG_HBA_PATH=/etc/postgresql/17/main/pg_hba.conf

# Verifique se o arquivo existe
ls -la "$PG_HBA_PATH"

# Se isso funcionar, então execute:
sudo cp "$PG_HBA_PATH" "${PG_HBA_PATH}.backup"
sudo sed -i 's/^local[[:space:]]\+all[[:space:]]\+postgres[[:space:]]\+peer$/local   all             postgres                                scram-sha-256/' "$PG_HBA_PATH"
sudo sed -i 's/^local[[:space:]]\+all[[:space:]]\+all[[:space:]]\+peer$/local   all             all                                     scram-sha-256/' "$PG_HBA_PATH"
sudo sed -i '0,/^host[[:space:]]\+all[[:space:]]\+all[[:space:]]\+127\.0\.0\.1\/32[[:space:]]\+scram-sha-256$/s//host    all             all             0.0.0.0\/0               md5/' "$PG_HBA_PATH"

# Verificar
sudo cat "$PG_HBA_PATH" | grep -E "^(local|host)[[:space:]]+(all|replication)"
```

<figure><img src="/files/f92b13fecbbabb40d529f12ce7e79a89cc2fb853" alt=""><figcaption><p>SED: pg_hba.conf</p></figcaption></figure>

{% hint style="info" %}
Preferir `scram-sha-256` em vez de `md5` em `pg_hba.conf` para hashing de senha mais forte em versões modernas do PostgreSQL.

Certifique-se de que seu driver JDBC suporta SCRAM (por exemplo, drivers PostgreSQL recentes). Se surgirem problemas de compatibilidade, use `md5` como alternativa.
{% endhint %}

3. Reinicie o serviço PostgreSQL.

```bash
cd
systemctl restart postgresql
# Senha: password
```

4. Permitir firewall (se habilitado) e reiniciar:

```bash
sudo ufw allow 5432/tcp || true
sudo systemctl restart postgresql
sudo ss -ltnp | grep 5432
```

{% endstep %}

{% step %}
**Instalar pgAdmin 4 (desktop)**

Instale o cliente desktop pgAdmin 4 usando o repositório oficial.

1. Adicionar repo e chave:

```bash
sudo install -d -m 0755 /etc/apt/keyrings
curl -fsS https://www.pgadmin.org/static/packages_pgadmin_org.pub | gpg --dearmor | sudo tee /etc/apt/keyrings/packages-pgadmin-org.gpg > /dev/null
source /etc/os-release
echo "deb [signed-by=/etc/apt/keyrings/packages-pgadmin-org.gpg] https://ftp.postgresql.org/pub/pgadmin/pgadmin4/apt/${UBUNTU_CODENAME} pgadmin4 main" | sudo tee /etc/apt/sources.list.d/pgadmin4.list
```

2. Instalar pgAdmin 4 (desktop):

```bash
sudo apt update -y && sudo apt upgrade -y
sudo apt install -y pgadmin4-desktop
```

3. Opcional: verificar entrada do repositório

```bash
cat /etc/apt/sources.list.d/pgadmin4.list
```

4. Adicione uma conexão de servidor no pgAdmin:

* Clique com o botão direito em Servers → Register → Server
* Nome: `Pentaho`
* Conexão: host, porta `5432`, usuário `pentaho`, senha `SecurePassword123` (não salve em produção)

<figure><img src="/files/87723c1e30dc044279ea522ef0dc09978754e777" alt="Create server group dialog in pgAdmin"><figcaption><p>Criar grupo de servidores</p></figcaption></figure>

<figure><img src="/files/d0080a2a20765e3eccda4303f2fe3175b9a325d7" alt="pgAdmin server group list"><figcaption><p>Grupo de servidores</p></figcaption></figure>

<figure><img src="/files/4967f372f9ea8824d8b4fa9adb6a5e95cdaffb6a" alt="pgAdmin new server connection dialog"><figcaption><p>Detalhes de conexão</p></figcaption></figure>

{% hint style="danger" %}
Não salve senhas em produção. Prefira keyrings do SO ou cofres seguros.
{% endhint %}

<figure><img src="/files/258baaef17120432606090262f90cd4626ea4176" alt="pgAdmin 4 main UI window"><figcaption><p>Interface do pgAdmin 4</p></figcaption></figure>
{% endstep %}

{% step %}
**Validar o ambiente**

1. Verificações rápidas para confirmar que tudo está pronto para o próximo passo.

```bash
# Java
java -version
[ "$PENTAHO_JAVA_HOME" = "/usr/lib/jvm/java-21-openjdk-amd64" ] && echo OK || echo "Verifique PENTAHO_JAVA_HOME"

# PostgreSQL
sudo -u postgres psql -c "SELECT version();"
sudo systemctl status postgresql --no-pager | sed -n '1,5p'

```

<figure><img src="/files/7b3feba10ffc2ff180a44f2fa3361411dd4c0af2" alt=""><figcaption><p>Validar serviço do PostgreSQL 17 ..</p></figcaption></figure>
{% endstep %}
{% endstepper %}

***


---

# 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/instalacao/archive-installation/prepare-environment.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.