Guide UUID : Versions, Formats et Bonnes Pratiques

Les UUID (Universally Unique Identifiers) sont des identifiants de 128 bits conçus pour être uniques dans l'espace et le temps sans autorité centrale. Ils constituent le choix standard pour les systèmes distribués où la génération d'identifiants de manière indépendante — sans coordination — est essentielle.

Format UUID

Un UUID est un nombre de 128 bits affiché sous forme de 32 chiffres hexadécimaux en cinq groupes séparés par des tirets :

550e8400-e29b-41d4-a716-446655440000
^^^^^^^^ ^^^^ ^^^^ ^^^^ ^^^^^^^^^^^^
time-low  mid  hi   clk   node
              +ver  +var

• Total : 128 bits (16 octets)
• Longueur de chaîne : 36 caractères (32 hex + 4 tirets)
• Version : Encodée dans le 13e caractère (le nibble "hi")
• Variante : Encodée dans le 17e caractère

Générez des UUID instantanément avec notre Générateur d'UUID.

Versions UUID

UUID v1 : Basé sur le Temps

Généré à partir de l'horodatage actuel et de l'adresse MAC de la machine.

// Structure: timestamp (60 bits) + clock sequence (14 bits) + node (48 bits)
6ba7b810-9dad-11d1-80b4-00c04fd430c8

Avantages : Naturellement triable par date de création, unicité garantie par machine. Inconvénients : Expose l'adresse MAC (problème de confidentialité), peut révéler la date de création. À utiliser quand : Vous avez besoin d'un ordre temporel et êtes dans un environnement contrôlé.

UUID v4 : Aléatoire

Généré à partir de nombres aléatoires cryptographiquement sécurisés. C'est la version la plus largement utilisée.

// 122 random bits (6 bits reserved for version and variant)
f47ac10b-58cc-4372-a567-0e02b2c3d479

Avantages : Simple, aucune fuite d'information, aucune coordination nécessaire. Inconvénients : Non triable, performance d'index de base de données légèrement inférieure aux identifiants séquentiels. À utiliser quand : Usage général — c'est le choix par défaut pour la plupart des applications.

UUID v7 : Aléatoire Ordonné par le Temps (Nouveau Standard)

La version la plus récente (RFC 9562, 2024), combinant un horodatage Unix avec des données aléatoires.

// Structure: timestamp (48 bits) + random (74 bits)
018e7b50-4a00-7000-8000-000000000001

Avantages : Naturellement trié par le temps, excellente performance d'index de base de données, aucune fuite d'information au-delà de la précision à la milliseconde. Inconvénients : Plus récent, certaines bibliothèques peuvent ne pas encore le supporter. À utiliser quand : Vous avez besoin d'identifiants uniques triés chronologiquement — idéal pour les clés primaires de base de données.

Autres Versions

• UUID v3 : Hash MD5 d'un espace de noms et d'un nom. Déterministe.
• UUID v5 : Hash SHA-1 d'un espace de noms et d'un nom. Déterministe et préféré à v3.
• UUID v6 : v1 réordonné pour une meilleure triabilité. Remplacé par v7.
• UUID Nil : Tous les zéros (00000000-0000-0000-0000-000000000000). Utilisé comme valeur sentinelle.

Probabilité de Collision

Quelle est la probabilité que deux UUID (v4) générés aléatoirement entrent en collision ? Avec 122 bits aléatoires :

• Après avoir généré 1 milliard d'UUID : probabilité ≈ 1 sur 10^18
• Pour avoir 50 % de chances de collision : il faut environ 2,7 × 10^18 UUID
• À 1 milliard d'UUID par seconde : cela prendrait environ 86 ans

En pratique, les collisions UUID v4 ne se produiront pas. Vous avez bien plus de chances de rencontrer une panne matérielle.

UUID vs Autres Formats d'Identifiants

ULID (Universally Unique Lexicographically Sortable Identifier)

Les ULID sont une alternative compacte : horodatage de 48 bits + 80 bits aléatoires, encodés en 26 caractères Crockford Base32. Ils se trient lexicographiquement par date de création.

Quand Utiliser les Identifiants Auto-Incrémentés

Les identifiants séquentiels sont plus simples et plus efficaces pour les applications à base de données unique. Utilisez les UUID quand vous avez besoin de :

• Identifiants générés par plusieurs systèmes indépendamment
• Identifiants qui ne révèlent pas l'ordre d'insertion aux utilisateurs externes
• Identifiants compatibles avec la fusion pour les bases de données distribuées

Considérations de Performance en Base de Données

Les UUID aléatoires (v4) causent une fragmentation de l'index B-tree car les insertions se font à des positions aléatoires. Cela peut dégrader les performances d'écriture de 2 à 5 fois par rapport aux identifiants séquentiels sur les grandes tables.

Solutions :

1. Utiliser UUID v7 : Les UUID ordonnés par le temps s'insèrent séquentiellement, égalant les performances de l'auto-incrément
2. Stocker en binaire : Utiliser BINARY(16) au lieu de CHAR(36) pour économiser 55 % de stockage
3. Utiliser ULID : Triable et plus compact que les UUID

-- PostgreSQL: native UUID type (16 bytes, efficient)
CREATE TABLE users (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  name TEXT NOT NULL
);

-- MySQL: store as BINARY(16) for performance
CREATE TABLE users (
  id BINARY(16) PRIMARY KEY,
  name VARCHAR(255) NOT NULL
);

Générer des UUID

Ligne de Commande

# macOS/Linux
uuidgen

# Python one-liner
python3 -c "import uuid; print(uuid.uuid4())"

JavaScript

// Built-in (Node.js 19+, modern browsers)
crypto.randomUUID();

// For UUID v7 (using uuid package)
import { v7 } from 'uuid';
const id = v7();

Python

import uuid
uuid.uuid4()  # Random
uuid.uuid5(uuid.NAMESPACE_DNS, 'example.com')  # Name-based

Pour une génération rapide sans code, notre Générateur d'UUID crée des UUID v4 instantanément dans votre navigateur.

FAQ

Dois-je utiliser un UUID ou un entier auto-incrémenté pour ma clé primaire de base de données ?

Pour les applications à base de données unique, les entiers auto-incrémentés sont plus simples et plus rapides. Pour les systèmes distribués, les microservices, ou lorsque vous devez générer des identifiants côté client avant l'insertion en base de données, les UUID (de préférence v7) sont le meilleur choix. Si vous utilisez PostgreSQL, le support natif des UUID rend la différence de performance négligeable.

Les UUID peuvent-ils être utilisés comme jetons de sécurité ?

UUID v4 utilise 122 bits d'aléatoire provenant d'une source cryptographique, ce qui fournit une bonne entropie. Cependant, pour les jetons de sécurité (clés API, identifiants de session), il est préférable d'utiliser des formats de jetons conçus à cet effet avec des propriétés supplémentaires comme les sommes de contrôle, l'encodage d'expiration ou l'identification par préfixe. Les UUID servent à l'identité, pas à l'authentification.

Ressources Connexes

• Générateur d'UUID — Générez des UUID instantanément en ligne
• Comparaison des Algorithmes de Hachage — Comprendre les fonctions de hachage derrière UUID v3 et v5
• Patrons de Conception d'API JSON — Utiliser efficacement les UUID dans les réponses API