KSUID ജനറേറ്റർ

പരിചയം

KSUID (K-Sortable Unique IDentifier) ഒരു പ്രത്യേക തിരിച്ചറിയൽ ഫോർമാറ്റാണ്, ഇത് പരമ്പരാഗത UUID (Universally Unique Identifier) എന്നിവയ്ക്കും മറ്റ് തിരിച്ചറിയൽ സിസ്റ്റങ്ങൾക്കുമുള്ള നിരവധി ആനുകൂല്യങ്ങൾ നൽകുന്നു. ഈ ഉപകരണം KSUIDകൾ വേഗത്തിൽ എളുപ്പത്തിൽ സൃഷ്ടിക്കാൻ അനുവദിക്കുന്നു.

KSUID എന്താണ്?

KSUID ഒരു 20-ബൈറ്റ് ക്രമീകരണശേഷിയുള്ള തിരിച്ചറിയൽ ആണ്, ഇത് ഉൾക്കൊള്ളുന്നു:

1. 32-ബിറ്റ് ടൈംസ്റ്റാമ്പ് (4 ബൈറ്റ്)
2. 16 ബൈറ്റ് യാദൃച്ഛികത

ഒരു സ്റ്റ്രിംഗായി പ്രതിനിധീകരിക്കുമ്പോൾ, KSUID ബേസ്62-ൽ എൻകോഡ് ചെയ്യപ്പെടുന്നു, ഇത് 27 അക്ഷരങ്ങൾ നീളമുള്ളതാണ്.

KSUIDയുടെ ഘടന

KSUIDയുടെ ഘടനയെ താഴെപ്പറയുന്നവയായി വിഭജിക്കാം:

1. ടൈംസ്റ്റാമ്പ് (4 ബൈറ്റ്): ഇത് യൂണിക്‌സ് എപ്പോച്ച് (1970-ൽ ജനുവരി 1, 00:00 UTC) മുതൽ കഴിഞ്ഞ സെക്കൻഡുകളുടെ എണ്ണം പ്രതിനിധീകരിക്കുന്നു. ടൈംസ്റ്റാമ്പ് KSUIDകൾ നിർമ്മാണ സമയത്തേക്കുറിച്ച് ക്രമീകരണശേഷിയുള്ളതായിരിക്കാം.

2. യാദൃച്ഛിക ഘടകം (16 ബൈറ്റ്): ഇത് ക്രിപ്റ്റോഗ്രാഫിക്കായി സുരക്ഷിതമായ യാദൃച്ഛിക സംഖ്യയാണ്, ഇത് ഒരേ സെക്കൻഡിൽ നിരവധി KSUIDകൾ സൃഷ്ടിക്കുമ്പോൾ പ്രത്യേകത ഉറപ്പാക്കുന്നു.

3. ബേസ്62 എൻകോഡിംഗ്: സംയുക്ത 20 ബൈറ്റ് (ടൈംസ്റ്റാമ്പ് + യാദൃച്ഛികം) പിന്നീട് ബേസ്62 (A-Z, a-z, 0-9) ഉപയോഗിച്ച് എൻകോഡ് ചെയ്യപ്പെടുന്നു, ഇത് അന്തിമ 27-അക്ഷരമുള്ള സ്റ്റ്രിംഗ് ഉൽപാദിക്കുന്നു.

KSUID ഫോർമുല

KSUIDയെ ഗണിതപരമായി പ്രതിനിധീകരിക്കാം:

$KSUID = Base62(T || R)$

എവിടെ:

• $T$ 32-ബിറ്റ് ടൈംസ്റ്റാമ്പ് ആണ്
• $R$ 128-ബിറ്റ് യാദൃച്ഛിക ഘടകം ആണ്
• $||$ സംയോജനത്തെ സൂചിപ്പിക്കുന്നു

ടൈംസ്റ്റാമ്പ് $T$ കണക്കാക്കപ്പെടുന്നു:

T = \text{floor}(\text{current_time} - \text{KSUID_epoch})

എവിടെ KSUID_epoch 1400000000 (2014-05-13T16:53:20Z) ആണ്.

KSUID ഘടനാ ചിത്രരൂപം

KSUIDകളുടെ ഉപയോഗ കേസുകൾ

KSUIDകൾ പ്രത്യേകിച്ച് താഴെപ്പറയുന്ന സാഹചര്യങ്ങളിൽ ഉപയോഗപ്രദമാണ്:

1. വിതരണം ചെയ്ത സിസ്റ്റങ്ങൾ: നിരവധി സർവറുകൾ അല്ലെങ്കിൽ സേവനങ്ങൾ തമ്മിൽ ഏകോപനം ഇല്ലാതെ പ്രത്യേക തിരിച്ചറിയലുകൾ ആവശ്യമുള്ളപ്പോൾ.

2. സമയ ക്രമീകരണശേഷിയുള്ള ഡാറ്റ: ഒരു വ്യത്യസ്ത ടൈംസ്റ്റാമ്പ് സൂക്ഷിക്കാതെ സൃഷ്ടി സമയത്തനുസരിച്ച് ഡാറ്റ ക്രമീകരിക്കാൻ ആഗ്രഹിക്കുന്നപ്പോൾ.

3. ഡാറ്റാബേസ് കീകൾ: ഡാറ്റാബേസുകളിൽ പ്രാഥമിക കീകളായി, പ്രത്യേകിച്ച് സ്വയം വർദ്ധിപ്പിക്കുന്ന സംഖ്യകൾ അനുയോജ്യമായിട്ടില്ലാത്ത വിതരണം ചെയ്ത ഡാറ്റാബേസുകളിൽ.

4. URL-സുരക്ഷിത തിരിച്ചറിയലുകൾ: വെബ് ആപ്ലിക്കേഷനുകളിൽ വിഭവങ്ങൾക്കായുള്ള ചെറുതായ, പ്രത്യേക, URL-സുരക്ഷിത തിരിച്ചറിയലുകൾ സൃഷ്ടിക്കാൻ.

5. ലോഗ് സഹകരണങ്ങൾ: മൈക്രോ സർവീസ് ആർക്കിടെക്ചറിൽ വ്യത്യസ്ത സേവനങ്ങളിലേക്കുള്ള ലോഗ് എൻട്രികൾ തമ്മിൽ സഹകരിക്കാൻ.

KSUIDകളുടെ ആനുകൂല്യങ്ങൾ

KSUIDകൾ മറ്റ് തിരിച്ചറിയൽ സിസ്റ്റങ്ങൾക്കേക്കാൾ നിരവധി ആനുകൂല്യങ്ങൾ നൽകുന്നു:

1. ക്രമീകരണശേഷി: UUIDകൾക്കു മാറ്റ്, KSUIDകൾ ക്രമീകരണ സമയത്തനുസരിച്ച് ക്രമീകരിക്കാം, ഇത് ഡാറ്റാബേസ് ഇൻഡക്സിംഗ്, ലോഗ് വിശകലനം എന്നിവയ്ക്കായി ഉപകാരപ്രദമാണ്.

2. ഏകോപനം ആവശ്യമില്ല: സ്വയം വർദ്ധിപ്പിക്കുന്ന ഐഡികൾക്കു മാറ്റ്, KSUIDകൾ വ്യത്യസ്ത സർവറുകൾക്ക് കൂട്ടായ്മ ഇല്ലാതെ സ്വതന്ത്രമായി സൃഷ്ടിക്കാം, കൂട്ടായ്മകൾ അപകടത്തിൽ വരുത്താതെ.

3. സംക്ഷിപ്ത പ്രതിനിധാനം: 27 അക്ഷരങ്ങളായ KSUIDകൾ, സ്റ്റ്രിംഗായി പ്രതിനിധീകരിക്കുമ്പോൾ UUIDകളേക്കാൾ കൂടുതൽ സംക്ഷിപ്തമാണ്.

4. ടൈംസ്റ്റാമ്പ് ഉൾക്കൊള്ളുന്നു: ഉൾക്കൊള്ളുന്ന ടൈംസ്റ്റാമ്പ്, ഒരു വ്യത്യസ്ത ടൈംസ്റ്റാമ്പ് ഫീൽഡ് സൂക്ഷിക്കാതെ സമയ അടിസ്ഥാനത്തിൽ ക്രമീകരണവും ഫിൽട്ടറിംഗും അനുവദിക്കുന്നു.

5. URL-സുരക്ഷിതം: ബേസ്62 എൻകോഡിംഗ് KSUIDകൾ URL-കളിൽ ഉപയോഗിക്കാൻ സുരക്ഷിതമാക്കുന്നു, അധിക എൻകോഡിംഗ് ആവശ്യമില്ല.

