PocketBase en VPS: instalación, configuración y mantenimiento

Instalar PocketBase en un VPS es una forma eficiente de desplegar una plataforma backend potente, ligera y multifuncional que ofrece una base de datos SQLite, API, autenticación y un panel de administración en un único archivo binario compacto, lo que permite un control total sobre la infraestructura y la optimización de costes.

En el mundo del desarrollo de aplicaciones web y servicios móviles, la velocidad de comercialización y la flexibilidad de la infraestructura juegan un papel clave. Los desarrolladores buscan constantemente soluciones que permitan crear rápidamente prototipos, MVP (Minimum Viable Products) e incluso productos completos sin necesidad de sumergirse profundamente en la configuración de un backend complejo. Aquí es donde entra en juego PocketBase, un proyecto único que cambia la percepción de lo que puede ser un backend.

PocketBase no es solo una base de datos o un framework; es un servidor backend de código abierto completo, escrito en Go, que incluye una base de datos SQLite embebida, una API RESTful, un sistema de autenticación de usuarios e incluso un cómodo panel de administración. Todo esto está empaquetado en un único archivo binario, lo que lo hace increíblemente fácil de desplegar y gestionar. Para proyectos que necesitan un desarrollo rápido, bajos costes operativos y control total sobre los datos, la instalación de PocketBase en su propio VPS se convierte en la solución ideal.

En este artículo, exploraremos en detalle cómo desplegar PocketBase en un servidor privado virtual (VPS) utilizando Docker y Docker Compose para una máxima flexibilidad y simplicidad. Repasaremos los requisitos del sistema, la instalación paso a paso, la configuración de un proxy inverso con HTTPS, las estrategias de copia de seguridad y actualización, y daremos recomendaciones para elegir la configuración de VPS óptima para diferentes escenarios de carga. Si busca una forma de obtener un backend potente y gestionable sin complicaciones adicionales, este artículo es su guía.

¿Qué es PocketBase y por qué debería desplegarlo en un VPS?

PocketBase es una solución backend única que combina varios componentes críticos para el desarrollo de aplicaciones modernas. No es solo una base de datos o un servidor API; es una plataforma integral diseñada para la máxima simplicidad y rendimiento.

Características clave de PocketBase

PocketBase se destaca de otras soluciones BaaS (Backend as a Service) gracias a su enfoque minimalista pero potente:

• Base de datos SQLite embebida: La base de PocketBase es SQLite, lo que la hace increíblemente ligera y no requiere el despliegue separado de un SGBD complejo. Esto es ideal para proyectos donde no se necesita la escalabilidad a nivel de PostgreSQL o MySQL para decenas de miles de solicitudes por segundo, pero la simplicidad y la velocidad son importantes.
• API RESTful y API GraphQL: APIs generadas automáticamente para todas sus colecciones de datos. Puede comenzar a interactuar inmediatamente con el backend desde su frontend utilizando métodos HTTP estándar. El soporte para GraphQL también está disponible a través de plugins o lógica personalizada.
• Sistema de autenticación: Soporte integrado para la autenticación de usuarios por email/contraseña, proveedores OAuth2 (Google, GitHub, etc.) y usuarios anónimos. La gestión de los derechos de acceso a los datos se realiza a través de reglas flexibles.
• Panel de administración: Una interfaz web cómoda e intuitiva para gestionar colecciones de datos, usuarios, archivos y configuraciones. Esto permite crear y modificar rápidamente la estructura de datos sin escribir código.
• Almacenamiento de archivos: Capacidad integrada para cargar y almacenar archivos, con soporte tanto para disco local como para integración con almacenamientos compatibles con S3.
• Suscripciones en tiempo real (Realtime): Soporte de WebSocket para recibir actualizaciones de datos en tiempo real, ideal para chats, notificaciones o interfaces de usuario dinámicas.
• Un único archivo binario: Todo PocketBase está compilado en un único archivo ejecutable, lo que simplifica el despliegue y la gestión de dependencias.
• Extensibilidad en Go: Para escenarios más complejos, se puede escribir lógica personalizada en Go, extendiendo la funcionalidad de PocketBase.

Escenarios de uso de PocketBase

Gracias a sus características, PocketBase es ideal para una amplia gama de tareas:

• Prototipos y MVP: Creación rápida de un backend para probar ideas, cuando no hay tiempo para una infraestructura compleja.
• Aplicaciones web pequeñas y medianas: Ideal para blogs, tiendas online con un pequeño surtido, portales corporativos, landing pages con formularios de contacto.
• Paneles de administración y herramientas internas: Creación rápida de herramientas internas para gestionar contenido, datos o usuarios.
• Backend para sitios estáticos: Adición de contenido dinámico, formularios y datos de usuario a sitios construidos con generadores de estáticos (Next.js, Astro, Jekyll, etc.).
• Aplicaciones móviles: Proporciona una API lista y un sistema de autenticación para aplicaciones iOS y Android.
• Proyectos personales: Una excelente opción para proyectos de hobby que requieren un backend fiable pero sencillo.

¿Por qué un VPS es la mejor opción para PocketBase?

