> 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/archive-installation/prepare-environment.md).

# Preparar o Ambiente

{% hint style="info" %}

#### **Preparar o Ambiente**

Prepare seu servidor Ubuntu para uma instalação do Pentaho Server a partir de um arquivo compactado.

Este processo irá:

* Crie uma `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 compatível com o Pentaho 11)
* Criar usuário do banco de dados do repositório - `pentaho` para a configuração
* Instalar pgAdmin 4 (desktop)
  {% endhint %}

{% hint style="warning" %}
Base Linux compatível para o 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 o unzip esteja instalado.

```bash
unzip --version
```

2. Defina as variáveis de caminho do Pentaho.

{% hint style="info" %}
Use estas variáveis para simplificar comandos e evitar erros de caminho. Considere adicioná-las ao perfil do seu shell para facilitar.
{% endhint %}

* Edite o arquivo /etc/environment.

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

* Adicione os seguintes caminhos.

```bash
# Caminhos do Pentaho
PENTAHO_BASE=/opt/pentaho
PENTAHO_SERVER=/opt/pentaho/server/pentaho-server
TOMCAT_HOME=/opt/pentaho/server/pentaho-server/tomcat
```

{% hint style="warning" %}
Se você adicioná-los a `~/.bashrc` ou `/etc/environment`, reabra seu shell ou `source` o arquivo para aplicar.
{% endhint %}

<figure><img src="/files/367b79566331bba4fb24970da829c8eb5b6258e5" alt=""><figcaption><p>Caminhos do Pentaho</p></figcaption></figure>
{% endstep %}

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

{% hint style="danger" %}
Em 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. Validar acesso:

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

{% endstep %}

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

{% hint style="info" %}
O 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** é totalmente gratuito e de código aberto sob a licença GPL. Você pode usá-lo para qualquer finalidade sem restrições.
* **Oracle JDK** mudou seu modelo de licenciamento em 2019. Agora é gratuito para desenvolvimento e uso pessoal, mas exige 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 como base para a maioria das distribuições JDK. A própria Oracle contribui significativamente 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 desprezíveis. A Oracle contribuiu com a maioria de suas melhorias de desempenho de volta para o OpenJDK.
* O Oracle JDK historicamente incluía algumas ferramentas e recursos adicionais (como Java Flight Recorder e Java Mission Control), mas muitos deles se tornaram código aberto e agora estão disponíveis no OpenJDK.

**Suporte e atualizações:**

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

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

Para a maioria dos desenvolvedores e organizações, o OpenJDK ou distribuições do OpenJDK com suporte do fornecedor são a escolha ideal, 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. Verifique o 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
# definir 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. Verifique:

```bash
echo $PENTAHO_JAVA_HOME
```

***

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

1. Editar:

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

2. Acrescente e aplique:

```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 recente. Para instalar o 17, adicione o repositório oficial do PostgreSQL (PGDG).

Se já houver outro PostgreSQL instalado, remova-o completamente primeiro para evitar conflitos de porta e de pacotes (veja a aba 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 esteja atualizado.

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

2. Instale os pacotes pré-requisitos.

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

3. Importe a chave GPG do PostgreSQL.

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

4. Adicionar o 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. Atualize a lista de pacotes.

```bash
sudo apt update
```

6. Instale os pacotes do servidor e do 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. Verifique o serviço e a 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 ajudar 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 novamente sua lista de pacotes 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 houver um PostgreSQL sem suporte instalado, remova-o completamente 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 do 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" %}
Em produção, evite um superusuário permanente para uso da aplicação. Use funções com o menor privilégio possível e conceda apenas o que for necessário. O caminho de workshop abaixo eleva os 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. Veja os bancos de dados atuais.

```
\l
```

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

5. Saia.

```sql
q
```

6. Verifique a versão do PostgreSQL via SQL.

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

7. Saia do prompt do PostgreSQL.

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

8. E saia 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 uma `pentaho` usuário e conceda `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` - Execute um único comando SQL e saia
* `CREATE USER pentaho` - Cria uma nova função/usuário do PostgreSQL chamada `pentaho`
* `WITH PASSWORD 'SecurePassword123'` - Define a senha para este usuário

***

* `ALTER USER pentaho` - Modifica o `pentaho` usuário
* `WITH SUPERUSER` - Concede privilégios completos de superusuário (pode fazer qualquer coisa: criar bancos de dados, criar usuários, ignorar todas as permissões etc.)
* `# Apenas demonstração` - **Comentário de aviso** indicando que isso é 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, ao conectar ao PostgreSQL via localhost</mark>

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

1. Faça backup das configurações 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ífica 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 %}
**Configure pg\_hba.conf**

{% hint style="info" %}
A **pg\_hba.conf** o arquivo (configuração de autenticação baseada em host do PostgreSQL) controla quem pode se 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 acesso ao banco de dados.

Em produção, você modificaria as configurações para permitir acesso aos bancos de dados nos IPs do servidor apenas para os usuários necessários.
{% 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.

```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"

# Verifique
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" %}
Prefira `scram-sha-256` em vez de `md5` em `pg_hba.conf` para um hash de senha mais forte em versões modernas do PostgreSQL.

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

3. Reinicie o serviço PostgreSQL.

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

4. Permita no firewall (se estiver habilitado) e reinicie:

```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 de desktop pgAdmin 4 usando o repositório oficial.

1. Adicione o repositório e a 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 da conexão</p></figcaption></figure>

{% hint style="danger" %}
Não salve senhas em produção. Prefira chaveiros do nível do sistema operacional 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 a próxima etapa.

```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 PostgreSQL 17 ..</p></figcaption></figure>
{% endstep %}
{% endstepper %}

***


---

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