Générateur UUID : V1, V4, V7 expliqué (et lequel utiliser réellement)

La première fois que les UUID m'ont vraiment compté, je déplaçais un SaaS WordPress adjacent d'une seule boîte MySQL à une configuration avec une réplique en lecture et un plan à partager plus tard. Les ID d'incrémentation automatique allaient bien depuis des années - jusqu'à ce que deux services commencent à s'insérer dans ce qui allait devenir la même table logique, et soudainement id = 42 signifiait deux lignes différentes. C'est le moment où l'incrément automatique s'arrête tranquillement, et les UUID sont la réponse habituelle.

Un UUID est une valeur de 128 bits que vous pouvez générer sur n'importe quelle machine, à tout moment, sans coordination, et toujours en confiance pour être unique. Cette "aucune coordination" est la seule chose : une application mobile hors ligne dans un avion, trois microservices et un travailleur de fond peuvent tous les identifiants d'impression simultanément et ne jamais entrer en collision. Les mathématiques soutenant cette confiance est vraiment absurde, et je vais vous montrer à quel point absurde en une seconde.

le Générateur UUID Sur Toolz.dev crée instantanément des UUID uniques ou en bloc dans plusieurs versions, directement dans votre navigateur, c'est pratique lorsque vous avez un sommaire de table ou que vous avez besoin d'un identifiant pour un test. Ce guide couvre la signification réelle des versions, celle à choisir en 2026, comment les stocker sans détruire votre index de base de données et les erreurs que j'ai commises afin que vous puissiez les ignorer.

tl;dr : Pour les nouvelles clés primaires de base de données en 2026, générer UUID V7 — Il est programmé pour l'heure, il indexe bien et ne fuite pas de matériel comme la V1. v4 Quand vous voulez une imprévisibilité pure. Stockez-les en tant que natif uuid Type ou BINARY(16), jamais VARCHAR(36). Faites-les en gros avec le Générateur UUID, et associez-le à Convertisseur d'horodatage Pour lire l'heure cueillie dans un V7. Tout côté client, tout est gratuit.

Qu'est-ce qu'un UUID, exactement ?

Un UUID (uniquement unique identifiant) est un nombre de 128 bits utilisé pour identifier quelque chose sans autorité centrale distribuant des identifiants. Microsoft appelle la même chose un GUID (identifiant globalement unique) ; ils sont identiques de toutes les manières qui comptent. La forme de texte canonique est de 36 caractères, soit 32 chiffres hexadécimaux divisés en cinq groupes de 8-4-4-4-12 :

550e8400-e29b-41d4-a716-446655440000

Deux de ces positions hexagonales ne sont pas des données aléatoires - ce sont des métadonnées. Le 13e chiffre hexadécimal encode la version (quelle stratégie de génération a créé), et le premier chiffre du quatrième groupe encode variante (Quel modèle de mise en page il suit - 8, 9, a, ou b pour les UUID standard). Donc, dans l'exemple ci-dessus, le 4 Dans le troisième groupe, vous dites qu'il s'agit d'un V4.

À quel point "unique" est-il unique ?

Une fois la version et les bits de variante réservés, un UUID V4 a 122 bits aléatoires. C'est 2^122 valeurs possibles, soit environ 5,3 indécillions :

5,316,911,983,139,663,491,615,228,241,121,400,000

Pour rendre ce béton : si vous générez un milliard d'UUID toutes les secondes, vous aurez besoin d'environ 86 ans avant de rencontrer même 50 % de chance d'avoir un célibataire collision n'importe où. En termes pratiques, les collisions V4 ne se produisent pas et vous pouvez concevoir comme si elles n'y arriveraient jamais.

Quelle est la différence entre UUID V1, V4 et V7 ?

La spécification — à l'origine RFC 4122, maintenant mis à jour par RFC 9562 (2024) — Définit plusieurs versions. Trois matières pour le travail quotidien.

UUID v1 — Horodatage + adresse MAC

