> ## Documentation Index
> Fetch the complete documentation index at: https://docs.vertracloud.app/llms.txt
> Use this file to discover all available pages before exploring further.

# PostgreSQL, MongoDB, Redis e MySQL gerenciados na Vertra Cloud

> A Vertra Cloud roda quatro motores de banco gerenciados, com TLS obrigatório, certificados gerados automaticamente, snapshots e uma aba Dados no navegador.

## O que é um banco de dados gerenciado na Vertra Cloud?

Um banco de dados gerenciado na Vertra Cloud é uma instância de PostgreSQL, MongoDB, Redis ou MySQL que a
plataforma provisiona, protege e monitora para você: o TLS é obrigatório, os certificados de CA, servidor
e cliente são gerados automaticamente, e cada banco roda no próprio container, com memória e
armazenamento dedicados.

## Quais motores de banco estão disponíveis?

Quatro: PostgreSQL (18 ou 17), MongoDB (8.0 ou 9.0), Redis (8.2 ou 7.2) e MySQL (9.7 ou 8.4). Você escolhe
a versão ao criar o banco, e a recomendada é a padrão. Todos os motores exigem TLS **e um certificado de
cliente** — só a senha nunca conecta.

> **PostgreSQL 18 / 17**
>
> Banco relacional com SQL completo, suporte a JSONB e extensões.
>
> **Usuário**: `vertracloud`  |  **Banco de dados**: `vertracloud`  |  **Autenticação**: senha + certificado de cliente

> **MongoDB 8.0 / 9.0**
>
> Banco NoSQL orientado a documentos, para dados flexíveis.
>
> **Usuário**: `vertracloud`  |  **Banco de dados**: `vertracloud`  |  **Banco de autenticação**: `admin`  |  **Autenticação**: senha + certificado de cliente

> **Redis 8.2 / 7.2**
>
> Armazenamento em memória para cache de alto desempenho, filas e pub/sub.
>
> **Usuário**: `vertracloud`  |  **Autenticação**: usuário + senha + certificado de cliente

> **MySQL 9.7 / 8.4**
>
> Banco relacional popular, com transações ACID e um grande ecossistema.
>
> **Usuário**: `vertracloud`  |  **Banco de dados**: `vertracloud`  |  **Autenticação**: senha + certificado de cliente X509

## Com qual usuário eu me conecto?

