Generátor CUID

Generátor CUID

Úvod

CUID (Collision-resistant Unique IDentifier) je unikátní identifikátor navržený tak, aby byl odolný vůči kolizím, horizontálně škálovatelný a sekvenčně tříděný. CUIDy jsou obzvlášť užitečné v distribuovaných systémech, kde je potřeba generovat unikátní identifikátory bez koordinace mezi uzly.

Struktura CUIDů

CUID obvykle sestává z následujících komponent:

1. Časová značka: Reprezentace aktuálního času
2. Čítač: Sekvenční čítač zajišťující unikátnost v rámci stejné milisekundy
3. Otisk klienta: Unikátní identifikátor pro stroj nebo proces generující CUID
4. Náhodná složka: Další náhodná data pro další snížení pravděpodobnosti kolize

Přesná struktura se může lišit v závislosti na implementaci CUID, ale tyto komponenty spolupracují na vytvoření unikátního a tříděného identifikátoru.

Zde je vizuální reprezentace typické struktury CUID:

Jak se CUIDy generují

CUIDy se generují pomocí kombinace časových a náhodných komponent. Proces obvykle zahrnuje:

1. Získání aktuální časové značky
2. Inkrementaci čítače (který se periodicky resetuje)
3. Generování otisku klienta (obvykle prováděno jednou na sezení nebo při spuštění aplikace)
4. Přidání náhodných dat
5. Kombinaci těchto prvků do specifického formátu

Výsledný CUID je obvykle reprezentován jako řetězec písmen a čísel.

Výhody a případy použití

CUIDy nabízejí několik výhod oproti jiným systémům unikátních identifikátorů:

1. Odolnost vůči kolizím: Kombinace časové značky, čítače a náhodných dat činí kolize extrémně nepravděpodobnými, i v distribuovaných systémech.
2. Horizontální škálovatelnost: CUIDy mohou být generovány nezávisle na více strojích bez koordinace.
3. Sekvenční třídění: Komponenta časové značky umožňuje chronologické třídění CUIDů.
4. URL-přátelské: CUIDy se obvykle skládají z znaků bezpečných pro URL.

Běžné případy použití CUIDů zahrnují:

• Primární klíče databáze
• Distribuované systémy, kde je potřeba generovat unikátní ID napříč více uzly
• ID sezení v webových aplikacích
• Sledování událostí v analytických systémech
• Pojmenovávání souborů nebo prostředků v cloudových úložištích

Příklady kódu

Zde jsou příklady generování CUIDů v různých programovacích jazycích:

// JavaScript (používající knihovnu 'cuid')
const cuid = require('cuid');
const id = cuid();
console.log(id);

## Python (používající knihovnu 'cuid')
import cuid
id = cuid.cuid()
print(id)

## Ruby (používající gem 'cuid')
require 'cuid'
id = Cuid::generate
puts id

// Java (používající knihovnu 'com.github.f4b6a3.cuid')
import com.github.f4b6a3.cuid.Cuid;

public class CuidExample {
    public static void main(String[] args) {
        String id = Cuid.createCuid();
        System.out.println(id);
    }
}

// C# (používající balíček NuGet 'Cuid.Net')
using Cuid;

class Program
{
    static void Main(string[] args)
    {
        string id = CuidGenerator.Generate();
        Console.WriteLine(id);
    }
}

// PHP (používající balíček 'endyjasmi/cuid')
<?php
require 'vendor/autoload.php';
use Endyjasmi\Cuid\Cuid;

$id = Cuid::make();
echo $id;

// Go (používající balíček 'github.com/lucsky/cuid')
package main

import (
    "fmt"
    "github.com/lucsky/cuid"
)

func main() {
    id := cuid.New()
    fmt.Println(id)
}

// Swift (používající balíček 'CUID')
import CUID

let id = CUID()
print(id)

// C++ (používající vlastní implementaci)
#include <iostream>
#include <chrono>
#include <random>
#include <sstream>
#include <iomanip>

