Générateur d'ID Snowflake : Créez des identifiants uniques pour systèmes distribués

Qu'est-ce qu'un générateur d'ID Snowflake ?

Un générateur d'ID Snowflake crée des identifiants uniques pour les systèmes distribués, initialement développé par Twitter pour gérer le traitement de données à grande échelle. Ce puissant générateur d'ID unique produit des entiers de 64 bits composés d'un horodatage, d'un ID de machine et d'un numéro de séquence, garantissant l'unicité à travers les systèmes distribués sans coordination entre les serveurs.

Notre outil gratuit en ligne de générateur d'ID Snowflake vous permet de générer et d'analyser des ID Snowflake instantanément, ce qui le rend parfait pour les développeurs travaillant avec des microservices, des bases de données distribuées et des applications à haut débit.

Comment fonctionne la génération d'ID Snowflake

Les ID Snowflake sont des entiers de 64 bits avec une structure soigneusement conçue qui garantit l'unicité :

41 bits : Horodatage (millisecondes depuis une époque personnalisée)
10 bits : ID de machine (5 bits pour l'ID du centre de données, 5 bits pour l'ID du travailleur)
12 bits : Numéro de séquence

Cette structure d'ID distribuée permet de générer environ 4 096 ID uniques par milliseconde par machine, ce qui la rend idéale pour les systèmes distribués à haut débit.

Comment utiliser notre outil de générateur d'ID Snowflake

Suivez ces étapes simples pour générer des ID Snowflake uniques :

Définir une époque personnalisée (facultatif) : Utilisez l'époque par défaut de Twitter (2010-11-04T01:42:54.657Z) ou définissez la vôtre
Configurer les ID de machine : Entrez l'ID de machine (0-31) et l'ID du centre de données (0-31)
Générer l'ID : Cliquez sur "Générer" pour créer un nouvel ID Snowflake unique
Voir les résultats : Consultez l'ID généré et sa répartition par composants

Analyser des ID Snowflake existants

Pour décoder un ID Snowflake, entrez-le dans le champ "Analyser l'ID" et cliquez sur "Analyser" pour voir ses composants d'horodatage, d'ID de machine et de séquence.

Formule de génération d'ID Snowflake

L'algorithme d'ID Snowflake construit des identifiants uniques en utilisant des opérations bit à bit :

1ID = (horodatage << 22) | (idCentreDonnées << 17) | (idTravailleur << 12) | séquence
2

Composants de la formule :

horodatage : Nombre de millisecondes depuis l'époque
idCentreDonnées : Entier de 5 bits (0-31) identifiant le centre de données
idTravailleur : Entier de 5 bits (0-31) identifiant la machine de travail
séquence : Entier de 12 bits (0-4095) pour plusieurs ID par milliseconde

Processus de calcul d'ID Snowflake

L'algorithme de génération d'ID Snowflake suit ces étapes précises :

Obtenir l'horodatage actuel : Récupérer l'heure actuelle en millisecondes
Assurer l'ordre chronologique : Vérifier que l'horodatage dépasse le dernier horodatage utilisé
Gérer le même horodatage : Si l'horodatage correspond au précédent, incrémenter le numéro de séquence
Prévenir le débordement : Si la séquence atteint 4096, attendre la milliseconde suivante
Combiner les composants : Utiliser des opérations bit à bit pour créer l'ID unique final

Ce processus garantit des ID croissants de manière monotone au sein de chaque machine tout en maintenant l'unicité globale à travers les systèmes distribués.

Cas d'utilisation et applications des ID Snowflake

Les ID Snowflake excellent dans divers scénarios de calcul distribué :

Cas d'utilisation principaux

Systèmes distribués : Générer des ID uniques à travers plusieurs machines sans coordination
Traitement de données à volume élevé : Créer des ID triables pour des ensembles de données massifs
Architecture de microservices : Assurer des identifiants uniques à travers différents services
Sharding de base de données : Utiliser des composants d'horodatage ou d'ID de machine pour un partitionnement efficace des données

Applications dans le monde réel

Plateformes de médias sociaux : Twitter, Instagram pour les ID de publications et d'utilisateurs
Systèmes de commerce électronique : Suivi des commandes et gestion des stocks
Collecte de données IoT : Journalisation des événements des appareils et données des capteurs
Systèmes financiers : Traitement des transactions et pistes de vérification

