Aller au contenu principal

Création des utilisateurs

Peupler la base avec des utilisateurs aux rôles variés

Notions théoriques​

Dans notre projet Supabase, la gestion des utilisateurs repose sur 2 éléments complémentaires :

  1. L’interface Auth : permet de gérer les comptes utilisateurs (email, mot de passe, statut de connexion).
  2. La table user_roles : permet d’attribuer un rôle personnalisé à chaque utilisateur (ex. : 'student', 'admin').

Création d’un utilisateur via Supabase Auth​

L’interface Auth de Supabase permet d’ajouter un utilisateur manuellement. Cela crée automatiquement une ligne dans la table auth.users, qui est une table système gérée par Supabase.

Un utilisateur Auth possède au minimum :

  • un identifiant unique (UUID),
  • un email,
  • un mot de passe (crypté),
  • un statut (confirmé, en attente…).
info

L’UUID de l’utilisateur est généré automatiquement et servira de clé étrangère dans d’autres tables (comme profiles, user_roles, etc.).

Rôle des utilisateurs dans l’application​

Dans une application multi-utilisateurs, il est souvent nécessaire de distinguer les droits d’accès.
On utilise pour cela une table des rôles (souvent appelée user_roles) et un type ENUM (user_role) pour restreindre les rôles possibles.

Exemple :

create type user_role as enum ('guest', 'student', 'teacher', 'admin', 'super-admin');

Et la table associée :

create table user_roles (
  id uuid default uuid_generate_v4() primary key,
  user_id uuid references auth.users(id) not null,
  role user_role not null default 'guest',
  created_at timestamp with time zone default current_timestamp,
  updated_at timestamp with time zone default current_timestamp
);
remarque

Chaque utilisateur peut avoir un seul rôle dans cette table. On peut ajouter une contrainte unique(user_id) pour l’imposer.

Insertion manuelle dans la table user_roles​

Une fois les utilisateurs créés via Auth, il est possible d’ajouter leurs rôles via des requêtes SQL :

insert into user_roles (user_id, role)
values ('uuid-de-l-utilisateur', 'student');

Sécurité des mots de passe et bonnes pratiques​

  • Utiliser des mots de passe temporaires à la création d’un utilisateur.
  • Forcer le changement de mot de passe au premier login.
  • Implémenter une politique de rotation des mots de passe (ex. : expiration tous les 90 jours).
  • Ne jamais stocker les mots de passe en clair (Supabase les crypte automatiquement).
astuce

Limiter les rôles possibles via un type ENUM évite les erreurs de saisie et les escalades de privilèges involontaires.

Exemple pratique​

Il est possible de créer des utilisateurs avec des rôles différents via l’interface Auth de Supabase, puis d’insérer leurs rôles dans la table user_roles en SQL.

1. Créer les utilisateurs dans l’interface Auth​

Dans Supabase :

  • Aller dans l’onglet Auth > Users
  • Cliquer sur + Add User
  • Remplir les champs :
    • Email : guest@example.com, student@example.com, etc.
    • Password : un mot de passe temporaire
    • Ne pas cocher "Confirm immediately" si on veut forcer la validation par email (optionnel)

Créer 5 utilisateurs :

EmailMot de passeRôle à attribuer
guest@example.comTemporaire123!guest
student@example.comTemporaire123!student
teacher@example.comTemporaire123!teacher
admin@example.comTemporaire123!admin
superadmin@example.comTemporaire123!super-admin

2. Récupérer les UUID des utilisateurs​

Dans l’interface SQL ou Table Editor, exécuter :

select id, email from auth.users;

Copier les UUID de chaque utilisateur.

3. Insérer les rôles dans la table user_roles​

Pour chaque utilisateur, insérer une ligne dans user_roles :

insert into user_roles (user_id, role)
values ('uuid-du-guest', 'guest'),
       ('uuid-du-student', 'student'),
       ('uuid-du-teacher', 'teacher'),
       ('uuid-du-admin', 'admin'),
       ('uuid-du-superadmin', 'super-admin');

4. Vérifier que les données ont bien été insérées​

select * from user_roles;

Vérifier que chaque utilisateur a bien un rôle associé.

Test de mémorisation/compréhension​


Quelle table contient les emails et mots de passe des utilisateurs dans Supabase ?


Quel est le type de champ utilisé pour restreindre les rôles possibles ?


Quel champ relie la table user_roles à auth.users ?


Quel rôle n'est pas valide si le type ENUM est : guest, student, teacher, admin, super-admin ?


Pourquoi faut-il utiliser un mot de passe temporaire à la création d’un utilisateur ?


Quel champ est automatiquement généré dans auth.users ?


Quel est le format du champ id dans auth.users ?


Que se passe-t-il si on insère un rôle non défini dans le type ENUM ?


Quelle commande permet de voir les utilisateurs créés dans Supabase ?


Quel champ pourrait être ajouté à user_roles pour suivre les modifications ?


TP pour réfléchir et résoudre des problèmes​

Créer des utilisateurs dans Supabase et leur attribuer un rôle

Étape 1 : Créer les 5 utilisateurs via l'interface Auth de Supabase​

  1. Ouvrir Supabase et accéder à votre projet.
  2. Aller dans Auth > Users.
  3. Cliquer sur + Add User pour chaque utilisateur.
  4. Remplir les champs suivants :
    • Email : choisir un email distinct pour chaque utilisateur.
    • Password : utiliser un mot de passe temporaire (exemple : Temporaire123!).
    • Ne pas cocher "Confirm immediately".

Créer les 5 utilisateurs suivants :

EmailMot de passe
guest@example.comTemporaire123!
student@example.comTemporaire123!
teacher@example.comTemporaire123!
admin@example.comTemporaire123!
superadmin@example.comTemporaire123!
Une solution

Étape 2 : Récupérer les UUID des utilisateurs créés​

  1. Aller dans l’onglet SQL Editor ou Table Editor.
  2. Lancer la requête suivante :
select id, email from auth.users;
  1. Copier les UUID associés à chaque email.
Une solution

Étape 3 : Attribuer un rôle à chaque utilisateur dans la table user_roles​

  1. S'assurer que la table user_roles et le type ENUM user_role existent (créés lors de la séance 6).
  2. Exécuter une requête INSERT pour chaque utilisateur :
insert into user_roles (user_id, role)
values
  ('UUID_guest', 'guest'),
  ('UUID_student', 'student'),
  ('UUID_teacher', 'teacher'),
  ('UUID_admin', 'admin'),
  ('UUID_superadmin', 'super-admin');

Remplacer les UUID_... par les UUID récupérés à l’étape précédente.

Une solution

Étape 4 : Vérifier l’attribution correcte des rôles​

Exécuter la requête suivante pour voir les utilisateurs et leurs rôles :

select u.email, r.role
from auth.users u
join user_roles r on u.id = r.user_id;
Une solution

Étape 5 : Sécuriser les comptes créés​

  1. Activer l’option "Force password change" pour chaque utilisateur si disponible.
  2. Mettre en place une politique de rotation des mots de passe (à documenter dans votre livrable).
  3. Vérifier que les mots de passe ne sont pas stockés en clair.
Une solution

Étape 6 : Préparer les données pour la suite du projet​

Vérifier que la base contient maintenant :

  • 5 utilisateurs dans auth.users
  • 5 entrées dans user_roles
  • Le type ENUM user_role bien défini
Une solution