Melhor VPS

Infraestrutura

PocketBase self-hosted em VPS: quanto recurso usar?

Aprenda a instalar PocketBase self-hosted em VPS com Docker, proxy HTTPS, backup do SQLite, segurança e recursos indicados para cada ambiente de produção.

Revisão editorial: Concluída

Resposta direta

O PocketBase self-hosted em VPS funciona bem para APIs, painéis internos, aplicativos móveis e produtos pequenos que precisam de autenticação, banco de dados, upload de arquivos e atualizações em tempo real sem manter vários serviços. Uma implantação inicial pode usar 1 vCPU, 1 GB de RAM e 20 GB de SSD, mas 2 vCPUs, 2 GB de RAM e 40 GB de SSD oferecem margem mais segura para produção. O serviço deve ficar atrás de um proxy HTTPS, com a porta 8090 inacessível pela internet. Como o banco principal é SQLite, a aplicação se beneficia de baixa latência de disco e backups consistentes do diretório pb_data. O PocketBase reduz a complexidade operacional, mas não substitui uma arquitetura distribuída quando há escrita concorrente intensa, alta disponibilidade entre nós ou exigência de escalabilidade horizontal.

Resumo rápido

  • O PocketBase reúne API, autenticação, painel administrativo, arquivos, eventos em tempo real e SQLite em um único executável.
  • Uma VPS pequena pode começar com 1 vCPU e 1 GB de RAM, embora 2 vCPUs e 2 GB sejam mais confortáveis em produção.
  • O diretório pb_data precisa estar em volume persistente e entrar na política de backup.
  • Caddy, Nginx ou Traefik deve terminar o HTTPS e encaminhar as requisições para a porta interna 8090.
  • O painel administrativo, as regras das coleções e os limites de upload exigem configuração antes da abertura pública.
  • SQLite atende muitas aplicações pequenas e médias, mas não foi projetado para escrita distribuída em vários nós.
  • Atualizações devem passar por backup, leitura das notas da versão e teste de restauração.

Como o PocketBase funciona em uma VPS

Onde o PocketBase simplifica o backend

O PocketBase é distribuído como um executável que incorpora servidor HTTP, autenticação, gerenciamento de coleções, armazenamento de arquivos e banco SQLite. Isso muda bastante a operação quando comparado a plataformas compostas por vários contêineres. Em vez de manter banco PostgreSQL, gateway, serviço de autenticação, painel e processos auxiliares, o administrador executa um serviço e preserva um diretório de dados.

Pense em um aplicativo de reservas com 5.000 usuários cadastrados. Ele pode ter coleções para clientes, horários e pagamentos, além de regras que permitem a cada usuário consultar apenas as próprias reservas. Outro exemplo é um painel interno de estoque usado por 20 funcionários. O PocketBase entrega login, API e interface administrativa sem exigir a criação imediata de um backend em Node.js ou Go. Um terceiro cenário é um protótipo móvel que usa o recurso de tempo real para atualizar mensagens ou estados de pedidos.

Essa simplicidade também reduz a quantidade de memória consumida em repouso. Não significa, porém, que qualquer projeto caberá em uma máquina mínima. Uploads de imagens, consultas sem índice, conexões em tempo real e rotinas personalizadas podem elevar CPU, RAM e uso de disco. O dimensionamento precisa considerar o comportamento da aplicação, não apenas o número de usuários cadastrados.

Limites do modelo de instância única

O SQLite mantém os dados em arquivos locais e coordena concorrência por mecanismos de bloqueio. Muitas leituras simultâneas são uma carga natural para esse modelo. Escritas longas ou muito frequentes podem formar fila, principalmente quando uma transação altera muitos registros. Colocar duas réplicas do PocketBase apontando para o mesmo diretório em armazenamento de rede não transforma o sistema em cluster e pode criar riscos de consistência.

Para um SaaS que recebe dez novas ordens por minuto, essa limitação pode nunca aparecer. Já uma plataforma de telemetria enviando centenas de gravações por segundo precisa de testes específicos e provavelmente de outra arquitetura. Quem prevê crescimento distribuído pode consultar o projeto de Supabase self-hosted em VPS, baseado em PostgreSQL e vários componentes. O ganho vem acompanhado de maior consumo de recursos e manutenção mais trabalhosa.