Alternatives et comparaisons des ID Snowflake

Bien que les ID Snowflake soient puissants, d'autres systèmes de génération d'ID uniques incluent :

Systèmes d'ID alternatifs

UUID (Identifiant Universel Unique) : Meilleur pour la génération distribuée sans exigences de triabilité
ID de base de données auto-incrémentés : Solution simple limitée à des instances de base de données uniques
ULID (Identifiant Universel Unique Lexicographiquement Triable) : Semblable à Snowflake avec encodage base32
NanoID : Générateur de chaînes uniques compact et sûr pour les applications web

Limitations et considérations des ID Snowflake

Comprendre les limitations des ID Snowflake aide à une mise en œuvre appropriée :

Défis courants

Problèmes de synchronisation d'horloge : Les dépendances de temps système peuvent causer des problèmes avec les ajustements NTP ou les changements d'heure d'été
Limitation de l'année 2079 : Le débordement de l'horodatage de 41 bits nécessite une planification à long terme pour les systèmes à grande échelle
Gestion des ID de machine : Assurer des ID de machine uniques à travers de grands systèmes distribués nécessite une coordination
Débordement de séquence : Des scénarios à très haut débit peuvent épuiser 4096 séquences par milliseconde
Ordonnancement inter-machines : Les ID sont monotones par machine mais pas globalement à travers toutes les machines

Historique des ID Snowflake

Les ID Snowflake ont été introduits par Twitter en 2010 pour résoudre le défi de la génération d'identifiants uniques distribués et triables dans le temps à grande échelle. Alors que la base d'utilisateurs de Twitter et le volume de tweets explosaient, les ID auto-incrémentés traditionnels devenaient insuffisants pour leur architecture distribuée.

Le système a depuis été adopté par de grandes entreprises technologiques, y compris Instagram, Discord et d'innombrables autres plateformes nécessitant une génération d'ID évolutive pour des systèmes distribués.

Exemples de code du générateur d'ID Snowflake

Implémentez la génération d'ID Snowflake dans votre langage de programmation préféré :

1class SnowflakeGenerator {
2  constructor(epoch = 1288834974657, datacenterIdBits = 5, workerIdBits = 5, sequenceBits = 12) {
3    this.epoch = BigInt(epoch);
4    this.datacenterIdBits = datacenterIdBits;
5    this.workerIdBits = workerIdBits;
6    this.sequenceBits = sequenceBits;
7    this.maxDatacenterId = -1n ^ (-1n << BigInt(datacenterIdBits));
8    this.maxWorkerId = -1n ^ (-1n << BigInt(workerIdBits));
9    this.sequenceMask = -1n ^ (-1n << BigInt(sequenceBits));
10    this.workerIdShift = BigInt(sequenceBits);
11    this.datacenterIdShift = BigInt(sequenceBits + workerIdBits);
12    this.timestampLeftShift = BigInt(sequenceBits + workerIdBits + datacenterIdBits);
13    this.sequence = 0n;
14    this.lastTimestamp = -1n;
15  }
16
17  nextId(datacenterId, workerId) {
18    let timestamp = this.currentTimestamp();
19
20    if (timestamp < this.lastTimestamp) {
21      throw new Error('L\'horloge a reculé. Refus de générer l\'id');
22    }
23
24    if (timestamp === this.lastTimestamp) {
25      this.sequence = (this.sequence + 1n) & this.sequenceMask;
26      if (this.sequence === 0n) {
27        timestamp = this.tilNextMillis(this.lastTimestamp);
28      }
29    } else {
30      this.sequence = 0n;
31    }
32
33    this.lastTimestamp = timestamp;
34
35    return ((timestamp - this.epoch) << this.timestampLeftShift) |
36           (BigInt(datacenterId) << this.datacenterIdShift) |
37           (BigInt(workerId) << this.workerIdShift) |
38           this.sequence;
39  }
40
41  tilNextMillis(lastTimestamp) {
42    let timestamp = this.currentTimestamp();
43    while (timestamp <= lastTimestamp) {
44      timestamp = this.currentTimestamp();
45    }
46    return timestamp;
47  }
48
49  currentTimestamp() {
50    return BigInt(Date.now());
51  }
52}
53
54// Utilisation
55const generator = new SnowflakeGenerator();
56const id = generator.nextId(1, 1);
57console.log(`ID Snowflake généré : ${id}`);
58