Bancos criados a partir da [v26.4.8](https://docs.vertracloud.app/pt-br/changelog/v26-4-8.md) recebem o usuário `vertracloud` e um banco
padrão chamado `vertracloud`. Ele é dono dos seus dados e, dependendo do motor, pode criar bancos e papéis
(PostgreSQL), usar todos os bancos (MongoDB) ou executar todos os comandos de dados (Redis). Como em outros
serviços de banco gerenciado, a administração no nível do servidor (configurações do servidor, usuários
administradores, backups e restaurações) fica a cargo da plataforma.

Bancos criados antes disso mantêm o usuário padrão do motor: `postgres` (banco `postgres`) no PostgreSQL,
`default` no MongoDB e no Redis, e `root` (banco `default`) no MySQL. O campo `username` em
[Obter banco de dados](https://docs.vertracloud.app/api-reference/endpoint/databases/get.md) sempre indica qual usar.

## O que preciso para me conectar?

São quatro itens, todos na página do banco no painel (ou pela API):

* **Host** — `<id-do-banco-sem-hifens>.db.usa1.vertraweb.app`, mostrado na página do banco e em
  [Obter banco de dados](https://docs.vertracloud.app/api-reference/endpoint/databases/get.md).
* **Porta** — **única por banco**, não a porta padrão do motor (5432, 27017, 6379, 3306). Sempre copie-a da
  página do banco ou da resposta da API.
* **Usuário** — `vertracloud` (ou o usuário do motor, em bancos mais antigos), mostrado na página do banco e
  como `username` em [Obter banco de dados](https://docs.vertracloud.app/api-reference/endpoint/databases/get.md).
* **Senha** — mostrada na página do banco; [redefina-a](https://docs.vertracloud.app/api-reference/endpoint/databases/credentials/resetpassword.md)
  se necessário.
* **Certificados** — baixe-os na aba **Certificados** do banco ou pelo
  [Obter certificado do banco de dados](https://docs.vertracloud.app/api-reference/endpoint/databases/credentials/get.md):

| Arquivo | O que é | Use como |
| - | - | - |
| `certificate-<id>.crt` | Seu certificado de cliente | certificado de cliente (`cert`, `sslcert`, `--cert`) |
| `certificate-<id>.key` | Sua chave privada de cliente | chave de cliente (`key`, `sslkey`, `--key`) |
| `certificate-<id>.pem` | Pacote: chave de cliente + certificado de cliente + a CA que assina o servidor | arquivo de CA (`ca`, `sslrootcert`, `--cacert`) e, no MongoDB, o arquivo de certificado com chave |

O certificado do servidor corresponde ao host do banco, então a verificação completa (`verify-full`,
`VERIFY_IDENTITY`, `rejectUnauthorized: true`) funciona. Mantenha os arquivos `.key` e `.pem` privados — eles
autenticam como você. [Redefinir os certificados](https://docs.vertracloud.app/api-reference/endpoint/databases/credentials/reset.md)
emite novos certificados e invalida os arquivos antigos.

## Como me conecto a cada motor?

Nos exemplos, `<host>`, `<port>` e `<password>` vêm da página do banco; o usuário e o banco são
`vertracloud` (troque pelo `username` do seu banco se ele foi criado antes da v26.4.8); e
`certificate.crt` / `certificate.key` / `certificate.pem` são os três arquivos baixados.

**PostgreSQL**

```javascript Node.js (pg) theme={null}
const { Pool } = require('pg');
const fs = require('fs');

const pool = new Pool({
  host: '<host>',
  port: <port>,
  user: 'vertracloud',
  password: '<password>',
  database: 'vertracloud',
  ssl: {
    ca: fs.readFileSync('certificate.pem'),
    cert: fs.readFileSync('certificate.crt'),
    key: fs.readFileSync('certificate.key'),
    rejectUnauthorized: true,
  },
});
```

```python Python (psycopg) theme={null}
import psycopg

conn = psycopg.connect(
    host="<host>", port=<port>, user="vertracloud", password="<password>", dbname="vertracloud",
    sslmode="verify-full", sslrootcert="certificate.pem",
    sslcert="certificate.crt", sslkey="certificate.key",
)
```

```bash psql theme={null}
psql "host=<host> port=<port> dbname=vertracloud user=vertracloud password=<password> sslmode=verify-full sslrootcert=certificate.pem sslcert=certificate.crt sslkey=certificate.key"
```

**MongoDB**

O usuário fica no banco `admin`, então a URI sempre precisa de `authSource=admin`.

```javascript Node.js (mongodb) theme={null}
const { MongoClient } = require('mongodb');

const client = new MongoClient('mongodb://vertracloud:<password>@<host>:<port>/vertracloud?authSource=admin', {
  tls: true,
  tlsCAFile: 'certificate.pem',
  tlsCertificateKeyFile: 'certificate.pem',
});
```

```bash mongosh theme={null}
mongosh "mongodb://vertracloud:<password>@<host>:<port>/vertracloud?authSource=admin" --tls --tlsCAFile certificate.pem --tlsCertificateKeyFile certificate.pem
```

**Redis**

```javascript Node.js (ioredis) theme={null}
const Redis = require('ioredis');
const fs = require('fs');

const redis = new Redis({
  host: '<host>',
  port: <port>,
  username: 'vertracloud',
  password: '<password>',
  tls: {
    servername: '<host>',
    ca: fs.readFileSync('certificate.pem'),
    cert: fs.readFileSync('certificate.crt'),
    key: fs.readFileSync('certificate.key'),
  },
});
```

```bash redis-cli theme={null}
redis-cli -h <host> -p <port> --user vertracloud -a <password> --tls --cacert certificate.pem --cert certificate.crt --key certificate.key
```

**MySQL**

```javascript Node.js (mysql2) theme={null}
const mysql = require('mysql2/promise');
const fs = require('fs');

const connection = await mysql.createConnection({
  host: '<host>',
  port: <port>,
  user: 'vertracloud',
  password: '<password>',
  database: 'vertracloud',
  ssl: {
    ca: fs.readFileSync('certificate.pem'),
    cert: fs.readFileSync('certificate.crt'),
    key: fs.readFileSync('certificate.key'),
  },
});
```

```bash mysql theme={null}
mysql -h <host> -P <port> -u vertracloud -p vertracloud --ssl-mode=VERIFY_IDENTITY --ssl-ca=certificate.pem --ssl-cert=certificate.crt --ssl-key=certificate.key
```

> [!WARNING]
>
> Uma conexão só com a senha — ou com TLS mas sem o certificado de cliente — é recusada por todos os motores.
> A maioria dos erros "connection refused" ou "handshake failed" vem de um `.crt`/`.key` ausente ou da porta
> padrão do motor usada no lugar da porta do próprio banco.

## Ciclo de vida

```mermaid theme={null}
stateDiagram-v2
    [*] --> Creating: create database
    Creating --> Online: ready
    Online --> Stopped: stop
    Online --> Error: failure
    Stopped --> Online: start
    Error --> Online: restart
```

| Estado | Descrição | Indicador |
| - | - | :-: |
| **Criando** | Container sendo provisionado com os certificados TLS | ↻ |
| **Online** | Banco em execução e aceitando conexões | ● |
| **Parado** | Parado manualmente (dados preservados) | ○ |
| **Erro** | Problema durante a inicialização ou a execução | ! |

## Operações disponíveis

> **Iniciar / Parar / Reiniciar**
>
> Controla o ciclo de vida do container. Os dados são preservados ao parar ou reiniciar.

> **Resetar**
>
> Apaga todos os dados e recria o banco do zero. **Ação irreversível.**

> **Redefinir senha**
>
> Gera uma nova senha aleatória e segura para o banco.

> **Redefinir certificados**
>
> Regenera todos os certificados TLS (CA, servidor e cliente).

> **Baixar snapshot**
>
> Baixa uma cópia dos dados do banco.

> **Restaurar snapshot**
>
> Restaura o banco a partir de um snapshot anterior.

> [!WARNING]
>
> A operação **Resetar** é destrutiva e apaga todos os dados do banco. Essa ação não pode ser desfeita.

## Métricas

O painel exibe métricas em tempo real para cada banco:

> **CPU**
>
> Uso de CPU do container.

> **Memória**
>
> Consumo atual de RAM.

> **Armazenamento**
>
> Espaço em disco usado vs. a cota.

## Armazenamento

O armazenamento dos bancos tem limites rígidos aplicados no nível do container, o que garante que um banco
não consuma mais espaço do que o alocado.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.