Passer au contenu
🛠️
Whiz Tools

Générateur UUID Gratuit - Créez des UUID V1 & V4 Instantanément

Générez des identifiants uniques instantanément avec notre générateur UUID gratuit. Créez des UUID Version 1 (basés sur le temps) et Version 4 (aléatoires) pour les bases de données, les API et les systèmes distribués.

Générateur UUID

Version UUID
UUID généré
Calculateur de chargement...
📚

Documentation

Générateur d’UUID

Un générateur d’UUID est un outil qui crée un identifiant unique universel, ou UUID (« Universally Unique Identifier ») : un code de 128 bits utilisé pour étiqueter une donnée afin qu’aucun autre élément, où que ce soit, ne partage vraisemblablement le même identifiant. Cette page génère des UUID de version 1 (fondés sur le temps) et de version 4 (aléatoires).

Qu’est-ce qu’un UUID ?

Un UUID est un nombre de 128 bits écrit avec 32 chiffres hexadécimaux (les caractères 0 à 9 et a à f). Il est divisé en cinq groupes séparés par des traits d’union, selon le modèle 8-4-4-4-12, soit 36 caractères au total. Voici à quoi ressemble un UUID :

1550e8400-e29b-41d4-a716-446655440000
2

Les UUID sont définis par la RFC 9562, publiée par l’Internet Engineering Task Force en mai 2024, qui a remplacé l’ancienne RFC 4122 de 2005. Les deux documents décrivent le même format de 128 bits. Les logiciels les utilisent pour identifier des lignes de base de données, des fichiers, des sessions utilisateur et d’autres enregistrements, sans avoir besoin d’une autorité centrale pour attribuer les numéros. Comme l’espace des UUID possibles est très vaste, deux ordinateurs peuvent générer des UUID indépendamment, au même moment, et produire presque jamais le même résultat.

Format et structure d’un UUID

Les 128 bits d’un UUID sont répartis dans des champs nommés. Chaque champ occupe un nombre fixe de bits :

  • time_low — 32 bits
  • time_mid — 16 bits
  • time_hi_and_version — 16 bits
  • clock_seq_hi_and_reserved — 8 bits
  • clock_seq_low — 8 bits
  • node — 48 bits
Disposition des champs d’un UUID time_low time_mid time_hi seq_hi seq_lo node time_low: 32 bits time_mid: 16 bits time_hi_and_version: 16 bits clock_seq_hi_and_reserved: 8 bits clock_seq_low: 8 bits node: 48 bits

Quatre bits de time_hi_and_version contiennent le numéro de version de l’UUID, et deux bits de clock_seq_hi_and_reserved contiennent la variante, qui indique au logiciel comment lire les autres champs. Huit versions sont définies.

Les noms de champs ci-dessus viennent de la version 1, dans laquelle ils contiennent réellement une valeur temporelle et une valeur de nœud. Les autres versions conservent la même disposition 8-4-4-4-12 et les mêmes limites de champs, mais remplissent la plupart des bits avec des données aléatoires. Dans un UUID de version 4, le groupe nommé time_low contient une valeur aléatoire et non une valeur temporelle.

Générer un UUID avec cet outil

  1. Choisir une version : version 1 (fondée sur le temps) ou version 4 (aléatoire).
  2. Lire l’UUID dans la zone de résultat. Un nouvel UUID apparaît dès le chargement de la page ou lors du changement de version.
  3. Sélectionner « Générer » pour en créer un autre.
  4. Sélectionner « Copier » pour copier le résultat dans le presse-papiers, puis le coller dans du code, une base de données ou un fichier de configuration.

Le panneau situé sous le résultat divise l’UUID en ses cinq champs et nomme chacun d’eux, ce qui permet de trouver facilement le chiffre de version et le chiffre de variante.

La version 4 convient à la plupart des usages, notamment aux clés de base de données et aux jetons de session, car elle ne contient aucune information sur le moment ou le lieu de sa création. La version 1 convient aux enregistrements dont la date de création doit pouvoir être récupérée à partir de l’identifiant lui-même, par exemple les entrées de journal.

UUID de version 1 ou de version 4

La version 1 encode l’horodatage actuel, ainsi qu’une séquence d’horloge et une valeur de nœud choisies aléatoirement. La norme autorise la valeur de nœud à être l’adresse réseau réelle (MAC) d’un ordinateur, mais elle autorise également une valeur de nœud générée aléatoirement comme solution respectueuse de la confidentialité. Cet outil utilise toujours l’option aléatoire : ses UUID de version 1 ne lisent ni n’exposent jamais une véritable adresse MAC. La norme exige aussi que le bit de poids faible du premier octet du champ de nœud soit défini à 1 pour une valeur de nœud aléatoire, ce que fait cet outil. Les cartes réseau réelles n’ont jamais ce bit défini ; un nœud aléatoire ne peut donc pas être confondu avec un nœud réel. C’est pourquoi le deuxième chiffre hexadécimal du cinquième groupe est toujours impair dans un UUID de version 1 produit par cette page : 1, 3, 5, 7, 9, b, d ou f.