CPU, RAM e disco para cada carga de trabalho

Configuração inicial realista

Uma instalação de laboratório pode funcionar com 1 vCPU, 512 MB de RAM e 10 GB de SSD, mas essa configuração deixa pouca folga para sistema operacional, proxy reverso, atualizações e picos de acesso. Para um serviço público pequeno, o ponto inicial mais equilibrado é 1 vCPU, 1 GB de RAM e 20 GB de SSD. Se a VPS também executar Caddy, monitoramento e tarefas de backup, 2 vCPUs, 2 GB de RAM e 40 GB de SSD reduzem o risco de falta de memória.

Considere uma API para aplicativo de academia com 2.000 usuários, 100 acessos simultâneos nos horários de pico e poucas gravações por segundo. Uma máquina com 2 vCPUs e 2 GB de RAM tende a oferecer margem operacional, desde que as consultas tenham índices e os arquivos enviados não sejam processados no mesmo servidor. Essa indicação é um ponto de partida, não uma promessa de desempenho. O resultado depende da versão, das extensões, do tamanho dos registros e do padrão de acesso.

O disco merece atenção porque o SQLite confirma transações no armazenamento local. SSD é o mínimo razoável. NVMe pode reduzir latência de I/O, mas não corrige consultas ruins nem elimina a serialização de determinadas escritas. Reserve espaço livre para arquivos temporários, backups e crescimento do banco. Se pb_data ocupa 8 GB, manter uma VPS com apenas 10 GB de disco cria uma operação frágil. Uma reserva de duas a três vezes o volume ativo permite gerar cópias locais antes do envio para armazenamento externo.

Quando aumentar recursos

Suba de 1 para 2 vCPUs quando compressão, hooks personalizados ou consultas concorrentes mantiverem a CPU acima de 70% por períodos prolongados. Passe de 2 para 4 GB de RAM se houver cache do sistema pressionado, uso constante de swap ou processamento de imagens. Acompanhe esses sinais com htop, free -m, iostat -xz 1 e métricas do provedor.

Três perfis ajudam a iniciar o planejamento:

PerfilCPU e RAM sugeridasDisco inicialExemplo de cargaPrincipal cuidado
Protótipo privado1 vCPU e 1 GB20 GB SSDAté 20 usuários internosBackup antes de cada atualização
Aplicação pública pequena2 vCPUs e 2 GB40 GB SSD ou NVMeCentenas de usuários ativos por diaÍndices, uploads e monitoramento
Produção com arquivos e automações2 a 4 vCPUs e 4 GB80 GB ou maisMilhares de usuários e jobs periódicosTeste de carga e armazenamento externo

Não use quantidade de contas como única métrica. Dez mil usuários cadastrados com 200 acessos diários podem exigir menos recursos que 300 dispositivos enviando eventos a cada segundo. Antes de contratar uma máquina maior, reproduza o fluxo crítico com dados parecidos com os reais e registre latência, CPU, memória e tempo de escrita.

Implantação com Docker, Caddy e HTTPS

Imagem e volume persistente

O PocketBase pode ser executado diretamente como serviço do systemd ou dentro de um contêiner. Docker facilita a repetição do ambiente, mas o projeto precisa de uma imagem construída com uma versão explicitamente escolhida. Confirme a versão estável e a arquitetura do servidor na página oficial de releases antes do build. O exemplo abaixo usa AMD64 e deve ser adaptado para ARM64 quando necessário:

FROM alpine:3.20
ARG PB_VERSION
RUN apk add --no-cache ca-certificates unzip wget \
    && wget https://github.com/pocketbase/pocketbase/releases/download/v${PB_VERSION}/pocketbase_${PB_VERSION}_linux_amd64.zip \
    && unzip pocketbase_${PB_VERSION}_linux_amd64.zip -d /pb \
    && rm pocketbase_${PB_VERSION}_linux_amd64.zip
WORKDIR /pb
EXPOSE 8090
CMD [./pocketbase, serve, --http=0.0.0.0:8090]

