Pocketbase

PocketBase 2026 : Installation et Démarrage en 5 minutes – Guide Débutant Complet

PocketBase 2026 : Installation et Démarrage en 5 minutes – Guide Débutant Complet

Bonjour et bienvenue sur pocketbase.fr, votre ressource dédiée à PocketBase, le backend open-source qui simplifie la vie des développeurs. Si vous êtes un débutant, un responsable SMB qui veut prototyper rapidement une application, ou un fondateur de startup cherchant un outil léger pour valider une idée sans investir dans une infrastructure complexe, cet article est fait pour vous. Nous allons explorer PocketBase de A à Z : de sa définition aux premiers pas concrets.

PocketBase est un backend open-source tout-en-un, livré en un seul fichier exécutable. Il intègre une base de données SQLite, une API REST-ish, une gestion d'authentification, des abonnements en temps réel, et une interface d'administration intuitive. Pas de configuration interminable, pas de dépendances multiples : vous lancez un binaire, et tout fonctionne. Idéal pour les projets solos ou les équipes petites qui veulent se concentrer sur le code métier plutôt que sur l'infrastructure.

Dans cet article, nous suivons une approche pas-à-pas. Nous couvrirons :

  1. Qu’est-ce que PocketBase ?
  2. Téléchargement & Installation.
  3. Premier lancement.
  4. Création de l'admin.
  5. Tour de l’interface.
  6. Concepts clés.

À la fin, vous aurez une instance PocketBase opérationnelle en moins de 5 minutes. Prêt ? Allons-y.

1. Qu’est-ce que PocketBase ?

PocketBase est un outil backend conçu pour être simple et puissant. Imaginez un serveur qui gère tout : stockage de données, authentification des utilisateurs, API pour vos apps frontend, et même des mises à jour en temps réel. Tout cela sans installer un stack LAMP ou configurer des services séparés comme MySQL, Node.js ou Firebase.

Pourquoi PocketBase pour les débutants, SMB et startups ?

  • Simplicité : Un seul fichier (environ 10 Mo) à télécharger et exécuter. Pas de Docker obligatoire pour démarrer, bien que vous puissiez l'ajouter plus tard.
  • Open-source : Gratuit, sous licence MIT, avec une communauté active sur GitHub. Vous pouvez l'inspecter, le modifier, ou l'étendre.
  • Fonctionnalités intégrées :
    • Base de données : SQLite embarquée, qui supporte jusqu'à des millions d'enregistrements pour des apps de petite à moyenne échelle.
    • API REST-ish : Endpoints automatiques pour CRUD (Create, Read, Update, Delete) sur vos données.
    • Authentification : Support pour email/password, OAuth2 (Google, GitHub), OTP (SMS), et MFA (authentification multi-facteurs).
    • Temps réel : Abonnements WebSocket pour des mises à jour live, comme dans un chat ou un dashboard.
    • Interface admin : Un dashboard web pour gérer vos données sans code.
    • Gestion de fichiers : Upload direct vers le stockage local ou cloud (S3 compatible).
  • Portabilité : Fonctionne sur Windows, macOS, Linux (x64 et ARM64). Vous pouvez le déployer sur un VPS basique, Heroku, ou un Raspberry Pi.

Pour un SMB, cela signifie que votre équipe peut prototyper une app client (gestion de stocks, CRM simple) sans embaucher un DevOps. Pour une startup, c'est parfait pour un MVP : validez votre idée avec une API prête en heures, pas en semaines.

La version actuelle est la 0.34.0 (novembre 2025). PocketBase est en développement actif, mais stable pour la plupart des usages. Notez que la compatibilité arrière n'est pas garantie avant la v1.0.0, donc suivez les mises à jour via le changelog sur GitHub.

En résumé, PocketBase remplace un backend traditionnel par quelque chose de plus agile. Si vous avez déjà utilisé Supabase ou Appwrite, c'est similaire, mais plus léger et auto-hébergé par défaut.

2. Téléchargement & Installation

Passons aux choses sérieuses. L'installation est triviale : téléchargez, extrayez, exécutez. Aucune dépendance externe n'est requise, car tout est compilé dans le binaire.

Étape 1 : Choisir la bonne version

Allez sur la page des releases GitHub : github.com/pocketbase/pocketbase/releases. Téléchargez la v0.34.0 (ou la plus récente) adaptée à votre système :

  • Linux x64 : pocketbase_0.34.0_linux_amd64.zip
  • Windows x64 : pocketbase_0.34.0_windows_amd64.zip
  • macOS x64 : pocketbase_0.34.0_darwin_amd64.zip
  • Linux ARM64 (ex. Raspberry Pi 5) : pocketbase_0.34.0_linux_arm64.zip
  • Windows ARM64 : pocketbase_0.34.0_windows_arm64.zip
  • macOS ARM64 (Apple Silicon) : pocketbase_0.34.0_darwin_arm64.zip

Pour les autres architectures, compilez depuis le source avec Go 1.21+.

Étape 2 : Télécharger et extraire

  • Sur Windows : Utilisez un outil comme 7-Zip pour extraire le ZIP. Vous obtenez pocketbase.exe.

