Qu’est-ce qu’un UUID ?
Un UUID (Universally Unique Identifier) est une valeur de 128 bits conçue pour être unique dans l’espace et le temps—sans autorité centrale. Il est couramment représenté sur 36 caractères (32 hex + 4 tirets), par exemple :
550e8400-e29b-41d4-a716-446655440000
- 128 bits = 16 octets
 - Formes texte : avec tirets (
8-4-4-4-12) ou compact 32 hex - Insensible à la casse : 
A–Fen majuscules ou minuscules - UUID nil : 
00000000-0000-0000-0000-000000000000(spécial “tout à zéro”) 
La norme officielle (2025)
La norme IETF actuelle est RFC 9562 (mai 2024), qui remplace RFC 4122. Elle clarifie les versions historiques et introduit des formats modernes ordonnés dans le temps pour améliorer les performances en bases et journaux.
Panorama des versions d’UUID
| Version | Idée clé | Cas d’usage typique | Remarques | 
|---|---|---|---|
| UUID v1 | Temps + identifiant de nœud | Systèmes legacy, corrélation de logs | Peut divulguer des infos de temps/hôte. | 
| UUID v2 | Sécurité DCE (IDs POSIX) | Spécialisé/legacy | Rare hors DCE. | 
| UUID v3 | Basé nom (MD5) | IDs stables depuis un nom | Déterministe ; MD5 obsolète. Préférez v5. | 
| UUID v4 | Aléatoire (122 bits) | IDs génériques | Simple, très répandu. | 
| UUID v5 | Basé nom (SHA-1) | IDs stables depuis un nom | Déterministe ; mêmes entrées → même UUID. | 
| UUID v6 | Ordonné dans le temps (réordonné v1) | Inserts ordonnés | Supplanté en pratique par v7. | 
| UUID v7 | Temps + aléatoire | Clés DB, logs, flux d’événements | Nouveau défaut moderne pour l’ordre. | 
| UUID v8 | Personnalisé | Interop/expérimentations | Pour formats/fournisseurs expérimentaux. | 
Choix rapides :
- Besoin d’IDs ordonnés pour de meilleurs index ? → UUIDv7
 - Besoin d’IDs déterministes à partir d’une entrée stable (URL, email) ? → UUIDv5
 - Besoin d’un ID aléatoire et l’ordre n’importe pas ? → UUIDv4
 
[ Publicité • Nos Partenaires ]
Pourquoi UUIDv7 est le “sweet spot” en 2025
- Ordonné dans le temps : encode un timestamp Unix (ms) en bits de poids fort → excellente localité d’index et scans par plage.
 - Toujours imprévisible : le reste des bits est aléatoire, rendant la prédiction impraticable.
 - Gains opérationnels : inserts B-tree plus réguliers, moins de splits, ingestion plus rapide à l’échelle.
Si vous utilisez v1 pour l’ordre, passer à v7 offre des bénéfices similaires sans exposer les identifiants matériels. 
Risque de collision (faut-il s’en soucier ?)
Pour v4 (122 bits aléatoires), les collisions sont astronomiquement improbables. Ordre de grandeur : il faudrait générer ~1 milliard d’UUID/s pendant ~85 ans pour atteindre ~50 % de probabilité d’une collision—bien au-delà des charges usuelles. Utilisez un RNG de qualité et c’est réglé.
Conclusion : dans les systèmes réels, considérez v4/v7 correctement générés comme uniques.
UUIDs basés sur un nom (v3/v5) en clair
- Combinez un espace de noms (DNS, URL) avec un nom (votre chaîne) et faites un hachage.
 - Déterministe : mêmes entrées → même UUID.
 - Idéal pour clés d’idempotence, déduplication, références stables inter-services.
 - Préférez v5 (SHA-1) à v3 (MD5). (Ne traitez pas cela comme des “mots de passe”.)
 
Bonnes pratiques
- Choisir la bonne version
- v7 pour ordre temporel + perf en base.
 - v4 pour des IDs aléatoires robustes.
 - v5 pour des IDs déterministes (nommez un namespace fixe).
 
 - Stockage