6. കൂട്ടായ്മാ സാധ്യത കുറവ്: 16-ബൈറ്റ് യാദൃച്ഛിക ഘടകം, ഉയർന്ന നിർമ്മാണ നിരക്കുകളിൽ പോലും കൂട്ടായ്മകൾ വളരെ അസാധ്യമാണ്.

ഈ ജനറേറ്റർ എങ്ങനെ ഉപയോഗിക്കാം

1. ആവശ്യമായ മറ്റ് പാരാമീറ്ററുകൾ നൽകുക (ഉദാഹരണത്തിന്, കസ്റ്റം ടൈംസ്റ്റാമ്പ്).
2. പുതിയ KSUID സൃഷ്ടിക്കാൻ "Generate KSUID" ബട്ടൺ ക്ലിക്കുചെയ്യുക.
3. സൃഷ്ടിച്ച KSUID ഔട്ട്‌പുട്ട് ഫീൽഡിൽ പ്രദർശിപ്പിക്കും.
4. ആവശ്യമെങ്കിൽ, പടിയെടുക്കൽ 1-3 ആവർത്തിച്ച് നിരവധി KSUIDകൾ സൃഷ്ടിക്കാം.
5. ഓരോ KSUID-നും "Copy" ബട്ടൺ ഉപയോഗിച്ച് ക്ലിപ്പ്ബോർഡിലേക്ക് കോപ്പി ചെയ്യാം.
6. ഓപ്ഷണലായി, സൃഷ്ടിച്ച KSUIDകളുടെ പട്ടിക ഡൗൺലോഡ് ചെയ്യാൻ "Export" ഫീച്ചർ ഉപയോഗിക്കാം.

ഓരോ KSUIDയും പ്രത്യേകമാണ്, അതിനാൽ അത് ഒരിക്കൽ മാത്രമേ ഉപയോഗിക്കേണ്ടതുള്ളൂ. പ്രത്യേക തിരിച്ചറിയലുകൾ ആവശ്യമുള്ളപ്പോൾ ഓരോ തവണയും പുതിയ KSUID സൃഷ്ടിക്കുക.

കോഡ് ഉദാഹരണങ്ങൾ

വിവിധ പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ KSUIDകൾ സൃഷ്ടിക്കുന്ന ഉദാഹരണങ്ങൾ ഇവിടെ നൽകിയിരിക്കുന്നു:

1## Python
2import ksuid
3
4new_id = ksuid.ksuid()
5print(f"Generated KSUID: {new_id}")
6

1// JavaScript
2const { ksuid } = require('ksuid')
3
4const newId = ksuid()
5console.log(`Generated KSUID: ${newId}`)
6

1// Java
2import com.github.ksuid.KsuidGenerator;
3
4public class KsuidExample {
5    public static void main(String[] args) {
6        String newId = KsuidGenerator.generate();
7        System.out.println("Generated KSUID: " + newId);
8    }
9}
10

1// C++
2#include <iostream>
3#include <ksuid/ksuid.hpp>
4
5int main() {
6    ksuid::Ksuid newId = ksuid::Ksuid::generate();
7    std::cout << "Generated KSUID: " << newId.string() << std::endl;
8    return 0;
9}
10

1## Ruby
2require 'ksuid'
3
4new_id = KSUID.new
5puts "Generated KSUID: #{new_id}"
6

1// PHP
2<?php
3require_once 'vendor/autoload.php';
4
5use Tuupola\KsuidFactory;
6
7$factory = new KsuidFactory();
8$newId = $factory->create();
9echo "Generated KSUID: " . $newId . "\n";
10?>
11

1// Go
2package main
3
4import (
5    "fmt"
6    "github.com/segmentio/ksuid"
7)
8
9func main() {
10    newId := ksuid.New()
11    fmt.Printf("Generated KSUID: %s\n", newId.String())
12}
13

1// Swift
2import KSUID
3
4let newId = KSUID()
5print("Generated KSUID: \(newId)")
6

റഫറൻസുകൾ

1. സെഗ്മെന്റിന്റെ KSUID GitHub റിപോസിറ്ററി: https://github.com/segmentio/ksuid
2. "Generating good unique identifiers" - പീറ്റർ ബോർഗൺ: https://peter.bourgon.org/blog/2019/05/20/generating-good-unique-ids.html
3. KSUID സ്പെസിഫിക്കേഷൻ: https://github.com/segmentio/ksuid/blob/master/README.md