V1 assemble un horodatage de 100 Nanosecondes (comptant à partir du 15 octobre 1582, date du début du calendrier grégorien - l'un de mes éléments de spec-tribia préférés) avec l'adresse MAC de la carte réseau. Il est naturellement ordonné dans le temps et vous pouvez en extraire le temps de création.

Le problème est là dans la définition : il intègre l'adresse MAC de la machine qui l'a faite. Cela divulgue une identité matérielle et, combiné à l'horodatage, rend les ID quelque peu prévisibles. Exemple : 6ba7b810-9dad-11d1-80b4-00c04fd430c8. Je n'utiliserais que la V1 pour la compatibilité avec le legs maintenant.

UUID v4 — aléatoire

La V4 est 122 bits de hasard et rien d'autre. C'est la version que la plupart des gens veulent dire quand ils disent "uuid", et c'est très simple : pas d'horodatage, pas de matériel, pas de commande. Exemple : f47ac10b-58cc-4372-a567-0e02b2c3d479.

L'avantage est qu'il ne fuit rien et est imprévisible, ce qui est exactement ce que vous voulez pour tout ce qui ne devrait pas être deviné. L'inconvénient est que c'est aléatoire, donc les inserts consécutifs se dispersent sur tout votre index - ce qui, comme je l'ai découvert, a un coût de performance réel à l'échelle.

UUID V7 — Ordonnance dans le temps + aléatoire

Le V7 est le compromis moderne, standardisé dans la RFC 9562. Les 48 premiers bits sont un horodatage Unix en millisecondes, le reste est aléatoire. Exemple : 018e4880-d4d0-7b9c-8c37-2a5c0f1e3d8a.

Cette disposition signifie que les ID V7 trient chronologiquement - de nouvelles lignes atterrissent à la "fin" d'un indice B-tree au lieu de se disperser - tout en étant globalement unique et sans coordination. Il fuit le temps de création approximatif (généralement bien) mais pas le matériel. Pour les nouveaux projets, c'est ma clé primaire par défaut, et c'est la direction que l'IETF pointe désormais.

Voici le compromis en un coup d'œil :

Les versions moins utilisées existent également : V3 et V5 sont des hachages déterministes d'un espace de noms plus un nom (V5 utilise SHA-1 et est préféré au MD5 V3), V6 est un V1 réorganisé et V8 est réservé aux implémentations personnalisées.

Faut-il utiliser des UUID ou des ID d'incrémentation automatique ?

C'est le débat que j'ai eu dans plus de critiques de conception que tout autre, alors voici le cadre que j'utilise réellement plutôt qu'une réponse religieuse.

Restez avec l'incrément automatique lorsque Vous disposez d'une seule base de données, les performances et le stockage sont serrés et les humains doivent lire les identifiants. Un nombre entier est de 4 à 8 octets par rapport à un 16 UUID, les comparaisons entières sont plus rapides et "commander #12345" est beaucoup plus facile à lire sur le téléphone qu'un UUID de 36 caractères. Sur une seule boîte sans sharding, l'incrément automatique est vraiment le choix le plus simple et le plus rapide - n'atteignez pas les UUID.

Passer aux UUID lorsque Tous ces éléments sont vrais : vous êtes distribué (plusieurs services ou serveurs d'identification de scripts de scie de manière indépendante), vous êtes inquiet pour l'énumération (les ID d'incrémentation automatique sont devinables et révèlent tranquillement votre nombre d'enregistrements : /users/1234 indique à un attaquant que vous avez moins de 1 235 utilisateurs), vous devez fusionner des données de plusieurs bases de données sans collision ou vous souhaitez que les clients génèrent des ID avant de se synchroniser. Ce point d'énumération est un véritable facteur de sécurité qui est sous-estimé.

Et le terrain d'entente V7 : UUID V7 vous donne la génération distribuée d'un UUID et La commande d'incrément automatique de l'index, sans fuite d'enregistrements. Pour la plupart des nouveaux projets en 2026 qui nécessitent des ID non séquentiels, la V7 est la réponse qui met fin au débat.

Comment stockez-vous les UUID sans détruire votre index ?

C'est la section née de ma propre erreur, alors faites attention ici, sinon nulle part ailleurs.

Sur cette migration que j'ai mentionnée, j'ai stocké les nouveaux UUID comme VARCHAR(36) Parce que c'était la chose évidente et lisible à faire. Cela a fonctionné - puis la table a grandi, et les inserts et les jointures sont devenus mesurablement plus lents. Deux problèmes aggravés : je dépensais 36 octets par ID au lieu de 16 ans, et J'utilisais des UUID V4 aléatoires, donc chaque insert a atterri à un endroit aléatoire dans l'index de clé primaire, en le fragmentant et en battant le pool de mémoire tampon. Le correctif les stockait en tant que binaire et, lors du prochain projet, il est passé à la V7 afin que les inserts restent séquentiels.

PostgreSQL A un natif uuid Tapez — utilisez-le. Il stocke 16 octets et compare rapidement :

CREATE EXTENSION IF NOT EXISTS "pgcrypto";

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

mysql N'a pas de type UUID natif, alors stockez BINARY(16) et convertir avec UUID_TO_BIN() / BIN_TO_UUID(). Le deuxième argument est important :

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

-- The `true` swaps the timestamp bytes for better index locality on v1
INSERT INTO users (id, name, email)
VALUES (UUID_TO_BIN(UUID(), true), 'Alice', '[email protected]');

SELECT BIN_TO_UUID(id, true) AS id, name, email FROM users;

La règle à retenir : Native uuid tapez là où vous en avez un, BINARY(16) Où vous ne le faites pas, et VARCHAR(36) Fondamentalement, jamais pour une clé que vous indexerez et rejoindra.

Comment générez-vous des UUID dans le code ?

Pour un ponctuel rapide, le Générateur UUID est plus rapide que d'ouvrir un repl. Dans le code, chaque langage principal a ceci intégré ou un pas loin.

Javascript / Typescript — Le navigateur et le nœud expédient tous deux un générateur V4 maintenant :

const id = crypto.randomUUID();   // v4, no dependency needed
// For v7, use the 'uuid' package:
import { v7 as uuidv7 } from 'uuid';
const ordered = uuidv7();

Python :

import uuid
uuid.uuid4()                                  # random
uuid.uuid5(uuid.NAMESPACE_DNS, 'example.com') # deterministic (SHA-1)

Java : UUID.randomUUID() Vous donne la V4 prête à l'emploi ; la V7 a besoin d'une bibliothèque comme java-uuid-generator ou une petite implémentation RFC 9562.

Allez : github.com/google/uuid vous donne à tous les deux - uuid.New() Pour la v4 et uuid.NewV7() pour la v7.

Notez que les aidants d'exécution natifs vous donnent presque toujours la v4. Si vous voulez spécifiquement la V7 pour sa commande, vous avez généralement besoin d'une bibliothèque, car c'est le nouveau standard et que tous les stdlibs n'ont pas rattrapé leur retard.

Où les UUID apparaissent-ils réellement dans les systèmes réels ?

Il est facile de parler des UUID dans l'abstrait, alors voici les endroits concrets sur lesquels je me suis appuyé, car la version que vous choisissez dépend vraiment du travail.

Clé de base de données primaires dans une configuration distribuée. C'est le cas classique et celui qui a commencé cet article pour moi. Le moment où plus d'un écrivain peut insérer dans la même table logique - réplicas, partitions ou deux services partageant un schéma - des pauses d'auto-incrémentation. Une clé primaire V7 résout le problème de coordination et indexe toujours proprement parce qu'elle est ordonnée dans le temps.

ID générés par le client pour les applications hors ligne. Une application mobile ou un spa de navigateur doit souvent créer un enregistrement avant de pouvoir parler au serveur - pensez à une note écrite sur un avion ou à une interface utilisateur optimiste qui affiche instantanément la nouvelle ligne. Si le client frappe un UUID à l'avance, l'enregistrement a une identité stable à partir de la première frappe et se synchronise plus tard sans un aller-retour de serveur pour "obtenir un identifiant". Je l'ai utilisé pour que les formulaires se sentent instantanés, même sur des connexions floconneuses.

Identificateurs de ressources non énumérables dans les URL et les API. putting /orders/1042 Dans une URL, vous dites à quiconque que vous avez reçu au plus 1 042 commandes et les laisse marcher /orders/1041, /orders/1040, et ainsi de suite. L'échange dans un UUID supprime à la fois la fuite de la métrique métier et l'énumération facile. Pour tout ce qu'un utilisateur peut voir dans une URL, cela vaut la peine d'être fait, mais rappelez-vous qu'un UUID n'est pas un mécanisme de contrôle d'accès, vous avez toujours besoin de véritables vérifications d'autorisation derrière.

ID de corrélation pour le traçage. Lorsqu'une seule demande s'affiche sur cinq microservices, attachez un UUID comme ID de corrélation et enregistrez-le à chaque saut "dans quelque part dans ce gâchis, quelque chose a échoué" en une seule chaîne de caractères dans tous vos journaux. C'est un endroit où même un V4 simple est parfait - vous n'avez pas besoin de commander, juste un caractère unique.

Clés d'idempoité. Les API de paiement et de webhook demandent souvent au client d'envoyer un UUID comme clé d'idempométrie afin qu'une requête à nouveau essayée ne facture une carte deux fois. Le client le génère une fois, le réutilise lors des tentatives et le serveur s'y déduit. C'est un petit modèle qui empêche une classe de bugs très coûteuse.

Questions fréquentes

A quoi sert un UUID ?

Un UUID identifie de manière unique quelque chose - une ligne de base de données, une ressource API, une session, un fichier téléchargé, une trace dans les microservices - sans avoir besoin d'un service central pour distribuer des identifiants. C'est le choix lorsque plusieurs systèmes ou clients doivent créer des identifiants de manière indépendante et toujours être sûrs qu'ils ne s'affrontent pas. Vous pouvez en générer un instantanément avec le Générateur UUID sur toolz.dev.

Deux UUID peuvent-ils jamais être identiques ?

En théorie oui, en pratique non. Un UUID V4 a 122 bits aléatoires, donnant environ 5,3 possibilités d'undécillions. Vous devez générer de l'ordre de 2,7 millions d'UUID avant d'atteindre 50 % de chances d'une seule collision. Pour chaque objectif technique réel, vous pouvez traiter les UUID comme garantis uniques.

Quelle version d'UUID dois-je utiliser en 2026 ?

Pour les nouvelles clés primaires de base de données, UUID V7 - Il est ordonné dans l'heure d'indexer efficacement tout en restant unique dans le monde, et c'est la recommandation actuelle de l'IETF sous la RFC 9562. Utilisez la v4 lorsque l'imprévisibilité est importante, comme des identifiants qui ne doivent pas être devinés. Évitez la V1 pour de nouveaux travaux car il intègre l'adresse MAC de la machine génératrice.

Les UUID sont-ils séquentiels ?

V1 et V7 sont ordonnés dans le temps, donc les ID générés plus tard trient les tris précédents ; la V4 est entièrement aléatoire sans ordre. La commande séquentielle est ce qui rend le v7 convivial pour les index B-tree - de nouvelles lignes s'ajoutent plutôt que des disperses. Si vous utilisez Random V4 comme clé primaire sur une grande table, ce manque d'ordre peut nuire aux performances des inserts et des index.

Comment dois-je stocker les UUID dans une base de données ?

Utilisez le natif uuid Tapez si votre base de données en possède une (postgreSQL le fait). sinon stocker BINARY(16), et dans MySQL 8.0+ convertir avec UUID_TO_BIN() et BIN_TO_UUID(). éviter VARCHAR(36) ou CHAR(36) Pour les clés : le stockage de chaînes gaspille 20 octets par ligne et ralentit chaque comparaison, ce qui s'ajoute rapidement aux grandes tables.

Quelle est la différence entre un UUID et un GUID ?

Ils sont la même chose. UUID est le terme de RFC 4122 utilisé dans la plupart des langues et plates-formes ; GUID est le nom de Microsoft pour cela, courant dans Windows et .NET. Le format et les garanties sont identiques, vous pouvez donc traiter un GUID et un UUID de manière interchangeable.

Puis-je extraire le temps de création d'un UUID ?

À partir de la v1, la v6 et la v7, oui, ils encodent un horodatage. V7 stocke un horodatage Unix milliseconde dans ses 48 premiers bits, que vous pouvez décoder et lire avec le Convertisseur d'horodatage. V4 et V5 ne contiennent aucune information temporelle, il n'y a donc rien à en extraire.

UUID v4 est-il suffisamment sécurisé pour les jetons de session ?

Pas tout seul. Les 122 bits aléatoires de V4 sont imprévisibles, mais les jetons de session et d'authentification veulent généralement au moins 256 bits d'un générateur de sécurité cryptographique. Utilisez un jeton sécurisé pour Auth, et réservé à cet effet, et réservez les UUID pour identifier les ressources plutôt que de les protéger.

Comment générer un UUID ?

Utilisez le générateur intégré de votre langue : crypto.randomUUID() Dans les navigateurs modernes et Node.js, uuid.uuid4() en Python, ou Guid.NewGuid() En .NET, produit chacun un V4 UUID en un seul appel. Pour un ponctage ou un lot rapide, générez-les instantanément avec le Générateur UUID sur toolz.dev — Aucun code requis.

Combien de caractères est un UUID ?

Un UUID est composé de 36 caractères dans sa forme de texte canonique : 32 chiffres hexadécimaux, plus les quatre traits d'union qui le divisent en groupes 8-4-4-4-12. Ce texte encode 128 bits, c'est pourquoi le stocker sous forme de 16 octets bruts avec BINARY(16) est beaucoup plus compact que la chaîne de 36 caractères.

arrivée

Les UUID sont l'un de ces fondements auxquels vous ne pensez pas jusqu'à ce qu'un système dépasse une seule base de données, puis ils sont tout. La version courte 2026 : par défaut v7 Pour les nouvelles clés primaires, utilisez v4 Lorsque vous avez besoin d'identifiants non devinables, stockez-les comme originaire du pays uuid ou BINARY(16), et sautez la v1 pour tout ce qui est nouveau. apprendre de mon VARCHAR(36) Après-midi, vous ne le répétez pas.

Générez-les instantanément avec le Générateur UUID Sur Toolz.dev — Unique ou en bloc, toute version, tout côté client sans rien téléchargé. Lorsque vous avez besoin de lire l'heure dans un V7, prenez la Convertisseur d'horodatage, et parcourez le reste de la Outils de codage — 600+ utilitaires gratuits — Plus toolz.dev.