L’horodatage contenu dans un UUID de version 1 peut être relu, ce qui permet de classer les enregistrements par ordre de création. Le tri du texte de l’UUID lui-même ne produit pas ce résultat, car le premier groupe contient les 32 bits de poids faible de l’horodatage, qui recommencent à zéro environ toutes les 7 minutes. La version 6, ajoutée par la RFC 9562, stocke le même horodatage en plaçant les bits de poids fort en premier, de sorte que le tri du texte brut fonctionne.

La version 4 est constituée de bits aléatoires, à l’exception de quelques bits fixés pour indiquer la version et la variante. Elle ne contient ni horodatage ni données propres à la machine ; elle ne révèle donc ni le moment ni le lieu de sa création. Elle ne peut pas être triée par ordre de création.

Six autres versions existent dans la norme, mais ne sont pas générées par cet outil : la version 2 (sécurité DCE, rarement utilisée) ; les versions 3 et 5, construites en hachant un espace de noms et un nom avec MD5 ou SHA-1, de sorte qu’une même entrée produit toujours le même UUID ; et les versions 6, 7 et 8, ajoutées par la RFC 9562 en 2024 pour les identifiants triables et personnalisés.

Calculer un UUID (formule)

Version 4 :

  1. Générer 128 bits aléatoires.
  2. Définir les quatre bits de version, c’est-à-dire le premier chiffre hexadécimal du troisième groupe, à 0100 (hexadécimal 4).
  3. Définir les deux bits de poids fort du quatrième groupe à 10 (le premier chiffre hexadécimal de ce groupe est donc 8, 9, a ou b).

Seuls 122 des 128 bits sont réellement aléatoires, puisque 6 bits sont fixés par les étapes 2 et 3. Cela donne 2^122, soit environ 5,3 × 10^36 UUID de version 4 possibles.

Version 1 :

  1. Prendre l’heure actuelle sous la forme d’un nombre d’intervalles de 100 nanosecondes depuis le 15 octobre 1582, date de la réforme du calendrier grégorien. En pratique, il s’agit de l’heure Unix ordinaire en millisecondes, à laquelle on ajoute 12 219 292 800 000, puis que l’on multiplie par 10 000.
  2. Répartir ce nombre de 60 bits dans trois champs : les 32 bits de poids faible vont dans time_low, les 16 suivants dans time_mid et les 12 bits de poids fort dans time_hi_and_version.
  3. Générer une séquence d’horloge de 14 bits, utilisée pour éviter les collisions si l’horloge du système est réglée en arrière.
  4. Générer une valeur de nœud de 48 bits, en définissant à 1 le bit de poids faible de son premier octet.
  5. Définir les bits de version à 0001 et les bits de variante à 10.

Toutes versions d’UUID confondues, l’espace complet de 128 bits contient 2^128, soit environ 3,4 × 10^38 valeurs possibles. Ce nombre est si élevé que les collisions aléatoires ne constituent pas un problème pratique.

Exemple détaillé

Lire un UUID de version 4. Prenons l’exemple précédent : 550e8400-e29b-41d4-a716-446655440000.

  • Troisième groupe, 41d4 : le premier chiffre est 4, ce qui indique qu’il s’agit d’un UUID de version 4.
  • Quatrième groupe, a716 : le premier chiffre, a (binaire 1010), commence par 10, les bits de variante requis.
  • Les autres chiffres hexadécimaux constituent la charge utile aléatoire.

Un programme qui lit cet UUID vérifie le 4 et le motif 10 pour confirmer le format, puis traite le reste comme une valeur aléatoire opaque.

Construire un UUID de version 1. Supposons que l’horloge indique 1 700 000 000 000 millisecondes de temps Unix, soit le 14 novembre 2023 à 22:13:20 UTC.

  1. Ajouter le décalage : 1 700 000 000 000 + 12 219 292 800 000 = 13 919 292 800 000 ms.
  2. Multiplier par 10 000 pour obtenir des intervalles de 100 nanosecondes : 139 192 928 000 000 000. En hexadécimal, cela donne 01EE833B04AFC000.
  3. Découper cette valeur : time_low = 04AFC000 (les 8 chiffres hexadécimaux de poids faible), time_mid = 833B (les 4 suivants), et les 12 bits de poids fort sont 1EE.
  4. Placer le chiffre de version 1 devant 1EE, ce qui donne time_hi_and_version = 11EE.

L’UUID est alors 04afc000-833b-11ee-, suivi de la séquence d’horloge et de la valeur de nœud. Un logiciel peut inverser ces quatre étapes pour retrouver le 14 novembre 2023 à partir de l’identifiant.

