Pocketbase

PocketBase en Production 2026

PocketBase en Production 2025 : Déploiement Sécurisé, Docker, TLS et Nginx

PocketBase est un outil backend open-source qui simplifie la vie des développeurs, surtout pour les petites équipes ou les startups qui veulent un serveur complet sans complications. Si vous avez testé PocketBase en local, vous savez déjà qu'il est facile à lancer. Mais pour passer en production, il faut sécuriser l'ensemble, assurer la disponibilité 24/7 et éviter les pièges courants. Cet article vous guide pas à pas pour transformer votre instance locale en un serveur fiable. Nous couvrons l'hébergement, le TLS automatique, les reverse proxies comme Nginx ou Caddy, le déploiement avec Docker et systemd, les variables d'environnement, et les pratiques de sécurité essentielles. Tout est basé sur la documentation officielle de PocketBase, mise à jour en 2025.

L'objectif ? Vous permettre de déployer sans stress, en évitant les pertes de données ou les vulnérabilités. Prévoyez environ 30 minutes pour un premier déploiement basique. Allons-y.

1. Hébergement Recommandé pour PocketBase

Choisir un hébergeur adapté est la première étape. PocketBase est un exécutable Go portable : il ne dépend d'aucune base de données externe ni de services tiers obligatoires. Vous pouvez l'héberger sur n'importe quel serveur Linux (comme Ubuntu 22.04 ou Debian) tant qu'il supporte les binaires Go. Pour les startups et SMB, optez pour des options simples et scalables.

Options d'Hébergement Simples

  • VPS Basiques (DigitalOcean, Linode ou OVH) : Un droplet à 5-10 €/mois suffit pour démarrer. Installez Ubuntu, uploadez l'exécutable, et c'est parti. Avantage : contrôle total, IP dédiée pour le TLS.
  • Cloud Gratuit ou Low-Cost (Fly.io, Render ou Heroku) : Fly.io est idéal pour PocketBase grâce à son support natif des exécutables Go. Vous déployez en une commande et bénéficiez de TLS gratuit. Exemple : fly launch après avoir configuré un fly.toml.
  • Serveurs Dédiés pour Équipes Plus Grandes : Si vous gérez plusieurs apps, un serveur comme Hetzner (à partir de 3 €/mois) avec un reverse proxy permet d'isoler les instances.

Pour un déploiement minimal, commencez par un VPS Ubuntu. Connectez-vous en SSH et créez un dossier pour votre app :

mkdir /root/pb
cd /root/pb

Téléchargez la dernière version de PocketBase (v0.34.0 en 2025) depuis GitHub et rendez-la exécutable :

wget https://github.com/pocketbase/pocketbase/releases/download/v0.34.0/pocketbase_0.34.0_linux_amd64.zip
unzip pocketbase_0.34.0_linux_amd64.zip
chmod +x pocketbase

Votre structure de dossiers devrait ressembler à ça :

pb/
├── pb_migrations/  # Pour les futures migrations
├── pb_hooks/       # Pour les hooks JS/Go
└── pocketbase      # L'exécutable

C'est la base. PocketBase stocke tout (base SQLite, fichiers uploadés) dans pb_data, créé automatiquement au premier lancement. Assurez-vous que ce dossier est sur un volume persistant pour éviter les pertes en cas de redémarrage.

Si vous gérez plusieurs apps, un reverse proxy (voir section 3) est indispensable pour router le trafic sans exposer chaque instance directement.

2. TLS Automatique avec Let's Encrypt

La sécurité commence par HTTPS. Sans TLS, vos données transitent en clair, ce qui est inacceptable en production. PocketBase intègre un support natif pour Let's Encrypt : il gère les certificats automatiquement.

Comment Activer le TLS Auto

Lancez simplement PocketBase avec votre domaine comme argument :

/root/pb/pocketbase serve yourdomain.com
  • PocketBase contacte Let's Encrypt via le port 80 pour valider le domaine (ACME challenge).
  • Il génère et renouvelle les certificats tous les 90 jours.
  • Ports requis : 80 (HTTP pour la validation) et 443 (HTTPS pour le trafic).

Pour un VPS standard, exécutez en root pour binder ces ports. Si vous n'êtes pas root, utilisez setcap :

sudo setcap 'cap_net_bind_service=+ep' /root/pb/pocketbase

Puis lancez en utilisateur normal. Testez avec curl https://yourdomain.com/_/ : vous devriez voir la page d'accueil de PocketBase.

