Gerador de ID Snowflake: Crie Identificadores Únicos para Sistemas Distribuídos

O que é um Gerador de ID Snowflake?

Um gerador de ID Snowflake cria identificadores únicos para sistemas distribuídos, originalmente desenvolvido pelo Twitter para lidar com o processamento de dados em grande escala. Este poderoso gerador de ID único produz inteiros de 64 bits compostos por um timestamp, ID da máquina e número de sequência, garantindo unicidade em sistemas distribuídos sem coordenação entre servidores.

Nossa ferramenta gratuita de gerador de ID Snowflake online permite que você gere e analise IDs Snowflake instantaneamente, tornando-a perfeita para desenvolvedores que trabalham com microsserviços, bancos de dados distribuídos e aplicações de alto desempenho.

Como Funciona a Geração de ID Snowflake

IDs Snowflake são inteiros de 64 bits com uma estrutura cuidadosamente projetada que garante unicidade:

41 bits: Timestamp (milissegundos desde uma época personalizada)
10 bits: ID da Máquina (5 bits para ID do data center, 5 bits para ID do trabalhador)
12 bits: Número de Sequência

Esta estrutura de ID distribuído permite a geração de aproximadamente 4.096 IDs únicos por milissegundo por máquina, tornando-a ideal para sistemas distribuídos de alto desempenho.

Como Usar Nossa Ferramenta de Gerador de ID Snowflake

Siga estas etapas simples para gerar IDs Snowflake únicos:

Defina a Época Personalizada (Opcional): Use a época padrão do Twitter (2010-11-04T01:42:54.657Z) ou defina a sua própria
Configure os IDs das Máquinas: Insira o ID da máquina (0-31) e o ID do data center (0-31)
Gere o ID: Clique em "Gerar" para criar um novo ID Snowflake único
Veja os Resultados: Veja o ID gerado e sua decomposição em componentes

Analisar IDs Snowflake Existentes

Para decodificar um ID Snowflake, insira-o no campo "Analisar ID" e clique em "Analisar" para ver seu timestamp, ID da máquina e componentes de sequência.

Fórmula de Geração de ID Snowflake

O algoritmo de ID Snowflake constrói identificadores únicos usando operações bit a bit:

1ID = (timestamp << 22) | (datacenterId << 17) | (workerId << 12) | sequence
2

Componentes da Fórmula:

timestamp: Número de milissegundos desde a época
datacenterId: Inteiro de 5 bits (0-31) identificando o data center
workerId: Inteiro de 5 bits (0-31) identificando a máquina trabalhadora
sequence: Inteiro de 12 bits (0-4095) para múltiplos IDs por milissegundo

Processo de Cálculo de ID Snowflake

O algoritmo de geração de ID Snowflake segue estas etapas precisas:

Obter Timestamp Atual: Recuperar o tempo atual em milissegundos
Garantir Ordem Cronológica: Verificar se o timestamp excede o último timestamp usado
Lidar com o Mesmo Timestamp: Se o timestamp corresponder ao anterior, incrementar o número de sequência
Prevenir Overflow: Se a sequência atingir 4096, aguardar o próximo milissegundo
Combinar Componentes: Usar operações bit a bit para criar o ID único final

Esse processo garante IDs monotonamente crescentes dentro de cada máquina, mantendo a unicidade global em sistemas distribuídos.

Casos de Uso e Aplicações de ID Snowflake

IDs Snowflake se destacam em vários cenários de computação distribuída:

Casos de Uso Principais

Sistemas Distribuídos: Gerar IDs únicos em várias máquinas sem coordenação
Processamento de Dados de Alto Volume: Criar IDs ordenáveis para conjuntos de dados massivos
Arquitetura de Microsserviços: Garantir identificadores únicos entre diferentes serviços
Sharding de Banco de Dados: Usar componentes de timestamp ou ID da máquina para particionamento eficiente de dados

Aplicações do Mundo Real

