Generator CUID

Generator CUID

Wprowadzenie

CUID (Collision-resistant Unique IDentifier) to unikalny identyfikator zaprojektowany tak, aby był odporny na kolizje, poziomo skalowalny i sortowalny sekwencyjnie. CUID-y są szczególnie przydatne w systemach rozproszonych, gdzie unikalne identyfikatory muszą być generowane bez koordynacji między węzłami.

Struktura CUID-ów

CUID zazwyczaj składa się z następujących komponentów:

1. Znacznik czasu: Reprezentacja aktualnego czasu
2. Licznik: Sekwencyjny licznik zapewniający unikalność w tej samej milisekundzie
3. Odcisk klienta: Unikalny identyfikator maszyny lub procesu generującego CUID
4. Komponent losowy: Dodatkowe losowe dane, aby jeszcze bardziej zredukować prawdopodobieństwo kolizji

Dokładna struktura może się różnić w zależności od implementacji CUID, ale te komponenty współpracują ze sobą, aby stworzyć unikalny i sortowalny identyfikator.

Oto wizualna reprezentacja typowej struktury CUID:

Jak generowane są CUID-y

CUID-y są generowane przy użyciu kombinacji komponentów opartych na czasie i losowych. Proces zazwyczaj obejmuje:

1. Uzyskanie aktualnego znacznika czasu
2. Inkrementacja licznika (który resetuje się okresowo)
3. Generowanie odcisku klienta (zwykle wykonywane raz na sesję lub przy uruchomieniu aplikacji)
4. Dodawanie danych losowych
5. Łączenie tych elementów w określonym formacie

Wynikowy CUID zazwyczaj reprezentowany jest jako ciąg liter i cyfr.

Zalety i zastosowania

CUID-y oferują kilka zalet w porównaniu do innych systemów unikalnych identyfikatorów:

1. Odporność na kolizje: Kombinacja znacznika czasu, licznika i danych losowych sprawia, że kolizje są niezwykle mało prawdopodobne, nawet w systemach rozproszonych.
2. Pozioma skalowalność: CUID-y mogą być generowane niezależnie na wielu maszynach bez koordynacji.
3. Sortowanie sekwencyjne: Komponent znacznika czasu umożliwia chronologiczne sortowanie CUID-ów.
4. Przyjazne dla URL: CUID-y zazwyczaj składają się z bezpiecznych dla URL znaków.

Typowe zastosowania CUID-ów obejmują:

• Klucze główne w bazach danych
• Systemy rozproszone, w których unikalne ID muszą być generowane na wielu węzłach
• Identyfikatory sesji w aplikacjach internetowych
• Śledzenie zdarzeń w systemach analitycznych
• Nazewnictwo plików lub zasobów w systemach przechowywania w chmurze

Przykłady kodu

Oto przykłady generowania CUID-ów w różnych językach programowania:

// JavaScript (z użyciem biblioteki 'cuid')
const cuid = require('cuid');
const id = cuid();
console.log(id);

## Python (z użyciem biblioteki 'cuid')
import cuid
id = cuid.cuid()
print(id)

## Ruby (z użyciem gema 'cuid')
require 'cuid'
id = Cuid::generate
puts id

// Java (z użyciem biblioteki '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# (z użyciem pakietu NuGet 'Cuid.Net')
using Cuid;

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

// PHP (z użyciem pakietu 'endyjasmi/cuid')
<?php
require 'vendor/autoload.php';
use Endyjasmi\Cuid\Cuid;

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

// Go (z użyciem pakietu 'github.com/lucsky/cuid')
package main

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

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

// Swift (z użyciem pakietu 'CUID')
import CUID

let id = CUID()
print(id)

// C++ (z użyciem własnej implementacji)
#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 (z użyciem własnej implementacji)
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

% Użycie
id = generateCUID();
disp(id);

## R (z użyciem własnej implementacji)
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)
}

## Użycie
id <- generate_cuid()
print(id)

' Excel VBA (z użyciem własnej implementacji)
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

' Użycie w komórce
'=GenerateCUID()

Historia i rozwój

CUID-y zostały pierwotnie opracowane przez Erica Elliotta w 2012 roku jako rozwiązanie problemu generowania unikalnych identyfikatorów w systemach rozproszonych. Koncepcja została zainspirowana systemem identyfikatorów Snowflake Twittera, ale zaprojektowana tak, aby była łatwiejsza do zaimplementowania i używania w różnych platformach.

Rozwój CUID-ów był napędzany potrzebą prostego, odpornego na kolizje systemu ID, który mógłby działać w różnych językach programowania i środowiskach. Celem Elliotta było stworzenie systemu, który byłby łatwy do zaimplementowania, nie wymagał centralnej koordynacji i mógłby skalować się poziomo.

Od momentu powstania, CUID przeszedł kilka iteracji i ulepszeń:

1. Oryginalna implementacja CUID koncentrowała się na prostocie i łatwości użycia.
2. W miarę wzrostu adopcji, społeczność przyczyniła się do implementacji w różnych językach programowania.
3. W 2021 roku wprowadzono CUID2, aby rozwiązać niektóre ograniczenia oryginalnego CUID i zapewnić jeszcze lepszą wydajność oraz odporność na kolizje.
4. CUID2 poprawił oryginał, wykorzystując bardziej bezpieczny generator liczb losowych i zwiększając ogólną długość identyfikatora.

Ewolucja CUID-ów odzwierciedla zmieniające się potrzeby systemów rozproszonych oraz ciągłe wysiłki na rzecz zrównoważenia prostoty, bezpieczeństwa i wydajności w generowaniu unikalnych identyfikatorów.

Odnośniki

1. Oficjalne repozytorium CUID na GitHubie
2. Specyfikacja CUID2
3. Elliott, Eric. "Generowanie unikalnych identyfikatorów w rozproszonym środowisku." Medium, 2015.
4. "Identyfikatory odporne na kolizje dla systemów rozproszonych." DZone, 2018.

To narzędzie do generowania CUID-ów pozwala szybko generować CUID-y do Twoich projektów. Po prostu kliknij przycisk "Generuj", aby stworzyć nowy CUID, a następnie użyj przycisku "Kopiuj", aby skopiować go do schowka w celu łatwego użycia w Twoich aplikacjach.