Points d'Attention pour Débutants

  • DNS Config : Pointez votre domaine A/AAAA vers l'IP du serveur avant de lancer.
  • Pare-feu : Ouvrez les ports 80 et 443 avec UFW : ufw allow 80,443/tcp.
  • Erreurs Courantes : Si la validation échoue (ex. : "challenge failed"), vérifiez que le port 80 n'est pas bloqué et que le domaine résout bien. Let's Encrypt limite à 5 échecs par heure.

En production, redirigez HTTP vers HTTPS dans votre reverse proxy (voir ci-après). Ça protège vos API et l'interface admin dès le départ.

3. Reverse Proxy : Nginx ou Caddy pour Plus de Contrôle

Un reverse proxy place PocketBase derrière un serveur web dédié, ajoutant sécurité, caching et routage. C'est recommandé pour les startups qui veulent scaler ou isoler plusieurs services. PocketBase écoute par défaut sur le port 8090 en HTTP ; le proxy gère le TLS et forwarde.

Pourquoi un Reverse Proxy ?

  • Masque l'IP interne de PocketBase.
  • Gère les gros uploads (limite body size).
  • Active les headers pour logger les vrais IPs clients (X-Real-IP, X-Forwarded-For).
  • Évite les subpaths : utilisez des sous-domaines (api.yourdomain.com) pour l'isolation same-origin (localStorage, CORS).

Configuration Nginx

Installez Nginx : apt install nginx. Créez /etc/nginx/sites-available/pocketbase :

server {
    listen 80;
    server_name yourdomain.com;

    client_max_body_size 10M;  # Pour les uploads

    location / {
        proxy_set_header Connection '';
        proxy_http_version 1.1;
        proxy_read_timeout 360s;  # Timeout long pour les ops DB

        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;

        proxy_pass http://127.0.0.1:8090;
    }
}

Activez : ln -s /etc/nginx/sites-available/pocketbase /etc/nginx/sites-enabled/ && nginx -t && systemctl reload nginx. Lancez PocketBase sur 8090 sans domaine (TLS géré par Nginx). Ajoutez Certbot pour TLS : certbot --nginx.

Configuration Caddy (Plus Simple)

Caddy est "zero-config" pour TLS. Installez-le via apt install caddy. Éditez /etc/caddy/Caddyfile :

yourdomain.com {
    request_body {
        max_size 10MB
    }
    reverse_proxy 127.0.0.1:8090 {
        transport http {
            read_timeout 360s
        }
    }
}

Relancez : systemctl reload caddy. Caddy obtient Let's Encrypt automatiquement. Pour les SMB, Caddy est plus rapide à setup que Nginx.

Dans les settings PocketBase (Dashboard > Settings), activez les headers proxy pour que les logs capturent les IPs réelles.

4. Docker et Systemd : Pour une Disponibilité 24/7

En production, votre serveur ne doit pas s'arrêter à chaque redémarrage ou crash. Docker containerise PocketBase, et systemd le gère comme un service.

Déploiement avec Docker

PocketBase n'a pas d'image officielle, mais c'est facile à créer. Dockerfile minimal :

FROM alpine:latest

ARG PB_VERSION=0.34.0

RUN apk add --no-cache unzip ca-certificates

ADD https://github.com/pocketbase/pocketbase/releases/download/v${PB_VERSION}/pocketbase_${PB_VERSION}_linux_amd64.zip /tmp/pb.zip
RUN unzip /tmp/pb.zip -d /pb/

# Copiez vos migrations et hooks si besoin
# COPY ./pb_migrations /pb/pb_migrations
# COPY ./pb_hooks /pb/pb_hooks

EXPOSE 8080

CMD ["/pb/pocketbase", "serve", "--http=0.0.0.0:8080"]

Build et run :

docker build -t pocketbase .
docker run -d -p 8080:8080 -v /host/pb_data:/pb/pb_data --name pb pocketbase
  • Le volume -v persiste pb_data (DB + fichiers).
  • Pour Docker Compose (idéal pour startups) : Ajoutez un docker-compose.yml avec restart: always.

Sur Fly.io, déployez en gratuit : flyctl auth login, puis fly launch avec le Dockerfile.

Gestion avec Systemd

Pour un déploiement bare-metal, créez /lib/systemd/system/pocketbase.service :

[Unit]
Description=PocketBase
After=network.target