Sur macOS/Linux : Ouvrez un terminal, naviguez vers le dossier de téléchargement, et exécutez :

unzip pocketbase_0.34.0_linux_amd64.zip  # ou darwin pour macOS

Cela crée l'exécutable pocketbase.

Placez le fichier dans un dossier dédié, comme ~/pocketbase/ sur Linux/macOS ou C:\pocketbase\ sur Windows. Ajoutez ce dossier à votre PATH si vous voulez l'exécuter de n'importe où (optionnel pour débuter).

Étape 3 : Permissions (Linux/macOS seulement)

Rendez l'exécutable exécutable :

chmod +x pocketbase

Vérification

Tapez ./pocketbase --help (ou pocketbase.exe --help sur Windows). Vous devriez voir la liste des commandes : serve, migrate, destroy, etc. Si cela fonctionne, l'installation est réussie.

Temps estimé : 1 minute. Pour un SMB sur un laptop partagé, c'est idéal – pas d'installation système.

3. Premier lancement

Maintenant, lancez le serveur. C'est là que la magie opère : PocketBase crée automatiquement sa base de données et ses répertoires.

Étape 1 : Lancer le serveur

Dans le terminal (ou invite de commandes), naviguez vers le dossier et exécutez :

./pocketbase serve
  • Sur Windows : pocketbase.exe serve.

Par défaut, le serveur écoute sur http://127.0.0.1:8090. Vous verrez un output comme :

2025/11/30 10:00:00 [INFO] Using sqlite as the database.
2025/11/30 10:00:00 [INFO] No migrations found.
2025/11/30 10:00:00 [INFO] HTTP Server listening on [::]:8090

Ce qui se passe en arrière-plan

  • PocketBase initialise une base SQLite dans ./pb_data/data.db.
  • Il crée des répertoires :
    • pb_data/ : Données persistantes (base, fichiers uploads). Ajoutez-le à .gitignore pour les projets Git.
    • pb_migrations/ : Scripts de migration JS (commitez-les pour versionner les changements de schéma).
    • pb_public/ (si présent) : Fichiers statiques servis sur la racine du serveur.
    • pb_hooks/ : Pour les extensions JS (nous en parlerons plus tard).

Ports et personnalisation

  • Port par défaut : 8090. Changez-le avec ./pocketbase serve --http=0.0.0.0:3000.
  • Adresse : 127.0.0.1 pour local. Pour réseau local : --http=0.0.0.0:8090.
  • Logs : Actifs par défaut. Pour plus de détails : --logLevel=debug.

Si vous rencontrez une erreur (ex. port occupé), changez le port ou tuez le processus existant.

Ouvrez votre navigateur sur http://127.0.0.1:8090. Vous verrez une page d'accueil basique (si pb_public existe) ou directement l'API sur /api/health. Le serveur est live !

Temps estimé : 30 secondes. Pour une startup, testez déjà l'API avec un outil comme Postman : GET http://127.0.0.1:8090/api/health retourne {"code":200,"health":{"database":{"ok":true},"migrations":{"ok":true}}}.

4. Création de l'admin

Sans admin, vous ne pouvez pas gérer l'interface. PocketBase génère un lien unique pour cela.

Étape 1 : Accéder au lien d'installation

Lors du premier lancement, le terminal affiche :

2025/11/30 10:00:00 [INFO] To initialize the application first user (aka admin) visit: http://127.0.0.1:8090/_/setup

Cliquez sur ce lien. Vous arrivez sur une page simple : champs pour email, mot de passe, et confirmation.

Étape 2 : Créer le compte

  • Email : Utilisez un email valide (ex. [email protected]).
  • Mot de passe : Minimum 8 caractères, incluez majuscules, minuscules, chiffres pour sécurité.
  • Cliquez Create.

Succès ! Vous êtes connecté comme superutilisateur. Ce compte a accès total : créer/supprimer collections, gérer users, etc.

Sécurité dès le départ

  • Changez le mot de passe régulièrement via l'interface.
  • Activez MFA plus tard (dans Settings > Auth).
  • Ne partagez pas ce lien – il expire après usage.

Si vous perdez l'accès, supprimez pb_data/ et relancez (perte de données, à éviter en prod).

Temps estimé : 20 secondes. Pour un débutant SMB, c'est rassurant : un admin unique pour commencer, scalable ensuite.

5. Tour de l’interface

L'interface admin (dashboard) est sur http://127.0.0.1:8090/_/. Connectez-vous avec vos identifiants. C'est une app web responsive, construite avec Svelte, qui s'adapte à mobile/desktop.

  • Sidebar gauche :
    • Dashboard : Aperçu global (stats users, collections, logs récents).
    • Collections : Gérez vos "tables" de données.
    • Records : Vue unifiée sur tous les enregistrements (recherche, filtres).
    • Auth : Gestion des utilisateurs (créer, bloquer, reset password).
    • Settings : Configuration serveur (email SMTP, OAuth providers, backups).
    • Logs : Historique des événements (erreurs, auth fails).
    • Realtime : Monitor des connexions live.

