- Générateur UUID / GUID en ligne

Qu'est-ce qu'un UUID / GUID et à quoi ça sert ?

Un UUID (Universally Unique Identifier) — aussi appelé GUID (Globally Unique Identifier) dans l'écosystème Microsoft — est un identifiant de 128 bits standardisé par la RFC 4122. Il se représente sous la forme de 32 caractères hexadécimaux regroupés en 5 blocs séparés par des tirets :

xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx

-- Exemple UUID v4 :
550e8400-e29b-41d4-a716-446655440000
│        │    │    │    └─ Nœud (48 bits)
│        │    │    └────── Variant (2 bits) + Clock seq (14 bits)
│        │    └─────────── Version (4 bits) + Time hi (12 bits)
│        └──────────────── Time mid (16 bits)
└───────────────────────── Time low (32 bits)

Le bit M indique la version (1, 3, 4, 5 ou 7) et le bit N le variant (RFC 4122 impose 10xx → valeurs 8, 9, a ou b en hexadécimal).

Pourquoi utiliser des UUIDs plutôt que des auto-incréments ?

Cas d'usage typiques des UUIDs

• IDs de ressources API REST : /users/550e8400-e29b-41d4-a716-446655440000
• Microservices : chaque service génère ses IDs indépendamment, sans coordinateur central
• Systèmes distribués : Kafka, Cassandra, DynamoDB utilisent des UUIDs nativement
• Tokens one-time : liens de vérification email, réinitialisation de mot de passe
• Nommage de fichiers : éviter les collisions lors d'uploads concurrents
• Idempotency keys : prévenir les doublons dans les paiements Stripe, les requêtes HTTP

Les versions UUID : v1, v4, v5, v7 — comment choisir ?

La RFC 4122 définit 5 versions d'UUID. Une 6ème (v6) et une 7ème (v7) ont été proposées dans un draft IETF pour corriger les limitations de performance de v1 et v4. Voici un guide de choix pratique.

UUID v1 — horodatage + nœud MAC

L'UUID v1 encode l'heure courante (en intervalles de 100 nanosecondes depuis le 15 octobre 1582) et l'adresse MAC de la machine. Il est ordonnable chronologiquement et friendly pour les index BTree.

// UUID v1 — les 8 premiers caractères changent avec le temps
// Mais l'ordre des bits n'est pas chronologique dans le format standard
1a8b3c00-f29b-11ed-a716-001a2b3c4d5e
         ↑ version=1

// ⚠️ Problème sécurité : révèle l'heure exacte et l'adresse MAC
// → Ne pas utiliser pour des tokens secrets

UUID v4 — 100% aléatoire (le plus utilisé)

122 bits aléatoires, 4 bits de version, 2 bits de variant. C'est le standard de facto pour la grande majorité des cas d'usage. La probabilité de collision est négligeable : il faudrait générer 2,71 × 10¹⁸ UUIDs pour avoir 50% de chance de collision.

// UUID v4 — JavaScript (API moderne, Node 14.17+ / tous navigateurs modernes)
const id = crypto.randomUUID();
// → "550e8400-e29b-41d4-a716-446655440000"

// Vérifier le support
if (typeof crypto.randomUUID === 'function') {
    const id = crypto.randomUUID();
} else {
    // Fallback avec getRandomValues
    const bytes = new Uint8Array(16);
    crypto.getRandomValues(bytes);
    bytes[6] = (bytes[6] & 0x0f) | 0x40; // version 4
    bytes[8] = (bytes[8] & 0x3f) | 0x80; // variant RFC 4122
    // ... convertir en string hexadécimale
}

UUID v5 — hash déterministe (SHA-1)

L'UUID v5 génère un identifiant déterministe à partir d'un namespace et d'un nom. Le même couple (namespace, nom) produit toujours le même UUID. Utile pour créer des IDs stables à partir de données métier.

// UUID v5 — Python (lib uuid standard)
import uuid

