Bonjour, je suis Matsun de Liberogic.
Dans notre article précédent, « Comment nous utilisons la RLS de Supabase dans nos applications métier », nous avons présenté le contrôle d'accès aux données.
Aujourd'hui, nous expliquons pourquoi nous associons Cloudflare et Supabase.
En résumé, nous confions les données et l'authentification à Supabase, tandis que la diffusion du frontend et les traitements impliquant une logique métier sont assurés par Cloudflare Workers.
Dans cet article, le terme « frontend » désigne l'ensemble formé par les pages affichées dans le navigateur et les traitements qui les génèrent, comme ceux de Next.js.
Le périmètre couvert par Supabase
Supabase est un service qui fournit de manière intégrée les fonctionnalités nécessaires au backend d'une application web.
On y trouve une base de données PostgreSQL, une authentification prenant en charge l'authentification multifactorielle, un contrôle d'accès via RLS, un stockage de fichiers avec Storage, ainsi que Realtime, qui permet de recevoir en temps réel les modifications de données. Ensemble, ces fonctions couvrent les besoins des applications métier.
Ce qui est particulièrement pratique, c'est que ces fonctionnalités sont intégrées entre elles et proposées sous forme de service géré.
Les informations de l'utilisateur authentifié peuvent être directement utilisées dans les politiques RLS, de sorte qu'il est possible de contrôler les données que chaque utilisateur peut lire et modifier, même en accédant à la base de données directement depuis le navigateur.
Une API correspondant aux tables de la base est également générée automatiquement, ce qui évite d'implémenter une API pour chaque simple opération de lecture et d'écriture.
La gestion et les sauvegardes du serveur de base de données sont assurées par Supabase, ce qui permet de se concentrer sur le développement de l'application.
Si l'on utilise un service qui ne fournit qu'une base de données, l'authentification, le contrôle d'accès et l'API doivent être implémentés soi-même.
C'est la raison pour laquelle Liberogic a choisi Supabase : authentification, contrôle d'accès et API sont disponibles dans un ensemble cohérent.
En revanche, Supabase ne propose pas d'hébergement pour le frontend.
Même lorsqu'on utilise Supabase, il faut décider séparément où diffuser le frontend.
Chez Liberogic, nous utilisons Cloudflare Workers pour diffuser ce frontend.
Les applications créées avec Next.js peuvent également fonctionner sur Workers, ce qui permet de regrouper la diffusion du frontend et les traitements côté serveur dans un même environnement d'exécution.
Répartition des rôles dans une application web utilisant Next.js et Supabase
Cet article prend pour exemple une application web dans laquelle le frontend est développé avec Next.js et Supabase sert de backend.
Avec Next.js, les données peuvent être récupérées côté serveur avant l'envoi de la page, ou côté navigateur après l'affichage de la page.
Dans nos applications métier, nous répartissons ces deux approches de la manière suivante.
Traitements côté serveur (Next.js sur Workers)
- Vérification de l'état de connexion et renouvellement de la session. Si l'utilisateur n'est pas connecté, il est redirigé vers la page de connexion sans que la page ne soit renvoyée.
- Vérification que l'authentification multifactorielle a bien été effectuée
- Récupération du profil de l'utilisateur connecté et vérification qu'il est autorisé à utiliser la fonctionnalité
- Vérification que les valeurs présentes dans l'URL (par exemple le mois concerné) sont correctes
Traitements côté navigateur
- Récupération des données affichées dans la page, comme les listes et les détails
- Mise à jour des données
En effectuant l'authentification et la vérification des droits avant de renvoyer la page, on évite un comportement peu naturel, comme l'affichage furtif d'une page contenant des fonctionnalités inaccessibles avant une redirection.
En revanche, si les données de la page sont également récupérées côté serveur, la page entière ne s'affiche qu'une fois ce chargement terminé.
Dans les applications métier, l'utilisateur enchaîne souvent plusieurs opérations sans changer de page.
Par exemple, lorsqu'il clique sur un bouton, seules les données nécessaires sont récupérées, un indicateur de chargement s'affiche uniquement sur la partie concernée, et seuls les éléments modifiés sont réaffichés.
Pour améliorer l'expérience de ces interactions fines, la récupération et la mise à jour des données de la page sont effectuées depuis le navigateur, au moment opportun.
Les rôles sont répartis de la manière suivante.
Navigateur
- Affichage des pages et interactions
- Requêtes de récupération et de mise à jour des données
- Les lectures et les mises à jour simples accèdent directement à Supabase (exécutées avec les droits de l'utilisateur connecté et contrôlées par RLS).
- Les écritures impliquant une logique métier et les intégrations avec des services externes passent par l'appel à l'API Workers.
Cloudflare Workers
- Diffusion du frontend (Next.js) et vérification de l'authentification et des droits avant le renvoi de la page
- API
- Écritures impliquant une logique métier
- Intégrations avec des services externes (envoi d'e-mails, échanges de fichiers, réception de webhooks, etc.)
Supabase
- Base de données
- Authentification
- Contrôle d'accès via RLS
- Storage
Les traitements qui ne peuvent pas être exécutés dans le navigateur sont placés dans Workers
Les applications métier impliquent souvent de nombreuses intégrations avec des services externes, tels que SendGrid, Box, les systèmes centraux et diverses solutions SaaS.
Ces intégrations nécessitent des informations d'authentification, comme des clés API, mais ces informations seraient visibles par les utilisateurs si elles étaient incluses dans le code exécuté dans le navigateur. Elles ne peuvent donc pas être placées côté navigateur.
C'est pourquoi nous regroupons la communication avec les services externes dans Workers.
Les informations d'authentification sont gérées côté serveur uniquement, sous forme de variables d'environnement Workers, et le navigateur appelle les API de Workers.
Si le service connecté change, les modifications se limitent généralement à Workers, ce qui réduit l'impact sur le frontend.
Limiter les écritures impliquant une logique métier à Workers
Comme nous l'avons expliqué précédemment, RLS est un mécanisme qui contrôle quels utilisateurs peuvent lire ou écrire quelles lignes.
Pour les lectures et les mises à jour simples, comme la modification de son propre profil, il suffit d'accéder directement à Supabase depuis le navigateur et de les contrôler avec RLS.
En revanche, les écritures impliquant une logique métier sont plus complexes en termes de conditions. Par exemple,
- Le demandeur ne peut modifier le corps du texte que pendant la phase de brouillon.
- L'approbateur ne peut modifier que le statut.
- Le montant est recalculé côté serveur au lieu d'être repris tel quel à partir de la valeur saisie.
Voilà les conditions en question.
Tenter d'exprimer toutes ces règles uniquement avec des politiques RLS rend ces politiques complexes. Si une règle est oubliée, une mise à jour non autorisée peut passer.
C'est pourquoi nous traitons les tables comportant une logique métier de la manière suivante.
- Les utilisateurs connectés disposent uniquement d'un droit de lecture, et les lignes qu'ils peuvent lire sont contrôlées par RLS.
- Le droit d'écriture n'est accordé qu'aux Workers, qui écrivent dans Supabase avec le service_role.
- Les Workers définissent strictement, dans un schéma, les champs que chaque utilisateur peut modifier, ainsi que le type et la plage de valeurs de ces champs, et rejettent toute saisie non définie dans ce schéma.
Le service_role n'est pas soumis au contrôle RLS.
C'est pourquoi les Workers vérifient systématiquement, avant toute écriture, l'authentification de l'utilisateur à l'origine de la requête ainsi que l'autorisation de son action.
Il s'agit de limiter à un seul chemin l'accès en écriture à la base de données, et de valider strictement les entrées sur ce chemin.
Cela ne signifie pas que RLS n'est plus utilisé : le contrôle de la lecture reste assuré par RLS, comme auparavant.
Tout ne passe pas par Workers
Il n'est toutefois pas nécessaire de faire passer toutes les communications par Workers. Faire transiter par Workers les lectures et les mises à jour simples, qui peuvent être suffisamment contrôlées par
RLS, ne fait qu'ajouter de la complexité à la mise en œuvre et à l'exploitation de l'API.
Chez Liberogic, nous adaptons l'usage selon la nature de chaque traitement, comme suit.
Le passage par Workers n'est pas une fin en soi : nous l'utilisons selon la nature de chaque traitement.
Facile à combiner avec les fonctions de Cloudflare
Avec Workers, il devient plus simple de se connecter à d'autres fonctions de Cloudflare, comme les suivantes.
- WAF
- Rate Limiting
- Turnstile
- Access
- R2
- Queues
En regroupant l'entrée de votre application web côté Cloudflare, il devient plus simple d'organiser la sécurité et les traitements périphériques.
Utiliser les points forts de chacun
Supabase et Cloudflare ne servent pas à tout faire à eux seuls.
- Supabase gère l'authentification et les données
- Cloudflare Workers sert à exécuter la logique propre à l'application.
Cette répartition est souvent retenue : avec cette architecture, on peut commencer petit et ajouter progressivement les traitements nécessaires.
Conclusion
Associer Cloudflare Workers et Supabase permet de séparer la gestion des données de la logique propre à l'application.
Les lectures et écritures de données contrôlées par RLS sont confiées à Supabase, tandis que les traitements liés aux services externes et aux informations sensibles sont placés côté Workers.
Nous pensons qu'une architecture où chaque traitement a un rôle distinct, plutôt que de tout concentrer en un seul endroit, facilite la maintenance au quotidien.
D'ordinaire, je suis plutôt à mon rythme, mais dès qu'un sujet m'intrigue, je creuse jusqu'à en avoir le cœur net. Au fil des essais et des erreurs, je continue chaque jour, en silence, à me consacrer au développement.
Matsun
Ingénieur frontend