Générateur UUID | Versions v1 à v7 - Gratuit et Rapide

Qu’est-ce qu’un UUID ?

Un UUID (Identifiant Universellement Unique) est un identifiant de 128 bits utilisé dans les systèmes informatiques pour identifier de manière unique des informations. L’UUID est standardisé par le RFC 4122 et, grâce à son énorme entropie, garantit une probabilité de collision pratiquement nulle – cela signifie que deux UUID générés indépendamment seront presque certainement uniques.

L’UUID a un format standard : xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx, où chaque x est un chiffre hexadécimal (0-9, a-f), M indique la version de l’UUID et N indique la variante.

Versions d’UUID

UUID v1 (Horodatage + adresse MAC)

L’UUID v1 est basé sur l’horodatage actuel (timestamp) et une valeur aléatoire (dans le navigateur, au lieu de l’adresse MAC). Il utilise des intervalles de 100 nanosecondes depuis le 15 octobre 1582 (calendrier grégorien).

Utilisation :

• Situations où vous avez besoin d’un tri chronologique des UUID
• Débogage et journalisation (l’UUID contient des informations sur l’heure de création)
• Systèmes distribués avec synchronisation temporelle

Exemple : 6ba7b810-9dad-11d1-80b4-00c04fd430c8

Avantages :

• Les UUID peuvent être triés chronologiquement par date de création
• Utile pour l’audit et le débogage
• Contient des informations d’horodatage

Inconvénients :

• Risque de sécurité potentiel – contient l’horodatage
• Dans le navigateur, il ne contient pas la véritable adresse MAC (remplacée par une valeur aléatoire)
• Mauvaise localité de DB (l’horodatage est dans les bits de faible poids)

UUID v3 (Hachage MD5)

L’UUID v3 est généré à l’aide d’un hachage MD5 de l’espace de noms UUID et du nom. Déterministe – le même espace de noms + le même nom créeront toujours le même UUID.

Utilisation :

• Conversion d’URL, de noms DNS ou d’autres identifiants en UUID
• Situations où vous avez besoin d’UUID reproductibles
• Mappage entre différents systèmes d’identification

Exemple : a3bb189e-8bf9-3888-9912-ace4e6543002

Avantages :

• Déterministe (même entrée = même sortie)
• Idéal pour la conversion d’identifiants connus
• Pas de collision pour des entrées différentes

Inconvénients :

• MD5 est un algorithme obsolète (préférez la v5)
• Nécessite un espace de noms et un nom
• Impossible de récupérer l’entrée d’origine

UUID v4 (Aléatoire) - RECOMMANDÉ

La version d’UUID la plus utilisée. L’UUID v4 est généré de manière purement aléatoire à l’aide d’un générateur de nombres aléatoires cryptographiquement sécurisé (crypto.getRandomValues()).

Utilisation :

• Clés primaires de base de données
• Identifiants de session (session IDs)
• Noms de fichiers uniques
• Jetons API
• Usages généraux, où vous avez besoin d’un ID garanti unique

Exemple : f47ac10b-58cc-4372-a567-0e02b2c3d479

Avantages :

• Entropie et sécurité maximales
• Aucune dépendance au temps ou aux paramètres système
• Implémentation la plus simple

Probabilité de collision : En générant 1 milliard d’UUID par seconde pendant 100 ans, la chance de collision est d’environ 0,00000006%.

UUID v5 (Hachage SHA-1)

L’UUID v5 est identique à la v3, mais utilise SHA-1 au lieu de MD5. Une alternative plus moderne et plus sécurisée à la v3.

Utilisation :

• Identique à la v3, mais avec une meilleure sécurité
• Préférable à la v3 pour les nouveaux projets
• Génération d’UUID à partir d’URL, de noms DNS, d’OID, de X.500 DN

Exemple : 886313e1-3b8a-5372-9b90-0c9aee199e5d

Avantages :