# Namespace prédéfini DNS + nom de domaine
uid = uuid.uuid5(uuid.NAMESPACE_DNS, 'example.com')
print(uid)  # → "cfbff0d1-9375-5685-968c-48ce8b15ae17"
# Toujours identique pour ce couple (NAMESPACE_DNS, 'example.com')

# UUID v3 — même principe mais avec MD5 (obsolète, préférer v5)
uid3 = uuid.uuid3(uuid.NAMESPACE_DNS, 'example.com')

UUID v7 — horodatage ms + aléatoire (recommandé pour les BDD)

Proposé dans le draft IETF RFC 9562 (2024), UUID v7 combine les avantages de v1 (ordonnable) et de v4 (aléatoire) tout en plaçant le timestamp en position big-endian dans les premiers bits. Résultat : tri chronologique natif et insertion BTree sans fragmentation.

// Structure UUID v7
// [48 bits timestamp ms][4 bits version=7][12 bits aléatoire]
// [2 bits variant][62 bits aléatoire]

01861f34-3a2b-7c94-8d12-1e4a5b6c7d8e
↑ timestamp Unix ms en big-endian → triable !

// PostgreSQL 17+ supporte UUID v7 nativement via gen_random_uuid()
// MySQL 8.4+ : UUID() génère du v1, utiliser une fonction custom pour v7

Tableau récapitulatif de choix

Générer des UUIDs en JavaScript et Node.js

Depuis 2021, tous les navigateurs modernes et Node.js 14.17+ exposent crypto.randomUUID() — une API native, cryptographiquement sécurisée, sans dépendance externe. C'est la méthode recommandée.

API native crypto.randomUUID() (recommandée)

// Navigateur (Chrome 92+, Firefox 95+, Safari 15.4+, Edge 92+)
const id = crypto.randomUUID();
console.log(id); // → "f47ac10b-58cc-4372-a567-0e02b2c3d479"

// Node.js 14.17+
const { randomUUID } = require('crypto');
const id = randomUUID();

// Node.js ESM
import { randomUUID } from 'crypto';
const id = randomUUID();

// Vérification du support
const uuid = typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function'
    ? crypto.randomUUID()
    : fallbackUUID(); // implémentation manuelle

Librairie uuid (npm) — support v1, v3, v4, v5, v7

// Installation
npm install uuid

// Utilisation (ESM)
import { v4 as uuidv4, v7 as uuidv7 } from 'uuid';

const idV4 = uuidv4();
// → "9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d"

const idV7 = uuidv7();
// → "01861f34-3a2b-7000-8000-000000000001" (trié chronologiquement)

// UUID v5 — déterministe à partir d'un namespace + nom
import { v5 as uuidv5 } from 'uuid';
const MY_NAMESPACE = '1b671a64-40d5-491e-99b0-da01ff1f3341';
const id = uuidv5('mon-slug-article', MY_NAMESPACE);
// → Toujours le même pour ce couple (namespace, nom)

Génération en masse avec Array.from

// Générer 10 UUIDs v4 en une ligne
const uuids = Array.from({ length: 10 }, () => crypto.randomUUID());

// Avec map sur un tableau existant (ajouter un ID à des objets)
const users = [{ name: 'Alice' }, { name: 'Bob' }, { name: 'Charlie' }];
const usersWithId = users.map(u => ({ ...u, id: crypto.randomUUID() }));

// Insérer en base (exemple Prisma / PostgreSQL)
await prisma.user.createMany({
    data: usersWithId,
    skipDuplicates: true,
});

Validation d'un UUID côté client

