
Choisissez SQLite lorsqu’une application peut gérer sa base localement et que ses écritures conviennent à ce fonctionnement. Choisissez PostgreSQL lorsqu’il vous faut un service de base de données partagé entre plusieurs clients, davantage de souplesse pour les écritures concurrentes, ou des fonctions et contrôles d’accès qui justifient l’exploitation d’un serveur.
Le choix entre SQLite et PostgreSQL concerne l’architecture de l’application. Une petite application peut avoir besoin de PostgreSQL parce que plusieurs services y écrivent. Une application en production peut fonctionner avec SQLite lorsque ses accès s’y prêtent. Le volume de données ou le nombre d’utilisateurs ne suffit pas à trancher.
Ce guide présente une expérience locale avec SQLite 3.53.1 et PostgreSQL 18.6, pilotée par Python 3.12.14. Les 15 vérifications ont réussi. Elles portent sur des lignes synthétiques, les contraintes, l’annulation, des transactions qui se chevauchent et une réouverture ou un redémarrage propre. Elles ne mesurent ni le débit, ni la récupération après incident, ni la restauration d’une sauvegarde, ni un déploiement cloud.
SQLite s’exécute dans le processus de l’application, au moyen d’une bibliothèque. L’application ouvre un fichier de base de données sur le stockage local auquel elle a accès. Plusieurs connexions et processus peuvent utiliser ce fichier en respectant les règles de verrouillage de SQLite. Une base embarquée n’implique donc pas un seul utilisateur.
PostgreSQL suit une architecture client-serveur. Les applications envoient leurs requêtes à un serveur qui gère les fichiers de la base et coordonne les accès. L’application et le serveur peuvent se trouver sur la même machine ou sur des machines différentes. Choisir PostgreSQL n’oblige pas à les séparer immédiatement sur deux VM.
Représentez les connexions avant de choisir le moteur. Un seul service gère-t-il les données ? Plusieurs instances de l’application doivent-elles accéder indépendamment à la base ? Combien de temps les transactions d’écriture restent-elles ouvertes ? Qui s’occupera de la maintenance et de la récupération ?
| Question | SQLite | PostgreSQL |
|---|---|---|
| Comment l’application se connecte-t-elle ? | Par une bibliothèque embarquée qui ouvre la base. | Par une connexion à un processus serveur. |
| Que faut-il exploiter ? | L’application, les fichiers, les permissions, les sauvegardes et les verrouillages. | Ces éléments, ainsi que le service de base de données, l’authentification, les connexions et la maintenance du serveur. |
| Comment les écritures se chevauchent-elles ? | Une seule transaction d’écriture à la fois par base, y compris en mode WAL. | Des écritures sur des lignes différentes peuvent se chevaucher ; les opérations en conflit peuvent attendre ou échouer. |
| Plusieurs machines peuvent-elles partager les accès ? | Il ne faut pas supposer qu’un fichier SQLite monté sur le réseau convient, notamment avec WAL. | Les clients peuvent joindre le serveur par un accès réseau contrôlé. |
| Quel cas d’usage envisager au départ ? | État local d’une application, outils locaux et services dont le profil d’écriture convient. | Données applicatives partagées entre des clients indépendants, avec des besoins de gestion au niveau serveur. |
Les recommandations d’usage de SQLite incluent les sites web et le stockage applicatif côté serveur. Sa simplicité ne le réserve pas aux prototypes. De même, choisir PostgreSQL crée un travail d’exploitation à confier à votre équipe ou à un fournisseur de service géré.
Notre exemple de webhook Python, en anglais utilise une boîte de réception SQLite locale pour un traitement limité. Il illustre un état géré par l’application ; il ne démontre pas que tous les systèmes de workers distribués devraient partager le même fichier SQLite.
Utilisez une nouvelle base de test vide et deux connexions à cette même base. N’exécutez pas cette préparation sur des données applicatives. Notre test SQLite utilisait un fichier local réel en mode WAL. PostgreSQL fonctionnait dans une instance jetable distincte, accessible uniquement par l’adresse de boucle locale, avec son niveau d’isolation Read Committed par défaut.
Créez cette petite table une seule fois dans chaque base de test, sans transaction déjà ouverte :
CREATE TABLE task_state (
id INTEGER PRIMARY KEY,
status TEXT NOT NULL CHECK (status IN ('queued', 'done'))
);
INSERT INTO task_state (id, status) VALUES (1, 'queued'), (2, 'queued');
Pour SQLite, activez WAL avant l’expérience et réglez le délai d’attente sur les deux connexions :
PRAGMA journal_mode = WAL;
PRAGMA busy_timeout = 200;
Pour PostgreSQL, réglez ce délai de verrouillage dans les deux sessions :
SET lock_timeout = '200ms';
Les limites de 200 ms rendent la contention visible dans ce petit test. Ce ne sont pas des recommandations pour la production. Dans la session A, modifiez la première ligne et laissez la transaction ouverte :
BEGIN;
UPDATE task_state SET status = 'done' WHERE id = 1;
-- Leave this transaction open while session B runs.
Pendant que A reste ouverte, exécutez ceci dans la session B :
BEGIN;
UPDATE task_state SET status = 'done' WHERE id = 2;
Avec SQLite, la modification de B atteint le délai d’attente et échoue avec SQLITE_BUSY. Exécutez ROLLBACK; dans B, puis COMMIT; dans A. Relancer la transaction de B réussit alors ; validez-la ensuite.
Avec PostgreSQL, B peut modifier l’autre ligne pendant que A reste ouverte. Validez B, puis A. Les deux lignes ont désormais l’état done. Nous avons aussi testé séparément une écriture sur la ligne 1 pendant que A la verrouillait : PostgreSQL a atteint le délai de verrouillage avec le code SQLSTATE 55P03, puis cette transaction a été annulée.
| Vérification observée | SQLite WAL | PostgreSQL |
|---|---|---|
| Lecture ordinaire pendant une modification non validée de A | Renvoie la valeur précédemment validée. | Renvoie la valeur précédemment validée. |
| B écrit sur une autre ligne pendant que A reste ouverte | Bloquée jusqu’au délai d’attente. | Exécutée et validée. |
| Écriture en conflit sur la ligne de A | Relève de la restriction à un seul écrivain ; pas de test SQLite distinct. | Atteint le délai de verrouillage configuré. |
| Annulation et état invalide | L’annulation préserve l’état précédent ; la contrainte CHECK refuse la valeur invalide. | Mêmes résultats. |
| Valeurs validées après une fermeture ou un redémarrage propre | Présentes après fermeture et réouverture de toutes les connexions. | Présentes après un redémarrage propre du serveur. |
Le mode WAL de SQLite autorise des lectures pendant une écriture, mais conserve un seul écrivain à la fois. Sa coordination par mémoire partagée rend également important l’accès depuis une même machine. Un bucket de stockage objet ou un fichier monté sur le réseau ne remplace pas une configuration locale prise en charge.
L’échec SQLite de notre test provient d’une transaction d’écriture délibérément laissée ouverte. Il ne fixe aucun débit maximal. Des transactions courtes et un profil d’écriture adapté peuvent traiter de nombreuses requêtes sans reproduire cette situation précise de contention.
Les règles de verrouillage de PostgreSQL permettent le comportement observé sur deux lignes indépendantes, tandis que les modifications en conflit restent en concurrence. Le niveau d’isolation influe aussi sur les valeurs visibles et les échecs que l’application doit gérer. Augmenter le nombre de connexions ne garantit pas davantage de travail utile.
Mesurez votre combinaison réelle de lectures, écritures, plans de requête et durées de transaction. Incluez les reprises et la gestion des connexions. Deux lignes synthétiques ne permettent pas de désigner le moteur le plus rapide ni de dimensionner une VM.
Une migration exige plus qu’un schéma recopié et des nombres de lignes identiques. Testez des actions représentatives de l’application : écritures refusées, identifiants générés, valeurs NULL, horodatages et annulations. Vérifiez le SQL émis par l’application ou son ORM sur le moteur cible.
Les règles de typage de SQLite diffèrent de celles de PostgreSQL ; SQLite propose aussi des tables STRICT pour un contrôle plus rigide. Définissez la correspondance entre les valeurs existantes et les types cibles, puis refusez ou corrigez explicitement les données invalides au lieu de dépendre de conversions implicites.
Si l’application utilise des clés étrangères dans SQLite, activez et vérifiez leur contrôle pour chaque connexion. Une relation jusque-là non contrôlée peut révéler des incohérences anciennes pendant la migration. Notre exemple utilise une contrainte CHECK et ne teste pas de migration de clés étrangères.
Prévoyez comment arrêter les écritures ou transférer leur prise en charge pendant la bascule, comment vérifier la nouvelle application et dans quelles conditions revenir en arrière. Un retour testé exige des versions compatibles des données et de l’application, pas simplement une copie de l’ancien exécutable.
Une base locale a elle aussi besoin d’un plan de récupération. Pour une base SQLite active, utilisez une méthode adaptée au moteur, comme l’API de sauvegarde SQLite. Ne supposez pas qu’une copie du seul fichier principal en cours d’utilisation capture un état complet et cohérent, notamment en mode WAL.
PostgreSQL documente plusieurs méthodes de sauvegarde. Choisissez selon la perte de données tolérable et le délai de rétablissement requis, puis répétez la procédure de restauration retenue. Le redémarrage propre vérifié dans notre test n’est ni une restauration de sauvegarde ni un test de récupération après incident.
Les fichiers de sauvegarde terminés peuvent être conservés séparément dans le stockage objet Hivenet. Le bucket ne devient pas pour autant le système de fichiers actif de la base, et une sauvegarde non testée ne devient pas automatiquement restaurable.
Conserver SQLite peut permettre de garder un déploiement compact. Passer à PostgreSQL introduit un service distinct, parfois utile même sur une seule machine. Déterminez ensuite si son exploitation revient à votre équipe ou à un fournisseur. Le guide de l’hébergement PostgreSQL, en anglais traite du choix entre service géré et exploitation autonome.
Compute avec Hivenet fournit une infrastructure CPU pour les applications et bases exploitées par les clients. Évaluez-la à partir de vos requêtes, besoins mémoire, connexions, caractéristiques du stockage et plan de récupération. Il s’agit d’une option d’infrastructure, pas d’une offre d’administration PostgreSQL gérée.
Choisissez l’architecture dont vous pouvez prendre en charge les accès et l’exploitation. Validez-la ensuite avec une charge représentative avant de déplacer l’état de l’application.
Choisissez une charge de travail d’IA, de calcul ou de stockage à tester sur Hivenet, ou échangez avec notre équipe sur sa mise en production.