• Déterministe
• SHA-1 est plus robuste que MD5
• Convient au mappage entre systèmes

Inconvénients :

• SHA-1 est également considéré comme obsolète (mais toujours plus sûr que MD5)
• Nécessite un espace de noms et un nom

UUID v6 (Horodatage ordonné)

L’UUID v6 est une version améliorée de la v1 avec des bits d’horodatage réorganisés pour une meilleure indexation de la base de données. Conçu pour résoudre les problèmes de localité dans les bases de données.

Utilisation :

• Clés primaires de base de données avec tri temporel
• Systèmes nécessitant à la fois un tri chronologique et des performances de base de données
• Alternative plus moderne à la v1

Exemple : 1ec9414c-232a-6b00-b3c8-9e6bdeced846

Avantages :

• Meilleure localité de DB que la v1 (horodatage dans les bits de poids fort)
• Tri chronologique
• Compatible avec le standard UUID

Inconvénients :

• Moins utilisé que les v1/v4
• Contient toujours des informations temporelles (risque de sécurité)

UUID v7 (Horodatage Unix)

L’UUID v7 utilise l’horodatage Unix (millisecondes depuis 1970) + des bits aléatoires. La dernière version d’UUID avec la meilleure localité de base de données.

Utilisation :

• Clés primaires de bases de données modernes
• Systèmes nécessitant performance + tri temporel
• Remplacement des v1/v6 dans les nouveaux projets

Exemple : 017f22e2-79b0-7cc3-98c4-dc0c0c07398f

Avantages :

• Meilleure localité de DB de toutes les versions
• L’horodatage Unix est standard
• Combine les avantages de l’aléatoire et du tri temporel

Inconvénients :

• Spécification relativement nouvelle (RFC 4122bis)
• Moins supportée dans les systèmes existants

Quelle version d’UUID utiliser ?

Guide de décision

Avez-vous besoin d’une sécurité et d’un caractère aléatoire maximums ? → Utilisez UUID v4 (choix le plus courant)

Avez-vous besoin d’un tri temporel et de performances de base de données ? → Utilisez UUID v7 (moderne) ou UUID v6 (standard)

Avez-vous besoin d’UUID reproductibles à partir d’identifiants existants ? → Utilisez UUID v5 (SHA-1) ou UUID v3 (MD5, obsolète)

Avez-vous besoin d’un horodatage et d’une piste d’audit ? → Utilisez UUID v1 (obsolète, performances de base de données moindres)

Bases de données

Pour les nouveaux projets : UUID v7 ou v4

• v7 est idéal pour le tri temporel + la performance
• v4 pour une aléatoire maximale sans informations temporelles

Pour les systèmes existants : UUID v1 ou v6

• v6 a une meilleure localité de base de données que la v1
• v1 est largement supportée

Avantages de l’UUID comme clé primaire :

• Unicité globale – Vous pouvez fusionner des données de différentes bases de données sans conflit
• Sécurité – Contrairement aux ID séquentiels (1, 2, 3…), il est impossible de deviner les valeurs suivantes
• Systèmes distribués – Les UUID peuvent être générés indépendamment sur plusieurs serveurs sans coordination
• Fusion de bases de données – La fusion de deux bases de données ne génère pas de conflits

Inconvénients :

• Taille plus grande (16 octets vs 4-8 octets pour un entier)
• Indexation plus lente dans certaines bases de données (utilisez v6/v7 pour de meilleures performances)
• Moins lisible pour un être humain

API et services web

• API REST – Identifiants uniques pour les ressources
• GraphQL – Identifiants globaux pour les nœuds
• Webhooks – Suivi des requêtes et des réponses
• Jetons – ID de session, jetons de rafraîchissement

Fichiers et stockage

• Noms de fichiers – Prévention des collisions lors du téléchargement
• S3/Stockage cloud – Chemins uniques vers les objets
• Clés de cache – Identifiants dans les systèmes de cache