// Regex de validation UUID (v1 à v5, ou v7)
const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-7][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;

function isValidUUID(str) {
    return UUID_REGEX.test(str);
}

isValidUUID('550e8400-e29b-41d4-a716-446655440000'); // → true
isValidUUID('not-a-uuid');                           // → false
isValidUUID('550e8400-e29b-91d4-a716-446655440000'); // → false (version 9 invalide)

UUIDs dans les bases de données : bonnes pratiques

Stocker des UUIDs en base de données demande quelques précautions pour éviter les problèmes de performance. Le choix du type de colonne et de la version UUID a un impact direct sur la vitesse des index.

PostgreSQL — type UUID natif

-- PostgreSQL supporte le type UUID nativement (16 octets, compact)
CREATE TABLE users (
    id   UUID         PRIMARY KEY DEFAULT gen_random_uuid(),  -- UUID v4
    name VARCHAR(255) NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL
);

-- Insertion avec UUID généré côté client (JavaScript / backend)
INSERT INTO users (id, name, email)
VALUES ('550e8400-e29b-41d4-a716-446655440000', 'Alice', 'alice@example.com');

-- Requête par UUID
SELECT * FROM users WHERE id = '550e8400-e29b-41d4-a716-446655440000';

-- Extension pgcrypto pour plus d'options
CREATE EXTENSION IF NOT EXISTS "pgcrypto";
SELECT gen_random_uuid(); -- UUID v4

MySQL — CHAR(36) vs BINARY(16)

-- Option 1 : CHAR(36) — lisible mais 36 octets
CREATE TABLE orders (
    id    CHAR(36)     PRIMARY KEY,
    total DECIMAL(10,2)
);

-- Option 2 : BINARY(16) — compact et performant (recommandé)
CREATE TABLE orders (
    id    BINARY(16)   PRIMARY KEY DEFAULT (UUID_TO_BIN(UUID(), 1)),
    total DECIMAL(10,2)
);
-- Le 2ème arg de UUID_TO_BIN = 1 → réordonne pour être chronologique

-- Requête lisible
SELECT BIN_TO_UUID(id, 1) AS id, total FROM orders;

-- PHP : générer et stocker
$uuid = Ramsey\Uuid\Uuid::uuid4()->toString();
$stmt->bindValue(':id', hex2bin(str_replace('-', '', $uuid)));

MongoDB — ObjectId vs UUID

// MongoDB utilise ObjectId par défaut (12 octets, timestamp + machine + PID + compteur)
// Pour imposer des UUIDs v4 :
const { MongoClient, UUID } = require('mongodb');

const doc = {
    _id: new UUID('550e8400-e29b-41d4-a716-446655440000'),
    name: 'Product Alpha',
};
await collection.insertOne(doc);

// Requête
const result = await collection.findOne({ _id: new UUID(id) });

Problème de fragmentation avec UUID v4 — et la solution UUID v7

UUID v4 est entièrement aléatoire. Chaque insertion dans un index BTree (PRIMARY KEY) atterrit à une position aléatoire, provoquant des page splits fréquents et une fragmentation progressive. Avec des tables de plusieurs millions de lignes, les performances d'insertion peuvent chuter de 30 à 50%.

• UUID v7 : timestamp en tête → insertions séquentielles → pas de fragmentation
• ULID : alternative populaire (26 chars Base32, tri chronologique natif)
• Snowflake ID (Twitter) : 64 bits, timestamp + datacenter + séquence
• CUID2 : collision-resistant, ordonné, URL-safe, ~24 chars

Générer des UUIDs en PHP, Python, Java et Go

PHP — ramsey/uuid ou uuid natif

<?php
// PHP 8.1+ — pas de UUID natif, mais ramsey/uuid est la référence
// composer require ramsey/uuid

use Ramsey\Uuid\Uuid;

$v4 = Uuid::uuid4()->toString();
// → "110e8400-e29b-41d4-a716-446655440000"

$v7 = Uuid::uuid7()->toString();
// → "01861f34-3a2b-7000-8000-000000000001"

// UUID v5 — déterministe
$v5 = Uuid::uuid5(Uuid::NAMESPACE_DNS, 'example.com')->toString();

// Sans dépendance — UUID v4 manuel (PHP pur)
function uuid4(): string {
    $data = random_bytes(16);
    $data[6] = chr(ord($data[6]) & 0x0f | 0x40); // version 4
    $data[8] = chr(ord($data[8]) & 0x3f | 0x80); // variant
    return vsprintf('%s%s-%s-%s-%s-%s%s%s', str_split(bin2hex($data), 4));
}
?>

Python — module uuid standard

import uuid

# UUID v4 — aléatoire
uid4 = uuid.uuid4()
print(uid4)              # → 550e8400-e29b-41d4-a716-446655440000
print(str(uid4))         # → string avec tirets
print(uid4.hex)          # → sans tirets
print(uid4.bytes)        # → bytes bruts (16 octets)

# UUID v5 — déterministe (SHA-1)
uid5 = uuid.uuid5(uuid.NAMESPACE_DNS, 'example.com')

# UUID v1 — horodaté
uid1 = uuid.uuid1()
print(uid1.time)         # → timestamp Unix en 100ns

# Valider un UUID
def is_valid_uuid(val):
    try:
        uuid.UUID(str(val))
        return True
    except ValueError:
        return False

Java — java.util.UUID

import java.util.UUID;

// UUID v4 — nativement supporté
UUID uid = UUID.randomUUID();
System.out.println(uid);              // → 550e8400-e29b-41d4-a716-446655440000
System.out.println(uid.toString());   // → même chose
System.out.println(uid.getMostSignificantBits());  // long
System.out.println(uid.getLeastSignificantBits()); // long

// Depuis une string
UUID parsed = UUID.fromString("550e8400-e29b-41d4-a716-446655440000");

// Pour UUID v7 en Java : utiliser la lib com.fasterxml.uuid
// org.javastruct:java-uuid-generator:5.0.0

Go — package uuid (google/uuid)

// go get github.com/google/uuid
package main

import (
    "fmt"
    "github.com/google/uuid"
)

func main() {
    // UUID v4
    id := uuid.New()
    fmt.Println(id.String()) // → "550e8400-e29b-41d4-a716-446655440000"

    // UUID v7
    id7, _ := uuid.NewV7()
    fmt.Println(id7.String())

    // Valider
    _, err := uuid.Parse("not-a-uuid")
    fmt.Println(err != nil) // → true

    // Depuis string
    id2, _ := uuid.Parse("550e8400-e29b-41d4-a716-446655440000")
    fmt.Println(id2.Version()) // → 4
}

UUIDs et sécurité : ce qu'il faut savoir

UUID v4 est-il cryptographiquement sûr ?

Cela dépend de la source d'aléatoire. crypto.randomUUID() et crypto.getRandomValues() utilisent le CSPRNG (Cryptographically Secure Pseudo-Random Number Generator) du système d'exploitation — le même que /dev/urandom sous Linux. Ils sont sûrs pour des tokens de session, des liens de reset de mot de passe, etc.

Prévention des attaques IDOR avec les UUIDs

Les IDs auto-incrémentés exposent les ressources à des attaques IDOR (Insecure Direct Object Reference) : un attaquant peut énumérer /api/orders/1, /api/orders/2… Les UUID v4 rendent cette énumération impossible (2¹²² combinaisons).

// ❌ Vulnérable à l'IDOR — endpoint prévisible
GET /api/orders/42      → order de l'utilisateur 42
GET /api/orders/43      → order de l'utilisateur 43 (accessible ?)

// ✅ Avec UUID v4 — énumération impossible
GET /api/orders/550e8400-e29b-41d4-a716-446655440000
// Contrôle d'accès obligatoire côté serveur malgré tout !

UUID v1 — risques de vie privée

L'UUID v1 encode l'adresse MAC de la machine. Plusieurs incidents ont permis de retrouver l'identité de créateurs de documents Word ou de messages Skype via leur UUID v1. Pour les données sensibles, préférez toujours UUID v4.

• Logs publics : utiliser UUID v4, jamais v1
• Tokens de réinitialisation : UUID v4 via crypto.randomUUID()
• Clés primaires BDD exposées en API : UUID v4 ou v7
• Fichiers partagés : UUID v4 comme nom de fichier

Questions fréquentes sur les UUIDs

UUID et GUID, c'est la même chose ?

Oui, techniquement. UUID est le terme de la RFC 4122 (IETF), GUID est le terme Microsoft (Windows, .NET, SQL Server, COM). Ils utilisent le même format 128 bits et sont interchangeables. La seule nuance : les GUIDs Microsoft sont parfois écrits avec des accolades — {550e8400-e29b-41d4-a716-446655440000}.

Peut-on avoir des collisions UUID v4 ?

Théoriquement oui, pratiquement non. Pour avoir 50% de chance de collision, il faudrait générer 2,71 × 10¹⁸ UUIDs. À raison d'un milliard d'UUIDs par seconde, cela prendrait 85 ans. Les bases de données modernes ont de toute façon une contrainte UNIQUE qui détecterait un éventuel doublon.

Comment stocker les UUIDs efficacement en MySQL ?

Utilisez BINARY(16) avec UUID_TO_BIN(uuid, 1) pour réordonner les bits de manière chronologique (UUID v1) ou utilisez UUID v7 directement. Évitez VARCHAR(36) pour les clés primaires : 2,25× plus volumineux et index moins performants.

Quelle est la différence entre UUID v4 et ULID ?

ULID (Universally Unique Lexicographically Sortable Identifier) est une alternative à UUID v4 : 26 caractères Base32 Crockford, tri chronologique natif, insensible à la casse. Il combine les avantages de l'ordre chronologique (UUID v7) et d'une représentation plus compacte. Exemple ULID : 01ARZ3NDEKTSV4RRFFQ69G5FAV.

Comment valider un UUID en PHP ?

<?php
// Regex de validation RFC 4122
function isValidUuid(string $uuid): bool {
    return (bool) preg_match(
        '/^[0-9a-f]{8}-[0-9a-f]{4}-[1-7][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i',
        $uuid
    );
}

var_dump(isValidUuid('550e8400-e29b-41d4-a716-446655440000')); // bool(true)
var_dump(isValidUuid('not-a-uuid'));                           // bool(false)
?>

Cet outil génère-t-il des UUIDs côté serveur ?

Non. Tout se passe dans votre navigateur via l'API crypto.randomUUID() (ou crypto.getRandomValues() en fallback). Aucune donnée n'est envoyée à un serveur. Les UUIDs générés sont cryptographiquement sécurisés et directement utilisables en production.

Comment utiliser un UUID comme nom de fichier lors d'un upload ?

// JavaScript (côté client — avant upload)
const file = event.target.files[0];
const ext  = file.name.split('.').pop();
const safeName = crypto.randomUUID() + '.' + ext;
// → "550e8400-e29b-41d4-a716-446655440000.jpg"

// PHP (côté serveur)
$ext  = pathinfo($_FILES['file']['name'], PATHINFO_EXTENSION);
$uuid = 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)
);
$filename = $uuid . '.' . strtolower($ext);
move_uploaded_file($_FILES['file']['tmp_name'], '/uploads/' . $filename);

Conclusion

Les UUIDs sont devenus incontournables dans le développement moderne : APIs REST, microservices, bases de données distribuées, tokens de sécurité. Le choix de la version dépend du cas d'usage : UUID v4 pour la majorité des cas (tokens, IDs API), UUID v7 pour les clés primaires BDD (performance d'index), UUID v5 pour des IDs déterministes depuis des données métier.

Notre générateur fonctionne entièrement dans votre navigateur via crypto.randomUUID() — sans envoi de données, sans serveur, cryptographiquement sécurisé. Générez en masse, choisissez votre format et copiez en un clic.