std::string generateCUID() {
    auto now = std::chrono::system_clock::now();
    auto now_ms = std::chrono::time_point_cast<std::chrono::milliseconds>(now);
    auto value = now_ms.time_since_epoch();
    long duration = value.count();

    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(0, 35);

    std::stringstream ss;
    ss << 'c';
    ss << std::hex << std::setfill('0') << std::setw(8) << duration;
    for (int i = 0; i < 8; i++) {
        int r = dis(gen);
        ss << (char)(r < 10 ? '0' + r : 'a' + r - 10);
    }
    return ss.str();
}

int main() {
    std::string id = generateCUID();
    std::cout << id << std::endl;
    return 0;
}

% MATLAB (používající vlastní implementaci)
function id = generateCUID()
    timestamp = dec2hex(round(posixtime(datetime('now'))*1000), 8);
    random = '';
    for i = 1:8
        random = [random char(randi([48 57 97 122]))];
    end
    id = ['c' timestamp random];
end

% Použití
id = generateCUID();
disp(id);

## R (používající vlastní implementaci)
library(lubridate)

generate_cuid <- function() {
  timestamp <- format(as.numeric(now()) * 1000, scientific = FALSE)
  timestamp <- substr(timestamp, 1, 8)
  random <- paste0(sample(c(0:9, letters[1:6]), 8, replace = TRUE), collapse = "")
  paste0("c", timestamp, random)
}

## Použití
id <- generate_cuid()
print(id)

' Excel VBA (používající vlastní implementaci)
Function GenerateCUID() As String
    Dim timestamp As String
    Dim random As String
    Dim i As Integer
    
    timestamp = Right("00000000" & Hex(CLng(CDbl(Now()) * 86400000)), 8)
    
    For i = 1 To 8
        random = random & Mid("0123456789abcdef", Int(Rnd() * 16) + 1, 1)
    Next i
    
    GenerateCUID = "c" & timestamp & random
End Function

' Použití v buňce
'=GenerateCUID()

Historie a vývoj

CUIDy byly původně vyvinuty Ericem Elliottem v roce 2012 jako řešení problému generování unikátních identifikátorů v distribuovaných systémech. Koncept byl inspirován systémem ID Snowflake společnosti Twitter, ale navržen tak, aby byl snadněji implementovatelný a použitelný napříč různými platformami.

Vývoj CUIDů byl řízen potřebou jednoduchého, odolného ID systému, který by mohl fungovat napříč různými programovacími jazyky a prostředími. Elliottovým cílem bylo vytvořit systém, který by byl snadno implementovatelný, nevyžadoval centrální koordinaci a mohl by horizontálně škálovat.

Od svého vzniku prošly CUIDy několika iteracemi a vylepšeními:

1. Původní implementace CUID se zaměřila na jednoduchost a snadnost použití.
2. Jak rostla adopce, komunita přispěla implementacemi v různých programovacích jazycích.
3. V roce 2021 byla představena CUID2, aby se vyřešily některé omezení původního CUID a poskytly ještě lepší výkon a odolnost vůči kolizím.
4. CUID2 vylepšil původní systém použitím bezpečnějšího generátoru náhodných čísel a zvýšením celkové délky identifikátoru.

Evoluce CUIDů odráží měnící se potřeby distribuovaných systémů a neustálé úsilí o vyvážení jednoduchosti, bezpečnosti a výkonu při generování unikátních identifikátorů.

Odkazy

1. Oficiální GitHub repozitář CUID
2. Specifikace CUID2
3. Elliott, Eric. "Generování unikátních ID v distribuovaném prostředí." Medium, 2015.
4. "ID odolná vůči kolizím pro distribuované systémy." DZone, 2018.

Tento nástroj generátor CUID vám umožňuje rychle generovat CUIDy pro vaše projekty. Jednoduše klikněte na tlačítko "Generovat", abyste vytvořili nový CUID, a použijte tlačítko "Kopírovat", abyste ho zkopírovali do schránky pro snadné použití ve vašich aplikacích.