# Postgres em produção

Checklist de postgres em produção: limite de conexões, transações longas, índices, vacuum e um backup postgres que você já restaurou.

Canonical URL: https://unbroker.cloud/pt/blog/postgres-in-production
Published: 2026-10-30
Reviewed: 2026-10-30
Author: Unbroker

## A resposta curta

Antes de usuários reais, encaixe as conexões do app no limite do servidor, corte transações que ficam abertas, coloque primary key e indexe as foreign keys pelas quais você altera, acompanhe o vacuum e restaure um backup pelo menos uma vez.

Isso é o que quebra primeiro um Postgres em produção. Não é falta de CPU. Os controles abaixo são a mesma lista que o health card do Postgres gerenciado lê nas estatísticas do Postgres. Como conectar o app está em [conectar uma API ao PostgreSQL](https://unbroker.cloud/solutions/api-with-postgres) e nos [detalhes de conexão](https://docs.unbroker.cloud/databases/connect).

## Postgres que você opera e Postgres gerenciado

Alguém tem que operar o host, e alguém tem que ser dono do schema. Não é o mesmo trabalho. [Rodar Postgres no seu próprio servidor Linux](https://unbroker.cloud/pt/servidores-cloud) significa que você aplica os patches dessa máquina e que a recuperação desse disco é sua. Se você está saindo do Railway, a [alternativa ao Railway](https://unbroker.cloud/pt/alternativas/railway) é a comparação.

### Um nó de banco que você opera

Um nó Postgres de Apps é um serviço privado: uma imagem de banco, um volume e uma conexão que outros serviços do projeto usam. Você cuida das atualizações do motor e da recuperação desse volume. O template de Postgres é um desses. Bancos novos desse template usam a imagem oficial do Postgres 16 com pgvector. O `CREATE EXTENSION vector;` é você quem roda. Não é um cluster gerenciado.

### Um cluster que o provedor opera

Um cluster gerenciado é um PostgreSQL que o provedor opera. Você continua dono dos schemas, das queries, das credenciais e do plano de recuperação que testa. Na Unbroker ele exige Pro. O menor plano do catálogo é 1 vCPU, 1 GB de RAM e 10 GB de armazenamento, até 30 GB nesse plano, a $21.21 por mês. O armazenamento extra de um plano custa $0.30 por GB ao mês. O Pro em si custa $25 por mês com $25 de crédito de uso, e o preço do cluster é separado. O Free não inclui bancos gerenciados. O plano de 1 GB de RAM é um único nó. Nós de standby exigem um plano de pelo menos 2 GB de RAM.

<aside class="plan-box">
<p><strong>Na Unbroker.</strong> Na criação você escolhe Postgres gerenciado ou um nó de Apps. Leia o preço cotado antes de confirmar. Os planos e a regra do nó estão em <a href="/managed-databases/postgres">Postgres gerenciado</a>.</p>
</aside>

## 1. Conexões: o limite que estoura primeiro

O PostgreSQL usa um processo de backend para cada conexão de cliente. O postmaster cria esse processo quando o cliente conecta. `max_connections` é o teto de conexões simultâneas. O default costuma ser 100, e pode ser menor se o kernel não aguentava 100 quando o diretório de dados foi inicializado. Só dá para mudar na partida do servidor.

Clientes comuns não usam todas as vagas. `superuser_reserved_connections` tem default 3. Quando as conexões ativas chegam a `max_connections` menos essa reserva, conexões novas só são aceitas para superusuários.

Cada cópia no ar do app abre os próprios clientes. Multiplique as conexões de uma cópia pela quantidade de cópias que rodam ao mesmo tempo. Some migrações, sessões de admin e um pooler se você usar um. Esse total tem que caber no limite. Este texto não escolhe um tamanho de pool. O número certo é o que ainda cabe. O exemplo de Express no guia de Node.js fixa o max do pool em 5 e diz que três réplicas com esse pool podem abrir quinze conexões, antes de jobs e ferramentas de administração. O processo em volta desse pool está em [Express em produção](https://unbroker.cloud/pt/blog/express-in-production).

Esse é o limite de conexões do Postgres que as pessoas encontram quando o servidor não aceita mais um cliente comum.

### Quando somar o PgBouncer

Some um pooler quando muitos processos do app segurariam uma conexão de servidor durante todo o tempo em que ficam conectados. O [PgBouncer](https://www.pgbouncer.org/features.html) tem três modos. Session pooling, o [default](https://www.pgbouncer.org/config.html), guarda a conexão de servidor até o cliente desconectar e suporta as funções de sessão do PostgreSQL. Transaction pooling devolve a conexão quando a transação termina, e quebra funções de sessão como `SET`, `LISTEN`, `PREPARE`, advisory locks de sessão e tabelas temporárias que preservam linhas. Statement pooling também não permite transações com mais de um statement. Use transaction pooling só se o app não precisa dessas funções de sessão.

<aside class="plan-box">
<p><strong>Na Unbroker.</strong> O health card mostra as conexões em uso contra o máximo. Ele lê estatísticas do Postgres, não as suas linhas. Ele não define <code>max_connections</code> para você.</p>
</aside>

## 2. Transações que ficam abertas

Um `UPDATE` ou um `DELETE` deixa a versão antiga da linha até que nenhuma transação ainda possa vê-la. Vacuum é o que recupera esse espaço. Uma transação que continua aberta mantém essas versões antigas interessantes, então o vacuum ainda não pode tratá-las como lixo. O guia de wraparound do PostgreSQL pede para encerrar transações abertas que estão longas, e achá-las em `pg_stat_activity` onde `age(backend_xid)` ou `age(backend_xmin)` é grande.

`xact_start` é o momento em que a transação atual começou, ou null se não há uma ativa. O `state` `idle in transaction` significa que a sessão está dentro de uma transação e não está rodando uma consulta.

```sql
SELECT pid, state, xact_start
FROM pg_stat_activity
WHERE xact_start IS NOT NULL
ORDER BY xact_start;
```

`statement_timeout` aborta um statement que demora mais que o limite. `idle_in_transaction_session_timeout` encerra uma sessão que fica idle dentro de uma transação aberta. Os dois têm default 0, que desliga o timeout. O PostgreSQL diz para não colocar `statement_timeout` no `postgresql.conf`, porque esse valor valeria para todas as sessões.

<aside class="plan-box">
<p><strong>Na Unbroker.</strong> O health card marca transações longas. Ele não escolhe um timeout por você. O Postgres self-hosted também tem uma aba Data somente leitura: você pode paginar linhas, e olhar não pode travar nem alterar os dados.</p>
</aside>

## 3. Erros de schema que doem depois

Uma chave que falta não impede o primeiro insert. Ela aparece quando alguma coisa precisa achar a linha de novo, ou quando um delete precisa procurar na outra tabela.

### Tabelas sem primary key

Declarar uma primary key cria um índice B-tree único nessas colunas e as força a `NOT NULL`. O PostgreSQL usa essa chave como destino default das foreign keys que apontam para a tabela. Um cliente que edita linhas em geral precisa dela para distinguir as linhas. O banco não obriga você a declarar uma.

### Foreign keys sem índice

Uma foreign key tem que apontar para uma primary key, uma restrição unique ou colunas de um índice unique que não seja parcial, então o lado referenciado já tem índice. As colunas que referenciam não ganham um índice sozinhas. Um `DELETE` ou um `UPDATE` da linha referenciada varre a tabela que referencia atrás de coincidências. Indexe essas colunas quando essa varredura importa. A declaração pula o índice porque nem sempre é necessário, e porque o índice é você quem escolhe.

<aside class="plan-box">
<p><strong>Na Unbroker.</strong> O health card marca tabelas sem primary key e foreign keys sem índice. Corrigir isso é uma mudança de schema que você roda. O cartão não cria o índice.</p>
</aside>

## 4. Vacuum atrasado

Vacuum recupera versões mortas de linhas para a tabela não crescer sem limite. Um `VACUUM` comum marca o espaço para reuso. Ele não devolve esse espaço ao sistema operacional, salvo num caso estreito. `VACUUM FULL` reescreve a tabela e precisa de um lock exclusivo. O autovacuum nunca roda `VACUUM FULL`. Ele tenta passar vacuum com frequência suficiente para você não precisar de um. A documentação diz que não é prudente desligar o daemon, a menos que a carga seja extremamente previsível, porque uma rajada de updates pode inchar a tabela até que `VACUUM FULL` seja o jeito de recuperar o espaço.

`n_dead_tup` é uma estimativa de linhas mortas. `last_autovacuum` é a última vez que o daemon de autovacuum rodou vacuum nessa tabela. Use os dois. Uma tabela quieta pode ter `last_autovacuum` vazio sem estar em apuros.

```sql
SELECT relname, n_dead_tup, last_autovacuum
FROM pg_stat_user_tables
ORDER BY n_dead_tup DESC;
```

<aside class="plan-box">
<p><strong>Na Unbroker.</strong> O health card marca tabelas atrasadas no vacuum. Ele usa essas estatísticas. Ele não muda a configuração do autovacuum.</p>
</aside>

## 5. Backups que você já restaurou

`pg_dump` escreve um dump que pode recriar o banco como ele estava quando o dump começou. Um dump de texto é recarregado com `psql`. Um dump em formato custom é restaurado com `pg_restore`. O dump é um snapshot do início do `pg_dump`, e não bloqueia o trabalho comum, salvo operações que precisam de um lock exclusivo. Não é uma cópia em nível de arquivo do diretório de dados. Depois de um restore SQL, o PostgreSQL pede para rodar `ANALYZE` para o planner ter estatísticas.

Guarde o dump em outro lugar que não seja o único disco do banco. Depois carregue-o uma vez antes do lançamento. Um arquivo que você nunca restaurou é uma esperança. Esse é o backup postgres que importa.

Um rollback de código não devolve as linhas. Esse corte está em [backups e rollback de um app feito com IA](https://unbroker.cloud/pt/blog/ai-built-app-to-production). Onde a migração roda, e por que um rollback deixa o schema no lugar, está em [migrações de banco de dados no deploy](https://unbroker.cloud/pt/blog/database-migrations-on-deploy). O que muda quando essa app é Django, com `DEBUG`, `ALLOWED_HOSTS` e um servidor de produção no lugar do `runserver`, está em [Django em produção](https://unbroker.cloud/pt/blog/django-in-production).

<aside class="plan-box">
<p><strong>Na Unbroker.</strong> Num cluster gerenciado, backup e restore dependem do motor e do plano. Não há uma única promessa de recuperação para todos os clusters. Teste um restore antes de tratá-lo como produção. Um nó de Apps guarda os dados no volume. Backups de volume vão para um bucket compatível com S3 que você controla, num horário que você define, e exigem Pro. Imagens reconhecidas como Postgres, inclusive <code>pgvector/pgvector</code>, <code>postgis/postgis</code> e <code>timescale/timescaledb</code>, recebem backups com <code>pg_dump</code>. O caminho do volume está em <a href="/solutions/persistent-files">backups de volume</a>.</p>
</aside>

## Credenciais e connection strings

O connection string é um segredo. Ele não vai no repositório.

Na Unbroker, cada variável é All, Production ou Preview. Um valor com escopo de ambiente substitui All para essa chave, então um preview pode usar outro banco sem mexer na produção. Um preview novo copia as variáveis All e Preview, e não recebe as que são só de Production. Coloque a credencial do banco de produção em Production, não em All, a menos que você queira que os previews a vejam.

## Checklist de Postgres antes do lançamento

Faça isto antes de usuários reais escreverem linhas. Cada linha é uma checagem.

1. Leia `max_connections` no servidor que você vai usar de verdade.
2. Multiplique as conexões de uma cópia do app pelas cópias que rodam ao mesmo tempo, e some cada outro cliente.
3. Deixe livre a reserva de superusuário. Não planeje usar todas as vagas.
4. Some um pooler só se esse produto ainda não cabe, e escolha session ou transaction de propósito.
5. Ache sessões com `xact_start` antigo, e encerre-as.
6. Decida se `idle_in_transaction_session_timeout` precisa ser diferente de zero. O default está desligado.
7. Dê uma primary key a cada tabela que os clientes atualizam.
8. Indexe as colunas que referenciam nas foreign keys pelas quais você apaga ou atualiza.
9. Leia `n_dead_tup` e `last_autovacuum` nas tabelas que mudam.
10. Guarde um dump em outro lugar que não seja o disco do banco.
11. Restaure esse dump uma vez, e depois rode `ANALYZE`.
12. Deixe o connection string de produção fora de All se os previews não devem vê-lo.

## Perguntas frequentes

### O que configuro no Postgres antes da produção?

Encaixe as conexões do app em max_connections, encerre transações que ficam abertas, coloque primary key, indexe as foreign keys pelas quais você apaga ou atualiza, acompanhe o vacuum e restaure um backup pelo menos uma vez. Uma página que consulta o banco não é essa lista.

### Por que o Postgres fica sem conexões?

O servidor recusa conexões novas que não são de superusuário quando as conexões ativas chegam a max_connections menos as vagas reservadas para superusuários. O default de max_connections costuma ser 100, e pode ser menor se o kernel não aguentava isso no initdb. Cada conexão de cliente é o próprio processo de backend.

### Preciso de PgBouncer para um app pequeno?

Não, se as conexões de uma cópia do app, vezes as cópias que rodam ao mesmo tempo, cabem em max_connections e ainda sobra lugar para outros clientes. Some um pooler quando muitos processos do app segurariam uma conexão de servidor pela sessão inteira. O modo default do PgBouncer é session pooling.

### Como acho transações longas no Postgres?

Consulte pg_stat_activity. xact_start é o momento em que a transação atual começou, e é null se não há uma ativa. O estado idle in transaction significa que a sessão está dentro de uma transação e não está executando uma consulta.

### Toda tabela do Postgres precisa de primary key?

O PostgreSQL não exige uma, e declará-la cria um índice B-tree único e marca as colunas como NOT NULL. A documentação também diz que um cliente que edita linhas em geral precisa dessa chave para identificá-las. O health card da Unbroker marca as tabelas que não têm uma.

### Foreign keys precisam de índice no Postgres?

A foreign key não cria um índice nas colunas que referenciam. O PostgreSQL diz que um delete ou um update da linha referenciada tem que varrer a tabela que referencia, então indexar essas colunas costuma ser uma boa ideia. Não é automático, porque nem sempre é necessário.

### Como sei se o autovacuum está atrasado?

Leia pg_stat_user_tables. n_dead_tup é uma estimativa de linhas mortas, e last_autovacuum é a última vez que o daemon de autovacuum rodou vacuum nessa tabela. Uma estimativa que cresce numa tabela que continua mudando, com last_autovacuum antigo ou vazio, é o sinal. A documentação não dá um corte único.

### Com que frequência testo um restore do Postgres?

Pelo menos uma vez antes de chamar o banco de produção, e de novo se o caminho do backup mudar. Um dump que você nunca carregou não é um plano. A documentação do Postgres também pede para rodar ANALYZE depois de restaurar um dump SQL para o planner ter estatísticas.

### Vale um Postgres gerenciado ou rodar eu mesmo?

Use um cluster gerenciado quando você quer que o provedor opere o host do banco. Use um nó Postgres de Apps quando você vai operar a imagem, o volume e a recuperação. Nos dois casos você continua dono do schema, das queries, das credenciais e de um restore que já testou. Isto não é uma comparação de preço.

## Related reading

- [Postgres gerenciado](https://unbroker.cloud/managed-databases/postgres)
- [Conectar uma API ao PostgreSQL](https://unbroker.cloud/solutions/api-with-postgres)
- [Backups e rollback de um app feito com IA](https://unbroker.cloud/pt/blog/ai-built-app-to-production)
- [Backups de volume](https://unbroker.cloud/solutions/persistent-files)
- [Django em produção](https://unbroker.cloud/pt/blog/django-in-production)
- [Express em produção](https://unbroker.cloud/pt/blog/express-in-production)
- [Preços](https://unbroker.cloud/pt/precos)