Elegir un VPS (Virtual Private Server) para desplegar PocketBase tiene una serie de ventajas innegables, especialmente para aquellos que buscan un equilibrio entre control, rendimiento y coste:

1. Control total sobre el entorno: A diferencia de los proveedores de BaaS, que lo limitan con sus reglas y herramientas, en un VPS obtiene acceso root completo. Esto le permite instalar cualquier software, configurar el firewall, elegir el sistema operativo y optimizar todos los parámetros según sus necesidades. Esto es críticamente importante para PocketBase self-hosted, donde desea tener control total sobre los datos y su procesamiento.
2. Optimización del rendimiento: Puede elegir exactamente los recursos de hardware (CPU, RAM, disco NVMe) que cumplen con los requisitos de su aplicación. Para PocketBase, que es muy eficiente, esto significa la posibilidad de obtener un excelente rendimiento incluso en configuraciones de VPS modestas.
3. Eficiencia económica: Para muchos proyectos, alojar PocketBase en un VPS resulta significativamente más barato que usar soluciones BaaS comerciales, especialmente a medida que el proyecto crece y aumenta el volumen de datos o el número de solicitudes. Solo paga por los recursos que se le asignan.
4. Seguridad y privacidad de los datos: Sus datos se almacenan en su servidor, bajo su control. Esto es importante para proyectos con altos requisitos de seguridad o cumplimiento normativo. Usted mismo configura las medidas de seguridad, las copias de seguridad y el acceso.
5. Flexibilidad de escalado: A medida que el proyecto crece, puede escalar fácilmente los recursos del VPS, pasando a planes de tarifas más potentes o incluso a servidores dedicados si la carga se vuelve extrema.
6. Integración con otros servicios: En un VPS puede instalar y configurar fácilmente otros servicios junto con PocketBase, por ejemplo, Redis para caching, MinIO para almacenamiento compatible con S3, u otras herramientas de monitoreo y logging.

El despliegue de PocketBase en un servidor, en particular en un VPS, brinda a los desarrolladores la libertad, el control y el ahorro que son necesarios para el lanzamiento y desarrollo exitoso de proyectos.

Requisitos del sistema para PocketBase en un servidor

PocketBase está diseñado teniendo en cuenta un consumo mínimo de recursos, lo que lo convierte en un candidato ideal para el despliegue incluso en los VPS más modestos. Sin embargo, como cualquier aplicación, tiene ciertos requisitos del sistema que dependen de la carga esperada.

Requisitos mínimos (para desarrollo, prototipos y proyectos muy pequeños)

• Procesador (CPU): 1 vCore. PocketBase es muy eficiente, y para la mayoría de las tareas un solo núcleo será suficiente.
• Memoria RAM: 512 MB - 1 GB. PocketBase en sí mismo necesita poca memoria, pero el SO, Docker y otros procesos en segundo plano también consumen RAM.
• Espacio en disco (Storage): 10 GB (NVMe SSD). Los discos NVMe aceleran significativamente las operaciones de lectura/escritura, lo cual es críticamente importante para la base de datos SQLite. 10 GB serán suficientes para el SO, Docker y el volumen inicial de datos.
• Sistema operativo: Cualquier distribución moderna de Linux (Ubuntu 20.04+, Debian 11+).
• Ancho de banda de red: 100 Mbps.

Esta configuración será suficiente para pruebas, proyectos personales o aplicaciones con muy baja concurrencia (hasta 5-10 usuarios simultáneos).

Requisitos recomendados (para proyectos de producción pequeños y medianos)

• Procesador (CPU): 2 vCores. Un núcleo adicional proporcionará un mejor rendimiento al procesar múltiples solicitudes simultáneamente y al ejecutar tareas en segundo plano.
• Memoria RAM: 2 GB - 4 GB. Para un entorno de producción, donde puede haber decenas o cientos de solicitudes simultáneas, más RAM ayudará a cachear los datos de SQLite y garantizará un funcionamiento estable.
• Espacio en disco (Storage): 50 GB - 100 GB (NVMe SSD). Un mayor volumen de disco proporcionará un margen para el crecimiento de datos y el almacenamiento de archivos, y NVMe seguirá siendo clave para el rendimiento.
• Sistema operativo: Ubuntu 22.04 LTS o Debian 12. Estas distribuciones ofrecen versiones actualizadas de software y soporte a largo plazo.
• Ancho de banda de red: 200 Mbps - 1 Gbps. Para una API activa y actualizaciones en tiempo real, así como para la transferencia de archivos, es necesario un buen ancho de banda.

Esta configuración es adecuada para la mayoría de las startups, herramientas internas y aplicaciones web con una carga moderada (hasta 100-200 usuarios simultáneos).

Dependencias

• Docker: El método recomendado para desplegar PocketBase, ya que proporciona aislamiento, facilidad de gestión y portabilidad.
• Docker Compose: Para la orquestación de contenedores, simplifica el lanzamiento y la gestión de PocketBase con servicios adicionales (por ejemplo, un proxy inverso).
• Reverse Proxy: Nginx o Caddy para manejar certificados HTTPS, nombres de dominio y balanceo de carga. Esto es críticamente importante para un entorno de producción.