[Service]
Type=simple
User=root
Group=root
LimitNOFILE=4096  # Pour plus de connexions
Restart=always
RestartSec=5s
StandardOutput=append:/root/pb/std.log
StandardError=append:/root/pb/std.log
WorkingDirectory=/root/pb
ExecStart=/root/pb/pocketbase serve yourdomain.com

[Install]
WantedBy=multi-user.target

Activez : systemctl daemon-reload && systemctl enable pocketbase && systemctl start pocketbase. Vérifiez les logs : journalctl -u pocketbase -f ou dans /root/pb/std.log. Le premier superuser se crée via ./pocketbase superuser create [email protected] password.

Avec systemd, PocketBase redémarre auto après crash ou reboot. Pour Docker, utilisez docker run --restart always.

5. Variables d'Environnement : Sécuriser et Configurer

Les variables d'environnement gardent les secrets hors du code. PocketBase en utilise peu, mais elles sont cruciales pour la sécurité.

PB_ENCRYPTION_KEY : Chiffrer les Settings

Par défaut, les settings (mots de passe SMTP, creds S3) sont en clair dans la DB. Chiffrez-les avec une clé de 32 caractères :

export PB_ENCRYPTION_KEY="tQ7b9Mb8USUOIDLCCkTCwARUtEtoTCKG"

Lancez avec : ./pocketbase serve --encryptionEnv=PB_ENCRYPTION_KEY. Les backups deviennent inutilisables sans la clé, protégeant contre les fuites.

Générez la clé : openssl rand -base64 24. Stockez-la dans /etc/environment ou un .env (chargez avec source .env).

GOMEMLIMIT : Gérer la Mémoire

Sur serveurs limités, évitez les OOM kills :

export GOMEMLIMIT=512MiB

Ça force le garbage collector Go à être plus agressif. Utile pour VPS à 1 Go RAM.

Autres vars : PB_PUBLICURL pour forcer l'URL publique si derrière proxy.

6. Sécurité en Production : Les Bases pour Éviter les Pannes

La sécurité n'est pas optionnelle. PocketBase est sécurisé par défaut, mais suivez ces étapes.

MFA pour Superusers

Activez l'auth multi-facteurs dans Dashboard > Settings > _superusers. Ça envoie un OTP par email à chaque login. Si email down, générez manuellement : ./pocketbase superuser otp [email protected].

Rate Limiter Anti-Abus

Depuis v0.23, configurez-le dans Settings > Application : limitez les requêtes auth ou CRUD par IP. Ex. : 10 logins/minute. Ça stoppe les bots.

SMTP pour Emails Fiables

Évitez sendmail Unix (marqué spam). Utilisez MailerSend, Brevo ou SendGrid. Dans Settings > Mail : entrez host, port, user/pass. Testez avec un envoi de vérif.

Limite de Fichiers Ouverts

Augmentez ulimit -n 4096 pour gérer +1000 connexions. Ajoutez dans le service systemd : LimitNOFILE=4096.

Autres Pratiques

  • Pare-feu : UFW allow only 22 (SSH), 80/443.
  • Updates : Relancez avec la dernière version périodiquement.
  • Monitoring : Utilisez api/_health pour checks automatisés.

7. Backups : Ne Perdez Jamais Vos Données

Les backups sauvent les startups d'un crash disque. PocketBase zippe pb_data (DB + fichiers) via API.

Backups Manuels

Arrêtez le serveur, copiez pb_data : rsync -av /root/pb/pb_data/ backup@server:/backups/$(date +%Y%m%d).tar.gz. Redémarrez.

Backups Auto via API

Dans Dashboard > Settings > Backups, activez et pointez vers S3 (bucket dédié). Ça met en read-only pendant le zip. Pour gros volumes (>2GB), script custom : sqlite3 pb_data/data.db .backup backup.db && rsync fichiers/.

Programmez avec cron : 0 2 * * * /root/backup.sh. Stockez off-site (S3, Backblaze).

Conclusion : Votre Backend Prod est Prêt

Vous avez maintenant un PocketBase en production : hébergé, sécurisé par TLS, proxifié, containerisé, et backupé. Pour une startup, ça scale à des milliers d'utilisateurs sans refactor. Testez tout : créez un superuser, uploadez un fichier, vérifiez les logs. Si bloqué, consultez les logs ou la doc officielle.

Prochain article : Migrations pour évoluer votre DB. Questions ? Commentez ci-dessous.

Partager Partager Partager Partager Partager Email

Lire la suite