Faça o build informando uma versão conferida, sem usar uma tag flutuante que mude sem controle:

docker build --build-arg PB_VERSION=VERSAO_VERIFICADA -t pocketbase-local .

O compose.yaml deve montar pb_data fora da camada gravável do contêiner. Sem esse volume, recriar o contêiner pode apagar banco, configurações e arquivos enviados.

services:
  pocketbase:
    image: pocketbase-local
    restart: unless-stopped
    ports:
      - 127.0.0.1:8090:8090
    volumes:
      - ./data:/pb/pb_data

A publicação em 127.0.0.1 impede acesso direto pela interface pública. Para uma explicação mais ampla sobre volumes, reinício e limites de recursos, consulte o conteúdo sobre Docker em VPS. Em produção, também é recomendável executar o contêiner com usuário sem privilégios, sistema de arquivos somente leitura onde for possível e diretório de dados com permissões restritas.

Proxy reverso e certificado TLS

Com o DNS apontando para a VPS, o Caddy pode obter e renovar o certificado automaticamente. Um arquivo simples encaminha o domínio para o PocketBase local:

api.exemplo.com {
    encode zstd gzip
    reverse_proxy 127.0.0.1:8090
}

Libere no firewall apenas SSH, HTTP e HTTPS. A porta 80 é usada na emissão ou no redirecionamento do certificado, enquanto a 443 recebe a aplicação. A porta 8090 permanece interna. Após iniciar os serviços, teste https://api.exemplo.com/api/health e confira os logs do proxy e do contêiner.

Atualização sem perder os dados

Uma atualização segura tem quatro passos: gerar backup consistente, ler as notas de migração, construir uma nova imagem e validar a aplicação antes de remover a anterior. Não substitua o binário durante uma escrita ativa. Em uma janela curta de manutenção, pare o contêiner, preserve pb_data, inicie a versão nova e teste autenticação, consulta, upload e regras das coleções. Se algo falhar, restaure os arquivos e volte para a imagem anterior. Essa rotina é mais lenta que executar latest, mas evita mudanças silenciosas no esquema ou em APIs.

Segurança da VPS e do PocketBase

Firewall, SSH e isolamento da aplicação

A superfície pública ideal contém apenas as portas 80 e 443, além do SSH restrito. Use autenticação SSH por chave, desative login direto de root e considere limitar a porta administrativa por endereço IP ou VPN. No Ubuntu, uma política básica com UFW pode permitir OpenSSH, 80/tcp e 443/tcp, seguida da ativação do firewall. Antes disso, abra uma segunda sessão e confirme que a chave funciona para não bloquear o próprio acesso.

O PocketBase não deve rodar como root. Se a implantação for feita sem Docker, crie um usuário de sistema dedicado, coloque o executável em /opt/pocketbase e conceda escrita somente em pb_data. Em contêiner, defina usuário não privilegiado e evite montar /var/run/docker.sock. Esse socket dá controle elevado sobre o host e não é necessário para o PocketBase.

Outro exemplo prático é separar o backup da aplicação. Uma credencial usada para enviar cópias a um bucket deve permitir gravação apenas no caminho previsto, sem poder listar ou apagar todos os objetos da conta. Para monitoramento externo, exponha somente o endpoint de saúde, sem publicar métricas que revelem caminhos, versões ou detalhes internos.

Regras de acesso e arquivos enviados

As regras das coleções são uma parte central da segurança. Uma coleção de pedidos não pode usar uma regra pública apenas porque o aplicativo precisa listar registros. A consulta deve relacionar o usuário autenticado ao campo de proprietário. Teste cada regra com três situações: visitante sem sessão, usuário dono do registro e usuário autenticado sem permissão. Um erro nessa camada pode expor dados mesmo que a VPS esteja corretamente protegida.

Uploads também precisam de limites. Defina tamanho máximo, valide extensões e não confie apenas no tipo MIME enviado pelo navegador. Um aplicativo de avatar pode aceitar JPEG, PNG e WebP de até 5 MB, enquanto uma área de documentos talvez permita PDF de até 20 MB. Se o produto recebe arquivos não confiáveis, faça análise antimalware em fluxo separado e nunca execute o conteúdo dentro do servidor.