Usages courants des UUID

  • Clés primaires dans les bases de données, en particulier lorsque plusieurs serveurs créent des enregistrements au même moment sans se consulter.
  • Jetons de session et clés d’API, généralement en version 4 pour la confidentialité qu’elle offre.
  • Identifiants de fichiers, d’événements et de ressources dans des systèmes distribués tels que les microservices.
  • Identifiants d’appareils dans les grands réseaux IoT, où chaque appareil peut générer son propre identifiant hors ligne.

Le principal compromis concerne la taille : un UUID occupe 16 octets de stockage, contre 4 ou 8 octets pour un simple compteur entier, et certaines bases de données indexent les UUID plus lentement que les entiers séquentiels.

Alternatives aux UUID

Les entiers à incrémentation automatique sont plus petits et plus simples, mais fonctionnent mal dès que plusieurs serveurs doivent attribuer des identifiants indépendamment. Les identifiants Snowflake, développés chez Twitter, associent un horodatage à un identifiant de processus pour produire des identifiants compacts et triables dans un système distribué. Les ULID (« Universally Unique Lexicographically Sortable Identifiers », identifiants universellement uniques et triables lexicographiquement) sont un format plus récent conçu pour être à la fois aléatoire et triable par date de création, contrairement à un UUID standard de version 4.

Histoire de la norme UUID

Le concept d’UUID est apparu dans les années 1980 chez Apollo Computer, dans le cadre de son Network Computing System. L’Open Software Foundation a ensuite adopté ce format pour son Distributed Computing Environment. L’Internet Engineering Task Force a publié la RFC 4122 en 2005, puis l’a remplacée par la RFC 9562 en mai 2024. La RFC 9562 conserve le fonctionnement inchangé de toutes les versions précédentes et ajoute les versions 6, 7 et 8.

Foire aux questions

À quoi sert un générateur d’UUID ?
Il crée des identifiants uniques pour les bases de données, les systèmes distribués, les jetons de session, les clés d’API et les identifiants d’appareils, afin qu’aucun enregistrement ne doive partager le même identifiant avec un autre.

Quelle est la différence entre UUID v1 et v4 ?
La version 1 encode un horodatage que le logiciel peut relire pour retrouver l’heure de création. La version 4 est entièrement aléatoire et ne contient aucun horodatage. La sortie de version 1 de cet outil utilise une valeur de nœud générée aléatoirement plutôt qu’une véritable adresse MAC ; elle n’expose donc pas non plus d’informations permettant d’identifier la machine.

La version 1 expose-t-elle mon adresse MAC ?
Pas avec cet outil. La norme autorise le champ de nœud d’un UUID de version 1 à contenir une véritable adresse MAC, mais ce générateur remplit toujours ce champ avec des bits aléatoires et définit le bit qui indique que la valeur ne correspond pas à une véritable adresse réseau.

Les UUID sont-ils garantis uniques ?
Non. Aucun système d’identifiants ne peut garantir une unicité absolue, mais l’espace de 128 bits contient environ 3,4 × 10^38 valeurs possibles, et un UUID de version 4 possède environ 5,3 × 10^36 valeurs aléatoires possibles. La probabilité d’un doublon est suffisamment faible pour être négligeable dans presque tous les usages pratiques.

Puis-je utiliser un UUID comme clé primaire de base de données ?
Oui. Les UUID conviennent bien aux clés primaires dans les systèmes distribués, car n’importe quel nœud peut en générer un sans consulter un serveur central. Le coût est de 16 octets de stockage par clé, soit davantage qu’un entier classique, avec des performances d’index potentiellement plus faibles dans les très grandes tables.

Un UUID est-il identique à un GUID ?
Oui. GUID (« Globally Unique Identifier », identifiant globalement unique) est le nom utilisé par Microsoft pour désigner le même concept que celui défini par la RFC 4122 sous le nom d’UUID.

Les UUID de version 4 peuvent-ils être triés par date de création ?
Non. Les UUID de version 4 sont aléatoires et ne contiennent donc aucune indication sur leur date de création. Un UUID de version 1 en contient une, mais il faut d’abord le décoder ; le tri du texte ne donne pas l’ordre de création. Les versions 6 et 7, ainsi que les ULID, sont conçus pour être triés directement sous forme de texte.

Références

  1. Davis, K., Peabody, B. et Leach, P. (2024). Universally Unique IDentifiers (UUIDs). RFC 9562. https://www.rfc-editor.org/rfc/rfc9562
  2. Leach, P., Mealling, M. et Salz, R. (2005). A Universally Unique IDentifier (UUID) URN Namespace. RFC 4122. https://www.rfc-editor.org/rfc/rfc4122
  3. Identifiant unique universel. Dans Wikipédia. https://en.wikipedia.org/wiki/Universally_unique_identifier
  4. Snowflake ID. Dans Wikipédia. https://en.wikipedia.org/wiki/Snowflake_ID
  5. Spécification ULID. GitHub. https://github.com/ulid/spec