Applications frontend

• Composants React/Vue – Clés uniques pour les listes
• ID Temporaires – ID avant l’enregistrement en base de données
• Stockage local – Clés pour les données stockées
• Applications offline-first – Génération d’ID sans connexion au serveur

Fonctionnalités avancées du générateur

Génération d’UUID avec heure personnalisée

Pour les versions basées sur le temps (v1, v6, v7), vous pouvez sélectionner n’importe quel horodatage à l’aide du sélecteur de date/heure. C’est utile pour :

Tests :

• Simulation d’UUID créés dans le passé
• Test du tri temporel dans les bases de données
• Reproduction d’UUID pour le débogage

Migration de données :

• Génération d’UUID avec des horodatages historiques
• Remplissage de données avec des valeurs d’horodatage correctes
• Importation de données de différentes périodes

Audit et conformité :

• Reconstruction d’UUID selon l’heure de création de l’enregistrement
• Génération rétroactive d’identifiants

Exemple d’utilisation :

1. Sélectionnez la version v1, v6 ou v7
2. Définissez la date et l’heure à l’aide du sélecteur de date/heure
3. Générez l’UUID avec votre propre horodatage

UUID basés sur le hachage (v3, v5)

Pour les UUID déterministes, vous pouvez utiliser les versions v3 (MD5) ou v5 (SHA-1) :

Comment utiliser :

1. Sélectionnez l’espace de noms en fonction du type de votre identifiant
2. Saisissez le nom/la valeur
3. Générez l’UUID

Exemples :

Propriétés importantes :

• ✅ Déterministe : Même entrée = toujours le même UUID
• ✅ Reproductible : Vous pouvez recréer l’UUID à tout moment
• ✅ Cohérent : Même UUID à travers différents systèmes
• ❌ Non décodable : Le nom d’origine ne peut pas être récupéré à partir de l’UUID
• ℹ️ Un seul UUID : Pour v3/v5, un seul UUID est toujours généré (même entrée = même sortie)

Utilisation pratique :

// Exemple : Conversion d'URL en UUID v5
Espace de noms : URL
Nom : https://example.com/api/users/123
Résultat : 886313e1-3b8a-5372-9b90-0c9aee199e5d

// Même entrée = toujours le même UUID
Espace de noms : DNS
Nom : google.com
Résultat : toujours le même UUID pour google.com

Comment utiliser les UUID en toute sécurité ?

Sécurité cryptographique

Notre générateur utilise crypto.getRandomValues(), qui est un générateur de nombres aléatoires cryptographiquement sécurisé. Contrairement à Math.random(), qui est prévisible et impropre à des fins de sécurité, crypto.getRandomValues() fournit une véritable entropie adaptée à :

• Génération de jetons de sécurité
• ID de session
• Clés API
• Applications cryptographiques

Comparaison des versions d’UUID

UUID vs autres identifiants

Implémentation dans différents langages

JavaScript/TypeScript

// UUID v4 - La méthode la plus simple (navigateurs modernes)
const uuid = crypto.randomUUID();

// UUID v4 - Implémentation manuelle
function generateUUIDv4() {
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
    const r = (crypto.getRandomValues(new Uint8Array(1))[0] & 0x0f) >> (c === 'x' ? 0 : 2);
    const v = c === 'x' ? r : (r & 0x3) | 0x8;
    return v.toString(16);
  });
}

// UUID v7 - Recommandé pour les bases de données
function generateUUIDv7() {
  const timestamp = Date.now();
  const timeHi = (timestamp >> 16).toString(16).padStart(8, '0');
  const timeLow = (timestamp & 0xFFFF).toString(16).padStart(4, '0');

  const randomBytes = crypto.getRandomValues(new Uint8Array(10));
  const randomHex = Array.from(randomBytes)
    .map(b => b.toString(16).padStart(2, '0'))
    .join('');

  return `${timeHi}-${timeLow}-7${randomHex.substr(0, 3)}-${randomHex.substr(3, 4)}-${randomHex.substr(7)}`;
}