1import time
2import threading
3
4class SnowflakeGenerator:
5    def __init__(self, datacenter_id, worker_id, sequence=0):
6        self.datacenter_id = datacenter_id
7        self.worker_id = worker_id
8        self.sequence = sequence
9
10        self.last_timestamp = -1
11        self.epoch = 1288834974657
12
13        self.datacenter_id_bits = 5
14        self.worker_id_bits = 5
15        self.sequence_bits = 12
16
17        self.max_datacenter_id = -1 ^ (-1 << self.datacenter_id_bits)
18        self.max_worker_id = -1 ^ (-1 << self.worker_id_bits)
19
20        self.worker_id_shift = self.sequence_bits
21        self.datacenter_id_shift = self.sequence_bits + self.worker_id_bits
22        self.timestamp_left_shift = self.sequence_bits + self.worker_id_bits + self.datacenter_id_bits
23        self.sequence_mask = -1 ^ (-1 << self.sequence_bits)
24
25        self._lock = threading.Lock()
26
27    def _til_next_millis(self, last_timestamp):
28        timestamp = self._get_timestamp()
29        while timestamp <= last_timestamp:
30            timestamp = self._get_timestamp()
31        return timestamp
32
33    def _get_timestamp(self):
34        return int(time.time() * 1000)
35
36    def next_id(self):
37        with self._lock:
38            timestamp = self._get_timestamp()
39
40            if timestamp < self.last_timestamp:
41                raise ValueError("L'horloge a reculé. Refus de générer l'id")
42
43            if timestamp == self.last_timestamp:
44                self.sequence = (self.sequence + 1) & self.sequence_mask
45                if self.sequence == 0:
46                    timestamp = self._til_next_millis(self.last_timestamp)
47            else:
48                self.sequence = 0
49
50            self.last_timestamp = timestamp
51
52            return ((timestamp - self.epoch) << self.timestamp_left_shift) | \
53                   (self.datacenter_id << self.datacenter_id_shift) | \
54                   (self.worker_id << self.worker_id_shift) | \
55                   self.sequence
56
57## Utilisation
58generator = SnowflakeGenerator(datacenter_id=1, worker_id=1)
59snowflake_id = generator.next_id()
60print(f"ID Snowflake généré : {snowflake_id}")
61

1import java.util.concurrent.locks.Lock;
2import java.util.concurrent.locks.ReentrantLock;
3
4public class SnowflakeGenerator {
5    private final long epoch;
6    private final long datacenterIdBits;
7    private final long workerIdBits;
8    private final long sequenceBits;
9    private final long maxDatacenterId;
10    private final long maxWorkerId;
11    private final long workerIdShift;
12    private final long datacenterIdShift;
13    private final long timestampLeftShift;
14    private final long sequenceMask;
15
16    private long datacenterId;
17    private long workerId;
18    private long sequence = 0L;
19    private long lastTimestamp = -1L;
20
21    private final Lock lock = new ReentrantLock();
22
23    public SnowflakeGenerator(long datacenterId, long workerId) {
24        this.epoch = 1288834974657L;
25        this.datacenterIdBits = 5L;
26        this.workerIdBits = 5L;
27        this.sequenceBits = 12L;
28
29        this.maxDatacenterId = ~(-1L << datacenterIdBits);
30        this.maxWorkerId = ~(-1L << workerIdBits);
31
32        this.workerIdShift = sequenceBits;
33        this.datacenterIdShift = sequenceBits + workerIdBits;
34        this.timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
35        this.sequenceMask = ~(-1L << sequenceBits);
36
37        if (datacenterId > maxDatacenterId || datacenterId < 0) {
38            throw new IllegalArgumentException("datacenterId ne peut pas être supérieur à maxDatacenterId ou inférieur à 0");
39        }
40        if (workerId > maxWorkerId || workerId < 0) {
41            throw new IllegalArgumentException("workerId ne peut pas être supérieur à maxWorkerId ou inférieur à 0");
42        }
43        this.datacenterId = datacenterId;
44        this.workerId = workerId;
45    }
46
47    public long nextId() {
48        lock.lock();
49        try {
50            long timestamp = timeGen();
51            if (timestamp < lastTimestamp) {
52                throw new RuntimeException("L'horloge a reculé. Refus de générer l'id");
53            }
54
55            if (lastTimestamp == timestamp) {
56                sequence = (sequence + 1) & sequenceMask;
57                if (sequence == 0) {
58                    timestamp = tilNextMillis(lastTimestamp);
59                }
60            } else {
61                sequence = 0L;
62            }
63
64            lastTimestamp = timestamp;
65
66            return ((timestamp - epoch) << timestampLeftShift) |
67                   (datacenterId << datacenterIdShift) |
68                   (workerId << workerIdShift) |
69                   sequence;
70        } finally {
71            lock.unlock();
72        }
73    }
74
75    private long tilNextMillis(long lastTimestamp) {
76        long timestamp = timeGen();
77        while (timestamp <= lastTimestamp) {
78            timestamp = timeGen();
79        }
80        return timestamp;
81    }
82
83    private long timeGen() {
84        return System.currentTimeMillis();
85    }
86
87    public static void main(String[] args) {
88        SnowflakeGenerator generator = new SnowflakeGenerator(1, 1);
89        long id = generator.nextId();
90        System.out.println("ID Snowflake généré : " + id);
91    }
92}
93