Première vue : Dashboard

  • Métriques : Nombre de collections, records, users actifs.
  • Graphiques simples : Activité récente (connexions, API calls).
  • Boutons rapides : Nouvelle collection, import JSON.

Gérer les Collections

Cliquez Collections. Par défaut, une collection "Example" existe (avec champs title, content).

  • + New Collection : Créez "users" (type Auth) ou "posts" (type Base).
  • Pour chaque collection : Ajoutez champs (text, number, relation, file), définissez règles d'accès (ex. "@request.auth.id != '' pour users loggés").
  • Boutons : List records, Export CSV/JSON, Delete.

Exemple : Créez une collection "Produits" pour votre SMB.

  1. Nom : products.
  2. Type : Base.
  3. Champs : name (text), price (number), image (file).
  4. Sauvegardez – l'API est auto-générée (/api/collections/products/records).

Records

  • Sélectionnez une collection : Vue tableau avec colonnes.
  • Actions : + New (formulaire auto), Edit/Delete ligne, Bulk actions.
  • Filtres : Par champ, sort, pagination (défaut 50/page).
  • Recherche : Texte libre sur tous champs.

Ajoutez un record test : Nom "Produit A", Prix 29.99. Il apparaît instantanément.

Auth et Settings

  • Auth : Listez users, envoyez reset email, activez providers OAuth.
  • Settings :
    • App info : Nom app, version.
    • Email : Configurez SMTP pour notifications (Gmail, SendGrid).
    • Auth providers : Ajoutez Google OAuth (clés API).
    • Backups : Automatisez vers S3 ou local.
    • Realtime : Activez subscriptions.

L'interface est intuitive : tooltips partout, validation en temps réel. Pour mobile, ça marche bien pour un check rapide.

Temps pour explorer : 2 minutes. Astuce startup : Utilisez-la pour onboarder un non-tech (ex. marketer ajoutant produits).

6. Concepts clés

Maintenant que c'est lancé, comprenons les bases pour éviter les pièges courants.

Collections : Vos tables dynamiques

Une collection est comme une table SQL, mais visuelle.

  • Types :
    • Base : Données standard (ex. posts, produits).
    • Auth : Pour users (champs email, password auto-gérés).
    • View : Requêtes virtuelles (ex. jointures SQL).
  • Champs : 20+ types (text, json, relation 1-n/n-n, geoPoint).
  • Règles : Expressions comme id = @request.auth.id pour sécurité.
  • Index : Auto sur ID, custom pour perf (ex. sur email).

Créez-en une pour tester : "Tasks" avec champs title (text), done (bool).

Records : Vos lignes de données

  • Chaque record a un ID unique (UUID), created/updated timestamps.
  • Opérations via UI ou API : POST /api/collections/tasks/records pour créer.
  • Relations : Liez à d'autres collections (ex. task.userId → users collection).
  • Fichiers : Attachez images ; thumbnails auto-générés.

Exemple API simple (testez avec curl) :

curl -X POST http://127.0.0.1:8090/api/collections/tasks/records \
  -H "Content-Type: application/json" \
  -d '{"title": "Test task", "done": false}'

Réponse : JSON avec ID et données.

Authentification de base

  • Collection users auto-créée.
  • Login : POST /api/collections/users/auth-with-password avec email/password.
  • Tokens : JWT pour sessions (expire en 60 jours par défaut).
  • Refresh : Endpoint dédié pour renouveler sans re-login.

Pour votre app frontend : Utilisez le SDK JS (npm install pocketbase) :

import PocketBase from 'pocketbase';
const pb = new PocketBase('http://127.0.0.1:8090');
await pb.collection('users').authWithPassword('[email protected]', 'password');

Temps réel

Abonnez-vous : pb.collection('tasks').subscribe('*', (e) => console.log(e.record));. Mises à jour push sur create/update/delete.

Bonnes pratiques pour débutants

  • Backup : Copiez pb_data/ régulièrement.
  • Dev vs Prod : En dev, utilisez SQLite ; en prod, envisagez migrations.
  • Sécurité : Toujours HTTPS (ajoutez NGINX reverse proxy).
  • Scaling : Pour >10k users, monitorez CPU ; migrez vers Postgres si besoin (via hooks).
  • Erreurs courantes : Port occupé ? Changez-le. Pas de données ? Vérifiez pb_data permissions.

Pour SMB/startups : Commencez avec l'UI pour prototyper, passez à API pour l'app réelle. Intégrez avec Next.js ou Flutter en 1h.

Conclusion : Votre premier projet avec PocketBase

Félicitations ! Vous avez installé, lancé, et exploré PocketBase. En 5 minutes, vous avez un backend fonctionnel : base de données, API, auth. C'est le point de départ idéal pour un dashboard SMB (gestion clients) ou un MVP startup (app todo avec realtime).

Prochaines étapes :

  • Lisez notre guide sur les collections pour structurer vos données.
  • Testez l'API avec Postman.
  • Déployez en prod (prochain article).

Des questions ? Commentez ci-dessous. Suivez pocketbase.fr pour plus de tutoriels. Bonne codage !

Partager Partager Partager Partager Partager Email

Lire la suite