Proteja o usuário administrativo com senha longa e exclusiva. O comando e o fluxo de criação de superusuário podem mudar entre versões, então confirme pocketbase superuser --help e a documentação correspondente ao binário instalado. Registre tentativas de login, aplique rate limiting no proxy quando fizer sentido e mantenha alertas para respostas 401, 403 e 429 fora do padrão. Segurança aqui depende da combinação entre sistema operacional, proxy, regras de coleção e comportamento da aplicação.

Backup, restauração e operação do SQLite

Como produzir um backup consistente

Copiar os arquivos do SQLite durante uma transação pode gerar uma cópia incompleta, especialmente quando arquivos auxiliares de journal ou WAL estão ativos. A estratégia mais simples para uma aplicação pequena é programar uma janela curta, interromper o PocketBase, compactar todo o diretório pb_data, enviar o arquivo a outro destino e iniciar o serviço novamente. O período indisponível costuma ser pequeno quando o volume de dados é modesto, mas deve ser medido.

Versões do PocketBase também podem oferecer recursos próprios de backup. Confirme o comportamento na documentação da versão implantada, incluindo conteúdo incluído, retenção e integração com armazenamento compatível com S3. Não presuma que um snapshot da VPS substitui o backup da aplicação. Um snapshot captura o estado do disco, mas pode reproduzir arquivos abertos em um ponto inconveniente e geralmente permanece na mesma conta do servidor.

Um exemplo de política para um produto em validação é manter sete cópias diárias, quatro semanais e três mensais. O arquivo deve sair da VPS após a criação. Se um invasor obtiver acesso administrativo, backups armazenados apenas em /opt/pocketbase/backups poderão ser apagados junto com os dados ativos. Criptografe informações sensíveis antes do envio e mantenha as credenciais fora da imagem Docker e do repositório Git.

Teste de restauração e retenção

Backup sem restauração testada é apenas uma expectativa. Uma vez por mês, crie uma VPS temporária ou uma máquina virtual local, instale a mesma versão do PocketBase, restaure pb_data e valide quatro fluxos: login, leitura de registros, criação de registro e download de arquivo. Registre duração, tamanho e eventuais ajustes. Esse procedimento revela permissões incorretas, arquivos ausentes e incompatibilidade entre versão do binário e estrutura do banco.

Defina RPO e RTO em termos concretos. Se o negócio aceita perder até 24 horas de alterações, um backup diário pode bastar. Se só pode perder 15 minutos, a operação precisa de cópias mais frequentes, testes de impacto e talvez uma arquitetura diferente. Um RTO de duas horas exige documentação, acesso às credenciais e automação suficiente para reconstruir a VPS nesse prazo.

Monitore ainda espaço livre e crescimento de pb_data. Um alerta ao atingir 70% do disco dá tempo para investigar. Aos 85%, operações temporárias e geração de backups já podem falhar. Use du -sh, df -h e métricas do provedor, além de verificar logs por mensagens de banco bloqueado, falta de espaço e erro de permissão. Em aplicações com muitos arquivos, mover uploads para armazenamento externo pode controlar o crescimento, desde que a opção seja suportada e testada na versão utilizada.

PocketBase, Supabase ou Appwrite na prática

Comparação de arquitetura

PocketBase, Supabase e Appwrite resolvem problemas parecidos, mas exigem níveis diferentes de infraestrutura. PocketBase concentra os componentes em um binário e usa SQLite. Supabase adota PostgreSQL e serviços que cobrem autenticação, API, tempo real e armazenamento. Appwrite distribui funções entre vários contêineres e dependências. A escolha não deve se limitar à quantidade de recursos da VPS. Modelo de dados, disponibilidade desejada, experiência da equipe e plano de crescimento pesam mais.

PlataformaBanco principalOperação self-hostedConfiguração inicial razoávelCenário comumLimitação a observar
PocketBaseSQLiteUm serviço principal e proxy1 a 2 vCPUs, 1 a 2 GB de RAMMVP, app móvel, painel internoEscala horizontal e escrita concorrente
SupabasePostgreSQLVários serviços e contêineres4 vCPUs e 8 GB de RAM ou mais, validar releaseSaaS relacional e equipes que usam SQLConsumo e manutenção do conjunto
AppwriteBanco e serviços conforme a versãoPilha com múltiplos contêineres4 vCPUs e 8 GB de RAM ou mais, validar releaseBackend integrado com funções e storageNúmero de componentes operacionais