1require 'time'
2
3class SnowflakeGenerator
4  def initialize(datacenter_id, worker_id, sequence = 0)
5    @datacenter_id = datacenter_id
6    @worker_id = worker_id
7    @sequence = sequence
8    @last_timestamp = -1
9    @epoch = 1288834974657
10
11    @datacenter_id_bits = 5
12    @worker_id_bits = 5
13    @sequence_bits = 12
14
15    @max_datacenter_id = -1 ^ (-1 << @datacenter_id_bits)
16    @max_worker_id = -1 ^ (-1 << @worker_id_bits)
17
18    @worker_id_shift = @sequence_bits
19    @datacenter_id_shift = @sequence_bits + @worker_id_bits
20    @timestamp_left_shift = @sequence_bits + @worker_id_bits + @datacenter_id_bits
21    @sequence_mask = -1 ^ (-1 << @sequence_bits)
22  end
23
24  def next_id
25    timestamp = (Time.now.to_f * 1000).to_i
26
27    raise 'L\'horloge a reculé' if timestamp < @last_timestamp
28
29    if timestamp == @last_timestamp
30      @sequence = (@sequence + 1) & @sequence_mask
31      timestamp = til_next_millis(@last_timestamp) if @sequence == 0
32    else
33      @sequence = 0
34    end
35
36    @last_timestamp = timestamp
37
38    ((timestamp - @epoch) << @timestamp_left_shift) |
39      (@datacenter_id << @datacenter_id_shift) |
40      (@worker_id << @worker_id_shift) |
41      @sequence
42  end
43
44  private
45
46  def til_next_millis(last_timestamp)
47    timestamp = (Time.now.to_f * 1000).to_i
48    timestamp = (Time.now.to_f * 1000).to_i while timestamp <= last_timestamp
49    timestamp
50  end
51end
52
53## Utilisation
54generator = SnowflakeGenerator.new(1, 1)
55snowflake_id = generator.next_id
56puts "ID Snowflake généré : #{snowflake_id}"
57

<?php

class SnowflakeGenerator {
    private $epoch;
    private $datacenterIdBits;
    private $workerIdBits;
    private $sequenceBits;
    private $maxDatacenterId;
    private $maxWorkerId;
    private $workerIdShift;
    private $datacenterIdShift;
    private $timestampLeftShift;
    private $sequenceMask;

    private $datacenterId;
    private $workerId;
    private $sequence = 0;
    private $lastTimestamp = -1;

    public function __construct($datacenterId, $workerId) {
        $this->epoch = 1288834974657;
        $this->datacenterIdBits = 5;
        $this->workerIdBits = 5;
        $this->sequenceBits = 12;

        $this->maxDatacenterId = -1 ^ (-1 << $this->datacenterIdBits);
        $this->maxWorkerId = -1 ^ (-1 << $this->workerIdBits);

        $this->workerIdShift = $this->sequenceBits;
        $this->datacenterIdShift = $this

Whiz Tools

Générer et analyser l'outil d'ID Snowflake Twitter pour des insights

Générateur d'ID Snowflake