Générateur de ULID

Introduction

Un ULID (Identifiant Universel Lexicographiquement Triable) est un identifiant unique qui combine un horodatage avec des données aléatoires pour créer une chaîne de 26 caractères. Les ULID sont conçus pour être triables lexicographiquement tout en maintenant un haut degré d'unicité et de randomisation.

Structure d'un ULID

Un ULID se compose de deux parties principales :

1. Horodatage (10 caractères) : Les 10 premiers caractères représentent le temps en millisecondes depuis l'Époque Unix (1970-01-01).
2. Aléatoire (16 caractères) : Les 16 caractères restants sont générés à l'aide de données aléatoires cryptographiquement sécurisées.

La chaîne résultante de 26 caractères est codée en utilisant l'alphabet base32 de Crockford (0-9 et A-Z, à l'exclusion de I, L, O et U).

Formule

Le ULID est généré en suivant les étapes suivantes :

1. Générer un horodatage de 48 bits (millisecondes depuis l'Époque Unix).
2. Générer 80 bits de données aléatoires cryptographiquement sécurisées.
3. Encoder les 128 bits combinés en utilisant l'encodage base32 de Crockford.

Calcul

Le générateur de ULID effectue les étapes suivantes :

1. Obtenir l'horodatage actuel en millisecondes.
2. Générer 10 octets aléatoires (80 bits) à l'aide d'un générateur de nombres aléatoires cryptographiquement sécurisé.
3. Combiner l'horodatage et les données aléatoires en un entier de 128 bits.
4. Encoder l'entier de 128 bits en utilisant l'encodage base32 de Crockford.

Cas d'utilisation

Les ULID sont utiles dans divers scénarios, notamment :

1. Clés de base de données : Les ULID peuvent être utilisés comme identifiants uniques pour les enregistrements de base de données, garantissant unicité et triabilité.
2. Systèmes distribués : Dans les environnements distribués, les ULID peuvent être générés sans coordination entre les nœuds.
3. Journalisation et traçage : Les ULID peuvent être utilisés pour étiqueter les entrées de journal ou tracer des événements, fournissant un identifiant unique et triable.
4. Identifiants compatibles URL : Les ULID sont sûrs pour les URL et peuvent être utilisés dans les applications web comme identifiants dans les URL.

Alternatives

Bien que les ULID soient polyvalents, il existe d'autres systèmes d'identifiants uniques à considérer :

1. UUID (Identifiant Universel Unique) : Un identifiant de 128 bits qui n'inclut pas de composant d'horodatage.
2. KSUID (Identifiant Unique Triable K) : Semblable aux ULID mais avec un encodage d'horodatage différent.
3. Snowflake ID : Le système de génération d'identifiants uniques distribué de Twitter, qui inclut un horodatage et un identifiant de travail.

Histoire

Les ULID ont été introduits en 2016 par Alizain Feerasta comme une alternative aux UUID. Ils ont été conçus pour répondre à certaines limitations des UUID, en particulier en termes de triabilité et de lisibilité. La spécification ULID est restée stable depuis son introduction, avec diverses implémentations disponibles dans différents langages de programmation.

Exemples

Voici quelques exemples de code pour générer des ULID dans différents langages de programmation :

1// Implémentation JavaScript
2function generateULID() {
3  const timestamp = Date.now().toString(36).padStart(10, '0');
4  const randomness = crypto.getRandomValues(new Uint8Array(16))
5    .reduce((acc, byte) => acc + byte.toString(36).padStart(2, '0'), '');
6  return (timestamp + randomness).toUpperCase();
7}
8
9console.log(generateULID());
10

1## Implémentation Python
2import time
3import secrets
4import base64
5
6def generate_ulid():
7    timestamp = int(time.time() * 1000).to_bytes(6, byteorder="big")
8    randomness = secrets.token_bytes(10)
9    return base64.b32encode(timestamp + randomness).decode("ascii").lower()
10
11print(generate_ulid())
12

1// Implémentation Java
2import java.security.SecureRandom;
3import java.time.Instant;
4
5public class ULIDGenerator {
6    private static final SecureRandom random = new SecureRandom();
7    private static final char[] ENCODING_CHARS = "0123456789ABCDEFGHJKMNPQRSTVWXYZ".toCharArray();
8
9    public static String generateULID() {
10        long timestamp = Instant.now().toEpochMilli();
11        byte[] randomness = new byte[10];
12        random.nextBytes(randomness);
13
14        StringBuilder result = new StringBuilder();
15        // Encoder l'horodatage
16        for (int i = 9; i >= 0; i--) {
17            result.append(ENCODING_CHARS[(int) (timestamp % 32)]);
18            timestamp /= 32;
19        }
20        // Encoder l'aléatoire
21        for (byte b : randomness) {
22            result.append(ENCODING_CHARS[b & 31]);
23        }
24        return result.toString();
25    }
26
27    public static void main(String[] args) {
28        System.out.println(generateULID());
29    }
30}
31

Ces exemples démontrent comment générer des ULID en JavaScript, Python et Java. Vous pouvez adapter ces fonctions à vos besoins spécifiques ou les intégrer dans des systèmes plus larges nécessitant des identifiants uniques.

Références

1. "Spécification ULID." GitHub, https://github.com/ulid/spec. Consulté le 2 août 2024.
2. "Encodage Base32 de Crockford." Encodage Base32, http://www.crockford.com/base32.html. Consulté le 2 août 2024.
3. "UUID vs ULID." Stack Overflow, https://stackoverflow.com/questions/54222235/uuid-vs-ulid. Consulté le 2 août 2024.