Al elegir un VPS, siempre debe orientarse a la carga máxima esperada. Es mejor tomar un plan con un pequeño margen que enfrentarse a problemas de rendimiento al inicio.

Preparación del VPS para la instalación de PocketBase

Antes de proceder con la instalación de PocketBase, es necesario realizar una serie de pasos preparatorios en su VPS. Estos pasos garantizarán la seguridad, estabilidad y el correcto funcionamiento de su futura plataforma.

1. Conexión al VPS por SSH

Lo primero que debe hacer es obtener acceso al servidor. Utilice un cliente SSH (PuTTY para Windows, terminal para Linux/macOS) para conectarse a su VPS. Necesitará la dirección IP del servidor, el nombre de usuario (normalmente root o un usuario creado por el proveedor) y la contraseña/clave SSH.

ssh user@your_vps_ip_address

Si utiliza el usuario root, se recomienda crear un nuevo usuario con privilegios limitados para el trabajo diario y configurar claves SSH para un inicio de sesión seguro. Puede encontrar información adicional sobre cómo trabajar con servidores en el artículo ¿Qué es un servidor y un dedicado: Guía completa para principiantes?.

2. Actualización del sistema

Siempre comience actualizando el gestor de paquetes y los paquetes instalados para asegurarse de tener las últimas versiones y parches de seguridad.

sudo apt update
sudo apt upgrade -y

3. Configuración del firewall (UFW)

UFW (Uncomplicated Firewall) es un firewall fácil de usar para Linux. Su configuración es críticamente importante para proteger su servidor del acceso no autorizado.

• Permitir SSH:

sudo ufw allow OpenSSH

• Permitir HTTP y HTTPS:

sudo ufw allow http
sudo ufw allow https

Estos puertos (80 y 443) son necesarios para acceder a su PocketBase a través de un navegador web después de configurar el proxy inverso.

• Permitir el puerto de PocketBase (opcional, solo para pruebas sin proxy):

sudo ufw allow 8090/tcp

El puerto 8090 es el puerto predeterminado en el que PocketBase escucha las conexiones entrantes. En un entorno de producción, el acceso a este puerto debe estar cerrado desde el exterior y solo disponible para el proxy inverso.

• Habilitar el firewall:

sudo ufw enable

Confirme la acción presionando y. Asegúrese de no haber bloqueado el acceso SSH.

• Verificar el estado del firewall:

sudo ufw status

4. Instalación de Docker

Docker es la base de nuestro despliegue. Lo instalaremos siguiendo la documentación oficial.

• Eliminar versiones antiguas de Docker (si las hay):

for pkg in docker.io docker-doc docker-compose docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin; do sudo apt remove $pkg; done

• Instalar dependencias:

sudo apt install ca-certificates curl gnupg lsb-release -y

• Añadir la clave GPG oficial de Docker:

sudo mkdir -m 0755 -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

• Configurar el repositorio de Docker:

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

• Actualizar la lista de paquetes e instalar Docker Engine:

sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

• Añadir el usuario al grupo docker (para no usar sudo):

sudo usermod -aG docker $USER
newgrp docker

Salga de la sesión SSH y vuelva a conectarse para que los cambios surtan efecto.

• Verificar la instalación de Docker:

docker run hello-world

Debería ver el mensaje "Hello from Docker!".

5. Instalación de Docker Compose

Docker Compose generalmente se instala junto con Docker Engine a través de un plugin. Si por alguna razón no está, o si está utilizando una versión antigua de Docker, se puede instalar por separado.

sudo apt install docker-compose-plugin -y

Verificar la versión de Docker Compose:

docker compose version

Ahora su VPS está completamente listo para desplegar el contenedor PocketBase Docker.

Instalación de PocketBase en un VPS usando Docker Compose

El uso de Docker Compose para la instalación de PocketBase es el método más conveniente y recomendado, ya que permite gestionar fácilmente la configuración, las dependencias y garantiza la portabilidad. Utilizaremos la imagen oficial de PocketBase.

1. Creación del directorio de trabajo

Cree un directorio para su proyecto PocketBase. En él se almacenarán los archivos de configuración de Docker Compose y los datos de PocketBase.

mkdir -p ~/pocketbase_app
cd ~/pocketbase_app

2. Creación del archivo docker-compose.yml

Dentro de este directorio, cree un archivo llamado docker-compose.yml. Este archivo describirá cómo Docker debe iniciar PocketBase.

nano docker-compose.yml

Pegue el siguiente contenido:

version: '3.8'

