ULID Generator

Inleiding

Een ULID (Universally Unique Lexicographically Sortable Identifier) is een unieke identifier die een tijdstempel combineert met willekeurige gegevens om een 26-teken lange string te creëren. ULIDs zijn ontworpen om lexicografisch sorteerbaar te zijn, terwijl ze een hoge mate van uniciteit en willekeurigheid behouden.

Structuur van een ULID

Een ULID bestaat uit twee hoofdonderdelen:

1. Tijdstempel (10 tekens): De eerste 10 tekens vertegenwoordigen de tijd in milliseconden sinds de Unix Epoch (1970-01-01).
2. Willekeurigheid (16 tekens): De resterende 16 tekens worden gegenereerd met behulp van cryptografisch veilige willekeurige gegevens.

De resulterende 26-teken lange string is gecodeerd met behulp van Crockford's base32 alfabet (0-9 en A-Z, met uitzondering van I, L, O en U).

Formule

De ULID wordt gegenereerd met de volgende stappen:

1. Genereer een 48-bits tijdstempel (milliseconden sinds Unix Epoch).
2. Genereer 80 bits aan cryptografisch veilige willekeurige gegevens.
3. Codeer de gecombineerde 128 bits met behulp van Crockford's base32 codering.

Berekening

De ULID-generator voert de volgende stappen uit:

1. Verkrijg de huidige tijdstempel in milliseconden.
2. Genereer 10 willekeurige bytes (80 bits) met behulp van een cryptografisch veilige willekeurige getallengenerator.
3. Combineer de tijdstempel en willekeurige gegevens tot een 128-bits geheel getal.
4. Codeer het 128-bits geheel getal met behulp van Crockford's base32 codering.

Toepassingen

ULIDs zijn nuttig in verschillende scenario's, waaronder:

1. Database sleutels: ULIDs kunnen worden gebruikt als unieke identificatoren voor database-records, wat uniciteit en sorteerbaarheid garandeert.
2. Gedistribueerde systemen: In gedistribueerde omgevingen kunnen ULIDs worden gegenereerd zonder coördinatie tussen knooppunten.
3. Logging en tracing: ULIDs kunnen worden gebruikt om logboekvermeldingen of gebeurtenissen te taggen, wat een sorteervriendelijke en unieke identifier biedt.
4. URL-vriendelijke ID's: ULIDs zijn URL-veilig en kunnen in webtoepassingen worden gebruikt als identificatoren in URL's.

Alternatieven

Hoewel ULIDs veelzijdig zijn, zijn er andere unieke identificatiesystemen om te overwegen:

1. UUID (Universally Unique Identifier): Een 128-bits identifier die geen tijdstempelcomponent bevat.
2. KSUID (K-Sortable Unique IDentifier): Vergelijkbaar met ULID, maar met een andere tijdstempelcodering.
3. Snowflake ID: Twitter's gedistribueerde unieke ID-generatiesysteem, dat een tijdstempel en werk-ID bevat.

Geschiedenis

ULIDs werden geïntroduceerd in 2016 door Alizain Feerasta als een alternatief voor UUIDs. Ze zijn ontworpen om enkele beperkingen van UUIDs aan te pakken, met name op het gebied van sorteerbaarheid en leesbaarheid. De ULID-specificatie is sinds de introductie stabiel gebleven, met verschillende implementaties beschikbaar in verschillende programmeertalen.

Voorbeelden

Hier zijn enkele codevoorbeelden om ULIDs te genereren in verschillende programmeertalen:

1// JavaScript-implementatie
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## Python-implementatie
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// Java-implementatie
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        // Encodeer tijdstempel
16        for (int i = 9; i >= 0; i--) {
17            result.append(ENCODING_CHARS[(int) (timestamp % 32)]);
18            timestamp /= 32;
19        }
20        // Encodeer willekeurigheid
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

Deze voorbeelden demonstreren hoe ULIDs te genereren in JavaScript, Python en Java. Je kunt deze functies aanpassen aan je specifieke behoeften of integreren in grotere systemen die unieke identificatoren vereisen.

Referenties

1. "ULID Specificatie." GitHub, https://github.com/ulid/spec. Toegang verkregen op 2 aug. 2024.
2. "Crockford's Base32 Codering." Base32 Codering, http://www.crockford.com/base32.html. Toegang verkregen op 2 aug. 2024.
3. "UUID versus ULID." Stack Overflow, https://stackoverflow.com/questions/54222235/uuid-vs-ulid. Toegang verkregen op 2 aug. 2024.