Generador de ID Snowflake: Crea Identificadores Únicos para Sistemas Distribuidos

¿Qué es un Generador de ID Snowflake?

Un generador de ID Snowflake crea identificadores únicos para sistemas distribuidos, desarrollado originalmente por Twitter para manejar el procesamiento de datos a gran escala. Este poderoso generador de ID único produce enteros de 64 bits compuestos por una marca de tiempo, ID de máquina y número de secuencia, asegurando unicidad en sistemas distribuidos sin coordinación entre servidores.

Nuestra herramienta gratuita en línea para generar ID Snowflake te permite generar y analizar ID Snowflake al instante, lo que la hace perfecta para desarrolladores que trabajan con microservicios, bases de datos distribuidas y aplicaciones de alto rendimiento.

Cómo Funciona la Generación de ID Snowflake

Los ID Snowflake son enteros de 64 bits con una estructura cuidadosamente diseñada que garantiza la unicidad:

41 bits: Marca de tiempo (milisegundos desde una época personalizada)
10 bits: ID de máquina (5 bits para ID de centro de datos, 5 bits para ID de trabajador)
12 bits: Número de secuencia

Esta estructura de ID distribuido permite la generación de aproximadamente 4,096 ID únicos por milisegundo por máquina, lo que la hace ideal para sistemas distribuidos de alto rendimiento.

Cómo Usar Nuestra Herramienta Generadora de ID Snowflake

Sigue estos simples pasos para generar ID Snowflake únicos:

Establecer Época Personalizada (Opcional): Usa la época predeterminada de Twitter (2010-11-04T01:42:54.657Z) o establece la tuya
Configurar IDs de Máquina: Ingresa el ID de máquina (0-31) y el ID de centro de datos (0-31)
Generar ID: Haz clic en "Generar" para crear un nuevo ID Snowflake único
Ver Resultados: Observa el ID generado y su desglose de componentes

Analizar ID Snowflake Existentes

Para decodificar un ID Snowflake, ingrésalo en el campo "Analizar ID" y haz clic en "Analizar" para ver su marca de tiempo, ID de máquina y componentes de secuencia.

Fórmula de Generación de ID Snowflake

El algoritmo de ID Snowflake construye identificadores únicos utilizando operaciones a nivel de bits:

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

Componentes de la Fórmula:

timestamp: Número de milisegundos desde la época
datacenterId: Entero de 5 bits (0-31) que identifica el centro de datos
workerId: Entero de 5 bits (0-31) que identifica la máquina trabajadora
sequence: Entero de 12 bits (0-4095) para múltiples ID por milisegundo

Proceso de Cálculo de ID Snowflake

El algoritmo de generación de ID Snowflake sigue estos pasos precisos:

Obtener Marca de Tiempo Actual: Recuperar la hora actual en milisegundos
Asegurar Orden Cronológico: Verificar que la marca de tiempo supere la última marca de tiempo utilizada
Manejar la Misma Marca de Tiempo: Si la marca de tiempo coincide con la anterior, incrementar el número de secuencia
Prevenir Desbordamiento: Si la secuencia alcanza 4096, esperar al siguiente milisegundo
Combinar Componentes: Usar operaciones a nivel de bits para crear el ID único final

Este proceso garantiza ID en aumento monótono dentro de cada máquina mientras mantiene la unicidad global en sistemas distribuidos.

Casos de Uso y Aplicaciones de ID Snowflake

Los ID Snowflake destacan en varios escenarios de computación distribuida:

Casos de Uso Principales

Sistemas Distribuidos: Generar ID únicos a través de múltiples máquinas sin coordinación
Procesamiento de Datos de Alto Volumen: Crear ID ordenables para conjuntos de datos masivos
Arquitectura de Microservicios: Asegurar identificadores únicos a través de diferentes servicios
Fragmentación de Bases de Datos: Usar componentes de marca de tiempo o ID de máquina para una partición de datos eficiente

Aplicaciones del Mundo Real

Plataformas de Redes Sociales: Twitter, Instagram para ID de publicaciones y usuarios
Sistemas de Comercio Electrónico: Seguimiento de pedidos y gestión de inventarios
Recolección de Datos IoT: Registro de eventos de dispositivos y datos de sensores
Sistemas Financieros: Procesamiento de transacciones y auditorías

Alternativas y Comparaciones de ID Snowflake

Si bien los ID Snowflake son poderosos, otros sistemas de generación de ID únicos incluyen:

Sistemas de ID Alternativos

UUID (Identificador Único Universal): Mejor para generación distribuida sin requisitos de ordenabilidad
IDs de Base de Datos Auto-incrementales: Solución simple limitada a instancias de base de datos únicas
ULID (Identificador Único Lexicográficamente Ordenable): Similar a Snowflake con codificación base32
NanoID: Generador de cadenas únicas compactas y seguras para URL para aplicaciones web

Limitaciones y Consideraciones de ID Snowflake

Entender las limitaciones de ID Snowflake ayuda en una implementación adecuada:

Desafíos Comunes

Problemas de Sincronización de Reloj: Dependencias del tiempo del sistema pueden causar problemas con ajustes de NTP o cambios de horario de verano
Limitación del Año 2079: El desbordamiento de la marca de tiempo de 41 bits requiere planificación a largo plazo para sistemas de alta escala
Gestión de ID de Máquina: Asegurar IDs de máquina únicos a través de grandes sistemas distribuidos requiere coordinación
Desbordamiento de Secuencia: Escenarios de rendimiento extremadamente alto pueden agotar 4096 secuencias por milisegundo
Ordenación entre Máquinas: Los ID son monótonos por máquina pero no globalmente entre todas las máquinas

Historia de los ID Snowflake

Los ID Snowflake fueron introducidos por Twitter en 2010 para resolver el desafío de generar identificadores únicos distribuidos y ordenables por tiempo a gran escala. A medida que la base de usuarios de Twitter y el volumen de tweets explotaron, los ID auto-incrementales tradicionales se volvieron insuficientes para su arquitectura distribuida.

Desde entonces, el sistema ha sido adoptado por grandes empresas tecnológicas, incluyendo Instagram, Discord y muchas otras plataformas que requieren generación de ID escalable para sistemas distribuidos.

Ejemplos de Código del Generador de ID Snowflake

Implementa generación de ID Snowflake en tu lenguaje de programación preferido:

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('El reloj se ha movido hacia atrás. Rechazando generar 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 generado: ${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("El reloj se ha movido hacia atrás. Rechazando generar 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 generado: {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 no puede ser mayor que maxDatacenterId o menor que 0");
39        }
40        if (workerId > maxWorkerId || workerId < 0) {
41            throw new IllegalArgumentException("workerId no puede ser mayor que maxWorkerId o 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("El reloj se ha movido hacia atrás. Rechazando generar 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 generado: " + 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 'El reloj se ha movido hacia atrás' 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 generado: #{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 no puede ser mayor que maxDatacenterId o menor que 0");
        }
        if ($workerId > $this->maxWorkerId || $workerId < 0) {
            throw new Exception("workerId no puede ser mayor que max

Whiz Tools

Generar y Analizar Herramienta de ID de Snowflake de Twitter para Perspectivas

Generador de ID de Snowflake

Generador de ID de Snowflake

Documentación

Generador de ID Snowflake: Crea Identificadores Únicos para Sistemas Distribuidos

¿Qué es un Generador de ID Snowflake?

Cómo Funciona la Generación de ID Snowflake

Cómo Usar Nuestra Herramienta Generadora de ID Snowflake

Analizar ID Snowflake Existentes

Fórmula de Generación de ID Snowflake

Proceso de Cálculo de ID Snowflake

Casos de Uso y Aplicaciones de ID Snowflake

Casos de Uso Principales

Aplicaciones del Mundo Real

Alternativas y Comparaciones de ID Snowflake

Sistemas de ID Alternativos

Limitaciones y Consideraciones de ID Snowflake

Desafíos Comunes

Historia de los ID Snowflake

Ejemplos de Código del Generador de ID Snowflake

Herramientas Relacionadas

Generador de UUIDs: Crea Identificadores Únicos Universales

Generador de ID Nano - Crea ID únicos seguros y compatibles con URL

Generador de Nombres de Proyectos Aleatorios

Generador de User Agent Aleatorio para Pruebas de Desarrollo Web

Generador de Claves API Aleatorias: Crea Cadenas Seguras de 32 Caracteres

Generador de CPF Válido para Pruebas y Desarrollo de Software

Generador de Ubicaciones Aleatorias: Creador de Coordenadas Globales

Generador de Hash MD5

Generador de KSUID Eficiente para Identificadores Únicos en Sistemas

Generador de Nombres de Bebé con Categorías - Encuentra el Nombre Perfecto