As configurações da tabela são referências de planejamento, não mínimos oficiais universais. Releases e recursos habilitados alteram o consumo. Se funções, observabilidade e armazenamento local forem adicionados, a máquina precisará de mais memória e disco. O artigo sobre Appwrite self-hosted em VPS detalha essa pilha e ajuda a estimar a diferença operacional.

Quando não escolher PocketBase

Evite PocketBase como primeira opção quando a aplicação exige escrita intensa em vários nós, replicação geográfica, failover automático ou ecossistema PostgreSQL. Um marketplace com conciliação financeira complexa e relatórios SQL pesados provavelmente aproveitará melhor um banco servidor tradicional. O mesmo se aplica a uma plataforma regulada que exige separação rígida de funções, trilhas avançadas de auditoria e procedimentos maduros de alta disponibilidade.

Isso não torna o PocketBase inadequado para produção. Ele pode sustentar produtos reais quando a carga combina com sua arquitetura e a equipe aceita operar uma instância principal com recuperação por backup. O erro seria tratar simplicidade como ausência de responsabilidade operacional. Mesmo um binário único precisa de TLS, atualização, teste de carga, backup externo e monitoramento.

Recomendações por perfil

Desenvolvedor solo e protótipo

Para um desenvolvedor validando um aplicativo, comece com 1 vCPU, 1 GB de RAM e 20 GB de SSD. Use Debian ou Ubuntu em versão com suporte, Caddy para HTTPS e Docker Compose com volume persistente. Essa estrutura atende um protótipo, uma aplicação pessoal ou um painel usado por poucas dezenas de pessoas. Configure backup diário externo e alerta de disco antes de convidar usuários.

Mantenha o ambiente simples. Não adicione Kubernetes, balanceador ou banco separado sem uma necessidade mensurável. Faça um teste com 20 a 50 clientes simultâneos, incluindo login, listagem, gravação e upload. Se a memória se aproximar do limite ou o swap for usado continuamente, migre para 2 GB. A primeira otimização costuma estar nas consultas, nos índices e no tamanho dos arquivos, não na troca imediata de provedor.

Equipe pequena e produto em validação

Para uma equipe com aplicação pública, use 2 vCPUs, 2 a 4 GB de RAM e pelo menos 40 GB de SSD ou NVMe. Separe desenvolvimento e produção. A imagem Docker deve ter versão fixada, e cada atualização precisa passar por ambiente de homologação com uma cópia anonimizada dos dados. Centralize logs do proxy e do PocketBase, monitore CPU, memória, disco, latência e taxa de erros.

Adote backups diários com retenção semanal e teste mensal de restauração. Se houver uploads frequentes, estime o crescimento por usuário. Quinhentos usuários enviando quatro imagens de 2 MB por mês acrescentam cerca de 4 GB mensais antes de miniaturas e cópias. Esse cálculo simples evita contratar um disco que ficará cheio em poucas semanas. Documente também quem pode acessar a interface administrativa e como revogar credenciais quando alguém sair da equipe.

Produção com dados críticos

Para produção crítica, a decisão começa pela arquitetura, não pelo tamanho da VPS. Use ao menos 2 a 4 vCPUs, 4 GB de RAM e disco dimensionado com folga, mas valide tudo com teste de carga representativo. Defina RPO, RTO, janela de manutenção e procedimento de rollback. Backups devem ser criptografados, armazenados fora da conta principal e restaurados periodicamente em ambiente isolado.

Se a aplicação não pode ficar indisponível durante a recuperação de uma instância, o modelo de nó único pode não atender. Não tente resolver isso compartilhando o arquivo SQLite entre múltiplos servidores. Avalie PostgreSQL gerenciado, Supabase, uma API própria ou outra plataforma que suporte replicação e failover de forma documentada. PocketBase continua sendo uma boa camada para ferramentas internas e serviços delimitados, mas o limite precisa ser explícito.