- Utilisez des colonnes binaires 16 octets lorsque possible (ex. 
BINARY(16)), pasCHAR(36). - PostgreSQL : type 
uuid; pour l’ordre, stockez des v7. 
 - Utilisez des colonnes binaires 16 octets lorsque possible (ex. 
 - Indexation
- Préférez v7 pour éviter les hotspots d’inserts aléatoires et améliorer la localité.
 
 - Formatage
- Acceptez les deux formes (avec/ sans tirets) ; normalisez pour les logs.
 - Traitez l’entrée comme de l’hex insensible à la casse.
 
 - Sécurité
- Les UUIDs sont des identifiants, pas des secrets. Évitez d’exposer des infos via v1. N’utilisez pas des UUIDs comme jetons d’auth.
 
 - Validation
- Imposez :
- 32 hex (compact) ou 
8-4-4-4-12avec tirets - Version correcte (nibble 
1–8) - Variante correcte (
10xx→8|9|a|b) 
 - 32 hex (compact) ou 
 
 - Imposez :
 
[ Publicité • Nos Partenaires ]
FAQ
Un UUID est un identifiant de 128 bits, généralement affiché sur 36 caractères : hexadécimal en 8-4-4-4-12 avec des tirets (ex. : 550e8400-e29b-41d4-a716-446655440000). Il n’est pas sensible à la casse et peut aussi apparaître en 32 caractères hex sans tirets.
Par défaut, utilisez UUIDv7 pour des IDs ordonnés dans le temps, adaptés aux index en base. Utilisez UUIDv4 pour des IDs aléatoires simples lorsque l’ordre n’a pas d’importance. Utilisez UUIDv5 lorsque vous avez besoin d’IDs déterministes dérivés d’un nom.
v4 est purement aléatoire (122 bits aléatoires), simple mais non triable naturellement. v7 encode un horodatage dans les bits de poids fort et de l’aléatoire dans le reste, offrant un tri quasi chronologique avec une bonne imprévisibilité—idéal pour les bases à forte écriture et les journaux.
En pratique oui, dans la plupart des contextes. “GUID” est le terme Microsoft ; “UUID” est le nom normalisé IETF. Les deux désignent des identifiants 128 bits.
Oui avec v7 (conçu pour l’ordre temporel). v1/v6 se trient aussi par temps mais posent des soucis de confidentialité/héritage. v4 est aléatoire et non triable par temps.
Avec un RNG correct, les collisions v4/v7 sont astronomiquement improbables pour des volumes réels. Considérez-les comme uniques ; utilisez un générateur de haute qualité.
Utilisez v5 pour dériver un ID stable à partir d’un espace de noms (DNS, URL) et d’un nom (chaîne d’entrée). Mêmes entrées → même UUID. Utile pour les clés d’idempotence, la déduplication et les références inter-services.
Les UUIDs sont des identifiants, pas des secrets. Ne les utilisez pas pour l’authentification ou l’autorisation. Évitez les données sensibles avec v1 (qui peut révéler l’heure/l’hôte). Préférez v4/v7 et de vrais secrets pour la sécurité.
Préférez les types binaires 16 octets lorsque disponibles (ex. PostgreSQL uuid, MySQL BINARY(16)), pas CHAR(36). Cela économise de l’espace et accélère les comparaisons et les index.
Les bits de poids fort ordonnés dans le temps de v7 améliorent la localité en B-tree, réduisent les splits de pages et accélèrent l’ingestion. L’aléa restant limite la prédictibilité tout en permettant des scans par plage efficaces.
L’UUID nil est tout à zéro : 00000000-0000-0000-0000-000000000000. Il représente une valeur “vide” ou non initialisée ; ne l’utilisez pas pour des entités réelles.
Vérifiez soit 32 hex (compact) soit 8-4-4-4-12 hex avec tirets, insensible à la casse, avec version correcte (nibble 1–8) et variante (8|9|a|b). Rejetez le reste.
Non. L’hexadécimal est insensible à la casse. Normalisez vers un style (souvent minuscule) pour la cohérence des journaux et interfaces.
À éviter. Les UUIDs sont conçus pour être opaques. Si vous avez besoin d’IDs lisibles ou strictement monotones, utilisez des schémas distincts de type ULID/KSUID avec leurs compromis.
Oui pour la plupart des nouveaux développements. v7 conserve les avantages d’ordonnancement sans exposer MAC/détails temporels. Pour migrer, faites du double-write ou un backfill en gardant les clés primaires stables afin d’éviter un re-key massif.
Aucune sémantique. Les tirets améliorent la lisibilité ; le compact économise des octets en texte. Stockez en binaire en interne et choisissez un format de présentation unique en externe.
Oui. Avec v7 (ou v4 + stratégie d’ordre), les bases s’en sortent bien. Assurez des index adaptés, du stockage binaire et faites des benchmarks selon votre charge.
Choisissez un UUID d’espace de noms fixe (DNS/URL/propre namespace) et une chaîne d’entrée stable. Le hachage (SHA-1) produit toujours le même UUID. N’utilisez pas v5 comme secret ; traitez-le uniquement comme identifiant stable.
[ Publicité • Nos Partenaires ]
Aide-mémoire (snippets)
Reconnaître un UUID (avec tirets, insensible à la casse) :
^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$
Compact (sans tirets) :
^[0-9a-fA-F]{32}$
Détectez la version via le 13ᵉ nibble hex (1–8) et la variante via le 17ᵉ nibble (8|9|a|b).
Quand préférer des IDs séquentiels
- Vous avez besoin d’entiers strictement monotones (ex. numéros de facture visibles).
 - Vous avez de toutes petites tables et cherchez des clés lisibles par l’humain.
 - Vous devez intégrer du sens métier dans les IDs (les UUIDs sont volontairement opaques).
 
Dans les autres cas, UUIDv7 est un excellent défaut en 2025.
[ Publicité • Nos Partenaires ]