services:
  pocketbase:
    image: ghcr.io/pocketbase/pocketbase:latest
    container_name: pocketbase
    restart: unless-stopped
    ports:
      - "8090:8090" # PocketBase por defecto escucha en el puerto 8090
    volumes:
      - ./pb_data:/pb_data # Guardar los datos de PocketBase
      - ./pb_public:/pb_public # Para archivos estáticos, si es necesario
      - ./pb_migrations:/pb_migrations # Para migraciones, si es necesario
    environment:
      # Opcional: se pueden configurar variables de entorno para PocketBase
      # Por ejemplo, para configurar SMTP para el envío de correos electrónicos
      # POCKETBASE_SMTP_HOST: smtp.example.com
      # POCKETBASE_SMTP_PORT: 587
      # POCKETBASE_SMTP_USERNAME: [email protected]
      # POCKETBASE_SMTP_PASSWORD: your_password
      # POCKETBASE_ADMIN_EMAIL: [email protected]
      # POCKETBASE_ADMIN_PASSWORD: your_strong_password
      # POCKETBASE_URL: https://yourdomain.com
    command: ["./pocketbase", "serve", "--http=0.0.0.0:8090"]

  # Opcional: Si planea usar Nginx o Caddy
  # como proxy inverso en un contenedor separado,
  # se puede añadir aquí. Pero a menudo se ejecuta
  # en el host o en un archivo docker-compose separado.
  # Ejemplo para Nginx (comentado):
  # nginx:
  #   image: nginx:latest
  #   container_name: nginx_proxy
  #   restart: unless-stopped
  #   ports:
  #     - "80:80"
  #     - "443:443"
  #   volumes:
  #     - ./nginx/conf.d:/etc/nginx/conf.d
  #     - ./nginx/certbot/conf:/etc/letsencrypt
  #     - ./nginx/certbot/www:/var/www/certbot
  #   depends_on:
  #     - pocketbase

Analicemos las partes principales de este archivo:

• version: '3.8': Indica la versión de la sintaxis de Docker Compose.
• services:: Define los servicios (contenedores) que se ejecutarán.
• pocketbase:: El nombre de nuestro servicio.
  • image: ghcr.io/pocketbase/pocketbase:latest: Indica que se debe usar la imagen oficial de Docker de PocketBase. :latest significa la última versión estable.
  • container_name: pocketbase: Asigna un nombre legible al contenedor.
  • restart: unless-stopped: El contenedor se reiniciará automáticamente si se detiene (por ejemplo, debido a un error) o al reiniciar el servidor, a menos que lo haya detenido manualmente.
  • ports: - "8090:8090": Mapea el puerto 8090 del contenedor al puerto 8090 de la máquina host. Esto le permitirá acceder a PocketBase desde el exterior. En un entorno de producción, este puerto solo será accesible para el proxy inverso.
  • volumes:: Define qué directorios de la máquina host se montarán dentro del contenedor.
    • ./pb_data:/pb_data: Esto es críticamente importante. Aquí se almacenarán todos los datos de PocketBase (base de datos SQLite, archivos cargados). Si no utiliza un volumen, los datos se perderán al eliminar el contenedor.
    • ./pb_public:/pb_public: Para archivos estáticos, si desea que PocketBase los sirva.
    • ./pb_migrations:/pb_migrations: Para almacenar las migraciones de la base de datos.
  • environment:: Permite pasar variables de entorno al contenedor de PocketBase. Esto es útil para configurar SMTP, la URL de la aplicación y otros parámetros.
  • command: ["./pocketbase", "serve", "--http=0.0.0.0:8090"]: Indica el comando que PocketBase debe ejecutar al iniciar. 0.0.0.0 significa que PocketBase escuchará en todas las interfaces de red disponibles.

3. Inicio de PocketBase

Guarde el archivo docker-compose.yml (Ctrl+X, Y, Enter). Ahora puede iniciar PocketBase.

docker compose up -d

• up: Inicia los servicios definidos en docker-compose.yml.
• -d: Inicia los servicios en segundo plano (detached mode).

Docker descargará la imagen de PocketBase (si no está localmente), creará y ejecutará el contenedor. Puede verificar el estado de los contenedores en ejecución:

docker ps

Debería ver un contenedor con el nombre pocketbase y el estado Up.

4. Configuración inicial de PocketBase

Después de iniciar el contenedor, PocketBase estará disponible en la dirección http://your_vps_ip_address:8090/_/ (observe el /_/ al final). Abra esta URL en su navegador. Se le pedirá que cree el primer administrador. Ingrese un correo electrónico y una contraseña segura. Esto creará la cuenta de administrador e inicializará la base de datos.

Ahora su PocketBase en VPS está en funcionamiento y listo para trabajar. El siguiente paso será configurar el proxy inverso y HTTPS para un acceso seguro y conveniente.

Configuración de Reverse Proxy y HTTPS para PocketBase

En un entorno de producción, es altamente desaconsejable proporcionar acceso directo a PocketBase a través del puerto 8090. En su lugar, se debe utilizar un servidor proxy inverso (Reverse Proxy) que aceptará todas las solicitudes entrantes en los puertos estándar (80 para HTTP y 443 para HTTPS), las reenviará a PocketBase y gestionará los certificados HTTPS. Esto aumenta la seguridad, permite el uso de nombres de dominio y simplifica la escalabilidad. En esta sección, veremos la configuración de Nginx y Caddy.

¿Por qué se necesita un Reverse Proxy?