Antes da entrada em produção, execute um checklist final: portas externas reduzidas, SSH por chave, usuário não root, regras das coleções testadas, limites de upload, HTTPS válido, backup externo, restauração comprovada, alerta de disco e versão fixada. Esse conjunto tem mais impacto na confiabilidade diária que escolher uma VPS apenas pelo número anunciado de vCPUs.

Perguntas frequentes

Quanto de RAM o PocketBase precisa em uma VPS?

Uma instalação de laboratório pode funcionar com 512 MB, mas 1 GB é um ponto inicial mais seguro para sistema operacional, proxy e PocketBase. Em produção pequena, 2 GB oferecem margem para conexões simultâneas, cache de arquivos e tarefas de backup. Projetos com hooks personalizados, processamento de imagens ou muitos acessos em tempo real podem precisar de 4 GB. Monitore memória disponível, swap e encerramentos por OOM. A quantidade de usuários cadastrados isoladamente não define o consumo, pois frequência de acesso, consultas e tamanho dos arquivos influenciam mais.

PocketBase pode ser usado em produção?

Sim, desde que a carga seja compatível com SQLite e a equipe aceite as características de uma instância principal. PocketBase pode atender aplicativos móveis, APIs pequenas, painéis internos e produtos em validação. Produção exige HTTPS, regras de acesso testadas, backup externo, restauração periódica, atualização controlada e monitoramento. Ele se torna menos indicado quando o sistema precisa de escrita distribuída, múltiplos nós ativos, failover automático ou relatórios relacionais muito pesados. Um teste de carga com dados e fluxos próximos dos reais deve orientar a decisão final.

É melhor instalar PocketBase com Docker ou systemd?

As duas abordagens são válidas. Docker facilita builds reproduzíveis, rollback de versão e isolamento de dependências, mas exige cuidado com volume persistente, usuário do contêiner e atualização da imagem. Systemd reduz camadas e executa diretamente o binário oficial, sendo uma opção simples para quem domina administração Linux. Em ambos os casos, `pb_data` precisa sobreviver à troca do executável. A escolha deve acompanhar a prática da equipe. Se todos os outros serviços usam Docker Compose, manter PocketBase no mesmo fluxo costuma reduzir erros operacionais.

Como fazer backup do banco SQLite do PocketBase?

Para uma implantação pequena, a abordagem mais previsível é interromper brevemente o PocketBase, copiar todo o diretório `pb_data`, compactar e enviar o arquivo para armazenamento externo. Isso evita capturar o SQLite no meio de uma transação. Algumas versões oferecem funções próprias de backup, que devem ser confirmadas na documentação correspondente ao binário instalado. Mantenha retenção diária, semanal e mensal conforme o risco do projeto. Pelo menos uma vez por mês, restaure a cópia em outro ambiente e teste login, leitura, gravação e download de arquivos.

PocketBase escala horizontalmente em várias VPS?

O modelo padrão não foi projetado para executar várias instâncias gravando no mesmo arquivo SQLite compartilhado. Montar `pb_data` em armazenamento de rede e iniciar múltiplos nós pode introduzir problemas de bloqueio, latência e consistência. É possível escalar partes externas, como CDN e armazenamento de arquivos, mas a camada principal continua condicionada ao banco local. Se o produto exige múltiplos nós ativos, replicação geográfica ou failover sem intervenção, considere PostgreSQL com uma arquitetura apropriada, Supabase ou um backend próprio preparado para banco servidor e coordenação distribuída.

PocketBase é mais simples que Supabase e Appwrite?

Na operação self-hosted, normalmente sim, porque PocketBase concentra API, autenticação, painel, arquivos e SQLite em um executável. Supabase e Appwrite usam conjuntos maiores de serviços e costumam exigir mais memória, contêineres e procedimentos de atualização. Essa simplicidade envolve uma troca. PocketBase oferece menos opções para escala horizontal e alta disponibilidade distribuída. Para um MVP ou painel interno, isso pode ser uma vantagem clara. Para um SaaS com SQL avançado, muitas integrações e failover automático, uma plataforma mais complexa pode justificar o custo operacional adicional.

Fontes consultadas