Plataformas de Mídia Social: Twitter, Instagram para IDs de postagens e usuários
Sistemas de E-commerce: Rastreamento de pedidos e gerenciamento de inventário
Coleta de Dados IoT: Registro de eventos de dispositivos e dados de sensores
Sistemas Financeiros: Processamento de transações e trilhas de auditoria

Alternativas e Comparações de ID Snowflake

Embora os IDs Snowflake sejam poderosos, outros sistemas de geração de ID único incluem:

Sistemas de ID Alternativos

UUID (Identificador Único Universal): Melhor para geração distribuída sem requisitos de ordenação
IDs de Banco de Dados Auto-incrementais: Solução simples limitada a instâncias de banco de dados únicas
ULID (Identificador Lexicograficamente Ordenável Universalmente Único): Semelhante ao Snowflake com codificação base32
NanoID: Gerador de strings únicas compactas e seguras para URLs para aplicações web

Limitações e Considerações de ID Snowflake

Entender as limitações do ID Snowflake ajuda na implementação adequada:

Desafios Comuns

Problemas de Sincronização de Relógio: Dependências de tempo do sistema podem causar problemas com ajustes de NTP ou mudanças de horário de verão
Limitação do Ano 2079: O overflow do timestamp de 41 bits requer planejamento a longo prazo para sistemas de alta escala
Gerenciamento de ID de Máquina: Garantir IDs de máquina únicos em grandes sistemas distribuídos requer coordenação
Overflow de Sequência: Cenários de desempenho extremamente alto podem esgotar 4096 sequências por milissegundo
Ordenação entre Máquinas: IDs são monotônicos por máquina, mas não globalmente entre todas as máquinas

História dos IDs Snowflake

Os IDs Snowflake foram introduzidos pelo Twitter em 2010 para resolver o desafio de gerar identificadores únicos distribuídos e ordenáveis por tempo em grande escala. À medida que a base de usuários e o volume de tweets do Twitter explodiram, os IDs auto-incrementais tradicionais tornaram-se insuficientes para sua arquitetura distribuída.

O sistema foi adotado desde então por grandes empresas de tecnologia, incluindo Instagram, Discord e inúmeras outras plataformas que requerem geração de ID escalável para sistemas distribuídos.

Exemplos de Código do Gerador de ID Snowflake

Implemente a geração de ID Snowflake em sua linguagem de programação preferida:

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('O relógio retrocedeu. Recusando-se a gerar 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// Uso
55const generator = new SnowflakeGenerator();
56const id = generator.nextId(1, 1);
57console.log(`ID Snowflake gerado: ${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("O relógio retrocedeu. Recusando-se a gerar 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## Uso
58generator = SnowflakeGenerator(datacenter_id=1, worker_id=1)
59snowflake_id = generator.next_id()
60print(f"ID Snowflake gerado: {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 não pode ser maior que maxDatacenterId ou menor que 0");
39        }
40        if (workerId > maxWorkerId || workerId < 0) {
41            throw new IllegalArgumentException("workerId não pode ser maior que maxWorkerId ou menor que 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("O relógio retrocedeu. Recusando-se a gerar 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 gerado: " + 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 'O relógio retrocedeu' 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## Uso
54generator = SnowflakeGenerator.new(1, 1)
55snowflake_id = generator.next_id
56puts "ID Snowflake gerado: #{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->sequenceBits + $this->workerIdBits;
        $this->timestampLeftShift = $this->sequenceBits + $this->workerIdBits + $this->datacenterIdBits;
        $this->sequenceMask = -1 ^ (-1 << $this->sequenceBits);

        if ($datacenterId > $this->maxDatacenterId || $datacenterId < 0) {
            throw new Exception("datacenterId não pode ser maior que maxDatacenterId ou menor que 0");
        }
        if ($workerId > $this->maxWorkerId || $workerId < 0) {
            throw new Exception("workerId não pode ser maior que maxWorkerId ou menor que 0");
        }
        $this->datacenterId = $datacenterId;
        $this->workerId = $workerId;
    }

Whiz Tools

Gerar e Analisar Ferramenta de ID Snowflake do Twitter para Insights

Gerador de ID Snowflake