• HTTPS/SSL: Un proxy inverso se integra fácilmente con Let's Encrypt para la obtención y renovación automática de certificados SSL gratuitos, garantizando una conexión cifrada segura.
• Nombres de dominio: Permite vincular su PocketBase a un nombre de dominio amigable (por ejemplo, api.yourdomain.com) en lugar de una dirección IP y un puerto.
• Seguridad: Oculta el puerto real en el que se ejecuta PocketBase y puede servir como primera línea de defensa, filtrando solicitudes maliciosas.
• Balanceo de carga: En escenarios más complejos, un proxy inverso puede distribuir las solicitudes entre varias instancias de PocketBase.
• Caching: Algunos proxies pueden cachear contenido estático, reduciendo la carga en el backend.

Antes de comenzar, asegúrese de que su dominio o subdominio (por ejemplo, pocketbase.yourdomain.com) apunte a la dirección IP de su VPS.

Configuración de Nginx como Reverse Proxy

Nginx es uno de los servidores web y proxies inversos más populares y de alto rendimiento. Lo utilizaremos para redirigir el tráfico a PocketBase y gestionar HTTPS.

1. Instalación de Nginx

sudo apt install nginx -y
sudo systemctl enable nginx
sudo systemctl start nginx

Verifique el estado de Nginx:

sudo systemctl status nginx

2. Configuración de Nginx para PocketBase

Cree un nuevo archivo de configuración de Nginx para su dominio. Reemplace pocketbase.yourdomain.com con su dominio real.

sudo nano /etc/nginx/sites-available/pocketbase.conf

Pegue el siguiente contenido:

server {
    listen 80;
    server_name pocketbase.yourdomain.com; # Reemplace con su dominio

    location / {
        proxy_pass http://localhost:8090; # PocketBase se ejecuta en el puerto 8090
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # Para soporte de WebSocket (Realtime API)
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

Guarde el archivo.

3. Activación de la configuración de Nginx

Cree un enlace simbólico al archivo de configuración de sites-available a sites-enabled y elimine la configuración predeterminada de Nginx.

sudo ln -s /etc/nginx/sites-available/pocketbase.conf /etc/nginx/sites-enabled/
sudo rm /etc/nginx/sites-enabled/default

Verifique la sintaxis de la configuración de Nginx:

sudo nginx -t

Si no hay errores, reinicie Nginx:

sudo systemctl restart nginx

Ahora su PocketBase debería ser accesible por HTTP a través de su dominio (http://pocketbase.yourdomain.com). El siguiente paso es añadir HTTPS.

4. Configuración de HTTPS con Certbot (Let's Encrypt)

Certbot automatiza el proceso de obtención e instalación de certificados SSL gratuitos de Let's Encrypt.

• Instalación de Certbot:

sudo apt install certbot python3-certbot-nginx -y

• Obtención e instalación del certificado:

sudo certbot --nginx -d pocketbase.yourdomain.com

Siga las instrucciones en pantalla. Certbot configurará automáticamente Nginx para usar HTTPS y añadirá una regla para la renovación automática del certificado.

• Verificación de la renovación automática:

sudo systemctl status certbot.timer

Ahora su PocketBase debería ser accesible por HTTPS: https://pocketbase.yourdomain.com.

Configuración de Caddy como Reverse Proxy

Caddy es un servidor web moderno que se destaca por su simplicidad de configuración y soporte automático de HTTPS con Let's Encrypt. Para muchos, es una solución más sencilla que Nginx.

1. Instalación de Caddy

Siga las instrucciones del sitio web oficial de Caddy para la instalación. Para Debian/Ubuntu:

sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list
sudo apt update
sudo apt install caddy -y

Inicie Caddy:

sudo systemctl enable caddy
sudo systemctl start caddy

2. Configuración de Caddyfile para PocketBase

Caddy utiliza un archivo Caddyfile para la configuración. Ábralo para editar:

sudo nano /etc/caddy/Caddyfile

Elimine el contenido existente y pegue lo siguiente, reemplazando pocketbase.yourdomain.com con su dominio:

pocketbase.yourdomain.com {
    reverse_proxy localhost:8090 {
        # Para soporte de WebSocket (Realtime API)
        header_up Upgrade {http.request.header.Upgrade}
        header_up Connection {http.request.header.Connection}
    }

    # Opcional: Aumente los límites de carga de archivos, si es necesario
    # client_max_body_size 250M
}

Guarde el archivo.

3. Verificación y recarga de Caddy

sudo caddy validate --config /etc/caddy/Caddyfile
sudo systemctl reload caddy

Caddy obtendrá e instalará automáticamente un certificado SSL para su dominio. Ahora su PocketBase debería ser accesible por HTTPS: https://pocketbase.yourdomain.com.

Ha configurado con éxito el proxy inverso y HTTPS para su instalación de PocketBase. Esto mejora significativamente la seguridad y la facilidad de uso de su aplicación.

Copias de seguridad y actualizaciones de PocketBase: estrategias y automatización

Las copias de seguridad (backups) y las actualizaciones regulares son los pilares de cualquier sistema de producción. PocketBase, aunque sencillo, no es una excepción. La pérdida de datos puede ser catastrófica, y el software obsoleto puede contener vulnerabilidades. Consideremos estrategias efectivas para garantizar la seguridad y la actualidad de su instalación PocketBase self-hosted.

Estrategias de copia de seguridad

Los componentes principales de los datos de PocketBase son el archivo de la base de datos SQLite (normalmente pb_data/data.db) y el directorio con los archivos cargados (pb_data/storage). Todo el directorio pb_data es críticamente importante para la copia de seguridad.

1. Copia de seguridad manual (para proyectos pequeños o antes de cambios importantes)

Antes de una copia de seguridad manual, se recomienda detener PocketBase para garantizar la integridad de los datos.

cd ~/pocketbase_app
docker compose stop pocketbase

Luego, simplemente copie el directorio pb_data:

cp -R pb_data pb_data_backup_$(date +%Y%m%d%H%M%S)

Después de copiar, puede iniciar PocketBase de nuevo:

docker compose start pocketbase

Este método es simple, pero no es adecuado para copias de seguridad automáticas regulares.

2. Copia de seguridad automática con Cron y Docker Volume

El mejor enfoque es automatizar el proceso. Podemos usar docker cp o simplemente copiar los datos del volumen montado.

Creación de un script para la copia de seguridad

Cree un script de copia de seguridad (por ejemplo, ~/pocketbase_app/backup.sh):

nano ~/pocketbase_app/backup.sh

Pegue el siguiente contenido:

#!/bin/bash

# Ruta al directorio de PocketBase en el host
PB_APP_DIR="/root/pocketbase_app" # Especifique su ruta
PB_DATA_DIR="${PB_APP_DIR}/pb_data"
BACKUP_DIR="${PB_APP_DIR}/backups"
TIMESTAMP=$(date +%Y%m%d%H%M%S)
BACKUP_FILE="${BACKUP_DIR}/pocketbase_backup_${TIMESTAMP}.tar.gz"
LOG_FILE="${BACKUP_DIR}/backup.log"

# Creamos el directorio para las copias de seguridad, si no existe
mkdir -p "$BACKUP_DIR"

echo "[$TIMESTAMP] Iniciando copia de seguridad de PocketBase..." | tee -a "$LOG_FILE"

# Opcional: Detener PocketBase para asegurar la consistencia (recomendado)
# Si no desea detenerlo, asegúrese de que PocketBase maneje correctamente la lectura de SQLite
# durante la escritura (el modo WAL está activado por defecto).
# docker compose -f "${PB_APP_DIR}/docker-compose.yml" stop pocketbase
# echo "[$TIMESTAMP] Contenedor de PocketBase detenido." | tee -a "$LOG_FILE"

# Creamos un archivo comprimido del directorio pb_data
if tar -czf "$BACKUP_FILE" -C "$PB_DATA_DIR" .; then
    echo "[$TIMESTAMP] Copia de seguridad creada: $BACKUP_FILE" | tee -a "$LOG_FILE"
else
    echo "[$TIMESTAMP] ERROR: Fallo al crear la copia de seguridad." | tee -a "$LOG_FILE"
    exit 1
fi

# Opcional: Iniciar PocketBase de nuevo
# docker compose -f "${PB_APP_DIR}/docker-compose.yml" start pocketbase
# echo "[$TIMESTAMP] Contenedor de PocketBase iniciado." | tee -a "$LOG_FILE"

# Eliminación de copias de seguridad antiguas (por ejemplo, más de 7 días)
find "$BACKUP_DIR" -name "pocketbase_backup_*.tar.gz" -mtime +7 -delete
echo "[$TIMESTAMP] Copias de seguridad antiguas eliminadas." | tee -a "$LOG_FILE"

echo "[$TIMESTAMP] Copia de seguridad de PocketBase finalizada." | tee -a "$LOG_FILE"

Haga que el script sea ejecutable:

chmod +x ~/pocketbase_app/backup.sh

Configuración de Cron para el lanzamiento automático

Añada una tarea a Cron para ejecutar el script diariamente (por ejemplo, a las 3 de la mañana).

crontab -e

Añada la siguiente línea al final del archivo:

0 3 * * * /root/pocketbase_app/backup.sh >> /root/pocketbase_app/backups/cron.log 2>&1

Esto ejecutará el script todos los días a las 03:00. Los logs de ejecución se escribirán en cron.log.

3. Almacenamiento remoto de copias de seguridad

Almacenar las copias de seguridad en el mismo servidor que los datos originales es arriesgado. Si pierde el servidor, perderá tanto los datos como las copias de seguridad. Se recomienda enviar las copias de seguridad a un almacenamiento remoto:

• Almacenamiento compatible con S3: Utilice aws s3 cp o rclone para enviar archivos a un almacenamiento en la nube (por ejemplo, AWS S3, DigitalOcean Spaces, Backblaze B2).
• SCP/SFTP: Copiar copias de seguridad a otro servidor o NAS a través de un protocolo seguro.

Integre estos comandos en su script backup.sh después de crear el archivo.

Proceso de actualización de PocketBase

Actualizar PocketBase a través de Docker Compose es un proceso sencillo, ¡pero siempre comience con una copia de seguridad!

1. Realice una copia de seguridad

Antes de cualquier actualización, siempre realice una copia de seguridad completa de los datos. Es su seguro.

cd ~/pocketbase_app
./backup.sh # Si tiene un script, o manualmente

2. Actualización de la imagen de Docker

Detenga el contenedor actual de PocketBase, descargue la nueva imagen y vuelva a iniciarlo.

cd ~/pocketbase_app
docker compose stop pocketbase
docker compose pull pocketbase # Descarga la última versión de la imagen
docker compose up -d pocketbase

El comando docker compose pull pocketbase descargará la última versión de la imagen de PocketBase. Luego, docker compose up -d pocketbase iniciará el contenedor con la nueva imagen, conservando todos sus datos (gracias al volumen montado pb_data). PocketBase realizará automáticamente las migraciones de base de datos necesarias en el primer inicio de la nueva versión.

3. Verificación de la actualización

Después de iniciar, asegúrese de que PocketBase funciona correctamente y verifique la versión en el panel de administración.

Las copias de seguridad regulares y las actualizaciones oportunas son la clave para la estabilidad y seguridad de su PocketBase en el servidor.

Qué VPS elegir para PocketBase: configuraciones para carga real

La elección del VPS adecuado para PocketBase depende de muchos factores, incluyendo el número de usuarios simultáneos, el volumen de datos, la intensidad de las operaciones de lectura/escritura, el uso de funciones en tiempo real y la presencia de servicios adicionales. Dado que PocketBase es muy eficiente, a menudo se pueden utilizar recursos más modestos que para los backends tradicionales.

Factores que influyen en la elección del VPS

• Número de usuarios simultáneos: Cuantos más usuarios interactúen activamente con su aplicación, más CPU y RAM se necesitarán para procesar las solicitudes.
• Volumen y complejidad de los datos: Grandes volúmenes de datos en SQLite y consultas complejas pueden requerir más RAM para el caching y un disco más potente.
• Uso de almacenamiento de archivos: Si su aplicación carga y sirve archivos activamente, esto aumentará la carga en el disco y el canal de red.
• Intensidad de las suscripciones en tiempo real: Un gran número de conexiones WebSocket activas puede consumir más RAM y CPU.
• Número de solicitudes API: Una alta frecuencia de solicitudes requiere más tiempo de procesador.
• Ubicación del servidor: Elija un VPS ubicado geográficamente cerca de su audiencia principal para minimizar las latencias.

Tabla de configuraciones de VPS recomendadas

A continuación se presenta una tabla con configuraciones de VPS aproximadas para diferentes escenarios de carga. Los precios son orientativos y pueden variar mucho según el proveedor y la región. Valebyte.com ofrece varios planes de tarifas que pueden adaptarse a estos requisitos.

Carga	CPU (vCores)	RAM (GB)	Disco (NVMe GB)	Ancho de banda	Precio aproximado ($/mes)
Desarrollo/Prototipo (1-5 usuarios)	1	1	25	100 Mbps	5-10
Proyecto pequeño (10-50 usuarios activos)	2	2	50	200 Mbps	10-25
Proyecto mediano (50-200 usuarios activos)	2-4	4-8	100-200	500 Mbps - 1 Gbps	25-60
Alta carga (200+ usuarios activos)	4-8+	8-16+	200-500+	1 Gbps+	60+

Recomendaciones adicionales para elegir un VPS

• Tipo de disco: Siempre elija un VPS con NVMe SSD. La velocidad de lectura/escritura es críticamente importante para SQLite, especialmente con operaciones activas de base de datos y archivos. La diferencia de rendimiento con los SSD o HDD normales es enorme.
• Virtualización KVM: Es preferible elegir un VPS con virtualización KVM, ya que proporciona un mejor aislamiento y rendimiento en comparación con OpenVZ. Puede obtener más información al respecto en el artículo KVM VPS vs OpenVZ VPS en 2026: ¿sigue siendo relevante?.
• VPS autogestionado (Self-managed): Dado que PocketBase es una solución self-hosted, lo más probable es que gestione el servidor usted mismo. Elegir un VPS autogestionado le permitirá ahorrar, pero requerirá habilidades básicas de administración de Linux. Para aquellos que duden, vale la pena familiarizarse con las diferencias: Self-managed vs Managed VPS en 2026: ¿cuál elegir?.
• Monitoreo: Después del despliegue, configure el monitoreo de su VPS (CPU, RAM, disco, red) y del propio PocketBase. Esto ayudará a identificar cuellos de botella y a escalar los recursos a tiempo.
• Escalado: Si su proyecto crece hasta cargas muy altas, es posible que deba considerar la transición a un servidor dedicado para obtener el máximo rendimiento y control.

Comenzando con configuraciones mínimas, puede aumentar gradualmente los recursos a medida que el proyecto crece, optimizando sus costes de alojamiento. La flexibilidad del VPS permite hacerlo sin problemas.

Cuestiones de seguridad y optimización para PocketBase self-hosted

El despliegue de PocketBase self-hosted en un VPS otorga control total, pero también impone la responsabilidad de la seguridad y el rendimiento. Las configuraciones y prácticas adecuadas ayudarán a proteger su aplicación y garantizar su funcionamiento estable.

Recomendaciones de seguridad del servidor

1. Claves SSH en lugar de contraseñas: Siempre use claves SSH para acceder al servidor y desactive la autenticación por contraseña para el usuario root. Esto aumenta significativamente la seguridad.
2. Usuario no-root: Cree un usuario separado con privilegios limitados para el trabajo diario y use sudo solo cuando sea necesario.
3. Firewall (UFW): Asegúrese de que el firewall esté configurado correctamente y que solo los puertos necesarios estén abiertos (22 para SSH, 80/443 para HTTP/HTTPS). El puerto 8090 de PocketBase debe ser accesible solo desde el interior del servidor (para el proxy inverso).
4. Actualizaciones regulares del SO: Mantenga el sistema operativo y todo el software instalado actualizados, ejecutando regularmente sudo apt update && sudo apt upgrade.
5. Fail2Ban: Instale y configure Fail2Ban para protegerse contra ataques de fuerza bruta en SSH y otros servicios.
6. Contraseñas complejas: Utilice contraseñas complejas y únicas para todas las cuentas, especialmente para el administrador de PocketBase.

Configuraciones de seguridad específicas de PocketBase

1. Acceso a la interfaz de administración (Admin UI): Asegúrese de que la interfaz de administración de PocketBase sea accesible solo a través de HTTPS y, si es posible, restrinja el acceso a ella por direcciones IP si su equipo trabaja desde ubicaciones fijas.
2. Reglas de API: En el panel de administración de PocketBase, configure cuidadosamente las reglas de acceso para cada colección. Defina quién puede leer, escribir, actualizar y eliminar registros (por ejemplo, solo usuarios autorizados, solo administradores o públicamente). Esto es críticamente importante para prevenir el acceso no autorizado a los datos.
3. CORS (Cross-Origin Resource Sharing): Configure los encabezados CORS correctos para permitir el acceso a su API solo desde dominios de confianza (su aplicación frontend). Esto se puede hacer a través de variables de entorno de PocketBase o a nivel del proxy inverso.
4. Limitación de solicitudes (Rate Limiting): Utilice las capacidades de su proxy inverso (Nginx o Caddy) para limitar el número de solicitudes desde una dirección IP en un período de tiempo. Esto ayudará a protegerse contra ataques DDoS y ataques de fuerza bruta.

   Ejemplo para Nginx:

   http {
               limit_req_zone $binary_remote_addr zone=one:10m rate=10r/s; # 10 solicitudes por segundo
   
               server {
                   # ...
                   location /api/ {
                       limit_req zone=one burst=20 nodelay;
                       # ...
                   }
               }
           }
           

5. Claves secretas: Si utiliza alguna clave secreta o tokens de API en las variables de entorno de PocketBase, asegúrese de que se almacenen de forma segura y no sean de acceso público.

Optimización del rendimiento de PocketBase

• SQLite PRAGMAs: PocketBase utiliza por defecto el modo WAL (Write-Ahead Logging) para SQLite, lo que mejora significativamente el rendimiento en operaciones simultáneas de lectura/escritura. Se pueden realizar optimizaciones adicionales con comandos PRAGMA, pero generalmente no es necesario.
• Índices de la base de datos: Asegúrese de que se creen índices para los campos de uso frecuente en sus colecciones. Esto acelerará significativamente las consultas a la base de datos. PocketBase permite gestionar índices a través de la interfaz de administración.
• Solicitudes API eficientes: Optimice las solicitudes de su frontend a la API de PocketBase. Utilice filtrado, clasificación y paginación en el lado del servidor para minimizar el volumen de datos transferidos.
• Caching: Para endpoints de API de alta carga que devuelven datos que rara vez cambian, considere el caching en el lado del cliente o utilizando un proxy inverso. PocketBase en sí mismo es muy rápido, por lo que el caching puede ser innecesario para la mayoría de los casos.
• Optimización de imágenes y archivos: Si su aplicación trabaja activamente con imágenes, utilice servicios para su optimización y compresión antes de cargarlas, para reducir el volumen de datos y acelerar la carga.

Siguiendo estas recomendaciones, garantizará no solo la seguridad, sino también el alto rendimiento de su PocketBase en el servidor, permitiéndole servir eficazmente a su aplicación.

Conclusiones

PocketBase representa una solución excepcional para los desarrolladores que buscan velocidad, simplicidad y control total sobre su backend. Desplegado en un VPS, se convierte en una herramienta potente, económica y flexible para crear una amplia gama de aplicaciones, desde prototipos hasta servicios de producción completos. Siguiendo las instrucciones paso a paso para la instalación de PocketBase a través de Docker Compose, la configuración de acceso seguro mediante un proxy inverso y HTTPS, y la implementación de estrategias de copias de seguridad y actualizaciones, obtendrá una plataforma fiable y fácil de gestionar.

Para un funcionamiento óptimo de PocketBase, se recomienda elegir un VPS con discos NVMe y suficiente RAM, en función de la carga esperada. Proveedores como Valebyte.com ofrecen una amplia selección de configuraciones de VPS que son ideales para el despliegue de PocketBase, garantizando el rendimiento y la fiabilidad necesarios para su proyecto.