Python

import uuid

# UUID v4
uuid_v4 = str(uuid.uuid4())
# Sortie : '6ba7b810-9dad-11d1-80b4-00c04fd430c8'

# UUID v1
uuid_v1 = str(uuid.uuid1())

Java

import java.util.UUID;

// UUID v4
String uuidV4 = UUID.randomUUID().toString();

PHP

// UUID v4 (PHP 7+)
function generateUUID() {
    return sprintf('%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
        mt_rand(0, 0xffff), mt_rand(0, 0xffff),
        mt_rand(0, 0xffff),
        mt_rand(0, 0x0fff) | 0x4000,
        mt_rand(0, 0x3fff) | 0x8000,
        mt_rand(0, 0xffff), mt_rand(0, 0xffff), mt_rand(0, 0xffff)
    );
}

C#

using System;

// UUID v4
Guid uuid = Guid.NewGuid();
string uuidString = uuid.ToString();

Bonnes pratiques

Stockage des UUID en base de données

PostgreSQL :

CREATE TABLE users (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT NOW()
);

MySQL 8.0+ :

CREATE TABLE users (
    id BINARY(16) PRIMARY KEY DEFAULT (UUID_TO_BIN(UUID())),
    email VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Astuce : Dans MySQL, stockez les UUID comme BINARY(16) au lieu de CHAR(36) pour économiser de l’espace et accélérer l’indexation.

Validation des UUID

function isValidUUID(uuid) {
  const regex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
  return regex.test(uuid);
}

Conversion d’UUID

// Suppression des tirets
const compact = uuid.replace(/-/g, '');

// Ajout des tirets
function formatUUID(compactUuid) {
  return [
    compactUuid.substring(0, 8),
    compactUuid.substring(8, 12),
    compactUuid.substring(12, 16),
    compactUuid.substring(16, 20),
    compactUuid.substring(20, 32)
  ].join('-');
}

Résolution des problèmes (Dépannage)

UUID v3/v5 ne fonctionne pas

Problème : Rien n’est généré après avoir sélectionné v3 ou v5

Solution :

1. ✅ Vérifiez que vous avez rempli le champ “Nom” - il est obligatoire !
2. ✅ Sélectionnez le bon espace de noms en fonction du type de votre entrée
3. ✅ Exemples d’entrées valides :
   • DNS : example.com, google.com
   • URL : https://example.com/page
   • N’importe quel texte : mon-application-v1

Astuce : Essayez d’abord une valeur simple comme test et l’espace de noms DNS.

Les UUID temporels (v1, v6, v7) ont une heure étrange

Problème : L’UUID généré a un horodatage inattendu

Solution :

1. ✅ Vérifiez le sélecteur de date/heure - l’heure est-elle correctement définie ?
2. ✅ Le sélecteur de date/heure utilise votre fuseau horaire local
3. ✅ Laissez le sélecteur de date/heure vide pour l’heure actuelle

L’UUID ne peut pas être copié

Problème : Le bouton “Tout copier” ne fonctionne pas

Solution :

1. ✅ Vérifiez que vous avez généré des UUID (qu’ils ne sont pas vides)
2. ✅ Certains navigateurs nécessitent HTTPS pour l’API du presse-papiers
3. ✅ Alternativement, sélectionnez le texte dans la zone de texte et copiez-le manuellement (Ctrl+C)

Questions Fréquentes (FAQ)

Alternatives aux UUID

ULID (Identifiant Universellement Unique Triable Lexicographiquement)

• ID de 128 bits (comme l’UUID)
• Triable lexicographiquement par date de création
• Représentation plus compacte (26 caractères au lieu de 36)
• Encodage base32 insensible à la casse

Exemple : 01ARZ3NDEKTSV4RRFFQ69G5FAV

NanoID

• Taille plus petite que l’UUID (21 caractères par défaut)
• Convivial pour les URL (sans caractères spéciaux)
• Génération plus rapide
• Longueur et alphabet configurables

Exemple : V1StGXR8_Z5jdHi6B-myT

ID Snowflake (Twitter)

• ID de 64 bits (plus petit que l’UUID)
• Triable temporellement
• Contient un ID de travailleur et un numéro de séquence
• Nécessite une configuration centralisée

Exemple : 1234567890123456789

Performance et optimisation

Vitesse de génération

Notre générateur peut générer :

• 1 UUID : < 1 ms
• 100 UUID : ~10-20 ms
• 1000 UUID : ~100-200 ms

Conseils de performance

1. Génération par lots – Si vous avez besoin de nombreux UUID, générez-les en une seule fois plutôt qu’un par un
2. Stockage en DB – Indexez les colonnes UUID pour des recherches rapides
3. Compression – Stockez les UUID sous forme binaire (16 octets) au lieu d’une chaîne (36 octets)
4. Mise en cache – Dans certains cas, vous pouvez pré-générer et mettre en cache des UUID

Pour les développeurs

Structure d’un UUID v4

xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
|        |    |    |    |
|        |    |    |    └─ 48 bits de données aléatoires (node)
|        |    |    └────── 16 bits de données aléatoires avec variante (clock_seq)
|        |    └─────────── 12 bits de données aléatoires + 4 bits de version (time_hi_and_version)
|        └──────────────── 16 bits de données aléatoires (time_mid)
└───────────────────────── 32 bits de données aléatoires (time_low)

• Version (4 bits) : toujours 0100 (binaire) = 4 (hex)
• Variante (2-3 bits) : toujours 10 (binaire) pour RFC 4122

Test des UUID

// Test Jest
describe('Générateur UUID', () => {
  test('génère un UUID v4 valide', () => {
    const uuid = generateUUIDv4();
    const regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
    expect(regex.test(uuid)).toBe(true);
  });

  test('génère des UUID uniques', () => {
    const uuid1 = generateUUIDv4();
    const uuid2 = generateUUIDv4();
    expect(uuid1).not.toBe(uuid2);
  });
});

Aspects de sécurité

Ce qu’il ne faut pas faire avec les UUID

❌ N’utilisez pas l’UUID v1 pour des applications sensibles – Il contient un horodatage, ce qui peut être un risque de sécurité

❌ N’utilisez pas Math.random() pour générer des UUID – Il n’est pas cryptographiquement sécurisé

❌ Ne vous fiez pas aux UUID pour l’autorisation – Un UUID peut être deviné (même avec une probabilité extrêmement faible)

❌ Ne stockez pas les UUID dans des cookies sans chiffrement – Utilisez des cookies signés ou JWT

Ce qu’il faut faire

✅ Utilisez l’UUID v4 dans la plupart des cas – Entropie et sécurité maximales

✅ Combinez les UUID avec d’autres mesures de sécurité – Pour la gestion de session, utilisez HTTPS, des cookies HttpOnly et une courte expiration

✅ Validez les UUID côté serveur – Vérifiez toujours le format et la version de l’UUID

✅ Utilisez des sources de hasard cryptographiquement sécurisées – crypto.getRandomValues() dans le navigateur, /dev/urandom sous Linux

Faits intéressants

• Nombre d’UUID v4 possibles : 2^122 ≈ 5.3 × 10^36 (340 undécillions)
• Collision nécessaire : Pour avoir 50% de chances de collision, vous devez générer 2,71 × 10^18 UUID (2,71 quintillions)
• Taille de tous les UUID possibles : Si nous stockions chaque UUID sous 16 octets, l’espace total occuperait 85 zettaoctets (85 milliards de téraoctets)
• Origine : L’UUID a été standardisé dans le cadre du DCE (Distributed Computing Environment) en 1990