अपस्टैश रेडिस और क्लाउडफ्लेयर वर्कर्स के साथ सुरक्षित API कीज़ बनाएं: चरण-दर-चरण गाइड

API कीज़ आपकी सर्विस की फ्रंट-डोर चाबियों की तरह हैं - वे उपयोगकर्ताओं को अंदर आने देती हैं जबकि चीजों को सुरक्षित रखती हैं। इस ब्लॉग में, मैं आपको अपस्टैश रेडिस का उपयोग करके तेज़, सर्वरलेस डेटा स्टोरेज के लिए और क्लाउडफ्लेयर वर्कर्स का उपयोग करके एज पर अनुरोधों को संभालने के लिए एक सरल, सुरक्षित API की जनरेटर बनाने के बारे में बताऊंगा। चाहे आप एक नई सर्विस सेट अप कर रहे हों या किसी मौजूदा ऐप में कीज़ जोड़ रहे हों, आप सीखेंगे कि API कीज़ कैसे जनरेट, स्टोर, और वैलिडेट करें ताकि सब कुछ सुचारू और कुशलता से चलता रहे।

API की क्या है?

API की एक यूनिक कोड है जो आपके API तक पहुंचने की कोशिश कर रहे यूजर या एप्लिकेशन की पहचान और प्रमाणीकरण करता है। इसे एक व्यक्तिगत पास की तरह समझें: जब कोई आपकी सर्विस का उपयोग करना चाहता है, तो उन्हें यह साबित करने के लिए यह "की" दिखानी होगी कि उन्हें अंदर जाने की अनुमति है। API कीज़ आपको यह नियंत्रित करने में मदद करती हैं कि कौन आपके संसाधनों तक पहुंच सकता है, और उनका उपयोग अक्सर उपयोग ट्रैक करने, सीमाएं लागू करने, या अनधिकृत पहुंच को रोकने के लिए किया जाता है। वे API एक्सेस को प्रबंधित करने और अपने डेटा को सुरक्षित रखने का एक सीधा तरीका हैं।

हम क्या बनाएंगे

इस गाइड में, हम एक API की जनरेटर बनाएंगे जो दो मुख्य कार्यक्षमताएं प्रदान करता है:

कस्टम सेटिंग्स के साथ नई API कीज़ जनरेट करना
उनके मेटाडेटा को प्राप्त करते हुए API कीज़ को वैलिडेट करना

मुख्य विशेषताओं में शामिल होंगे:

कस्टमाइज़ेबल की प्रीफिक्सेस
एक्सपायरेशन डेट्स
रेट लिमिटिंग
मेटाडेटा स्टोरेज
ओनर आइडेंटिफिकेशन

आइए अपने API की सिस्टम को विज़ुअलाइज़ करें

यह डायग्राम क्लाइंट, हमारे क्लाउडफ्लेयर वर्कर, और अपस्टैश रेडिस के बीच API कीज़ बनाने और वैलिडेट करने दोनों के लिए इंटरैक्शन को दर्शाता है। इस अवलोकन को ध्यान में रखते हुए, आइए अपना सिस्टम बनाना शुरू करें।

अपस्टैश रेडिस और क्लाउडफ्लेयर वर्कर्स के साथ सुरक्षित API कीज़ बनाएं: चरण-दर-चरण गाइड

पूर्वापेक्षाएँ

फॉलो करने के लिए, आपको आवश्यकता होगी:

एक क्लाउडफ्लेयर वर्कर्स अकाउंट
एक अपस्टैश अकाउंट
आपकी स्थानीय मशीन पर Node.js इंस्टॉल्ड

प्रोजेक्ट स्ट्रक्चर

हमारे प्रोजेक्ट की निम्न संरचना होगी:

folder-name/ 
├── src/ 
│   ├── config/ 
│   │   ├── generateApiKey.ts 
│   │   └── schema-validation.ts 
│   ├── lib/ 
│   │   └── ratelimit.ts 
│   ├── routes/ 
│   │   ├── create.ts 
│   │   └── verify.ts 
│   ├── types/ 
│   │   └── api.ts 
│   └── index.ts 
├── package.json 
└── wrangler.toml

चरण 1: प्रोजेक्ट सेटअप

आइए अपना प्रोजेक्ट सेट अप करके और आवश्यक निर्भरताएं इंस्टॉल करके शुरू करें।

नया प्रोजेक्ट डायरेक्टरी बनाएं

अपना टर्मिनल खोलें और निम्न कमांड चलाएं:

mkdir keyflow 
cd keyflow 
npm init -y

निर्भरताएं इंस्टॉल करें

हमें अपने प्रोजेक्ट के लिए कुछ पैकेजों की आवश्यकता होगी:

npm install hono @upstash/redis @upstash/ratelimit @hono/zod-validator zod wrangler

@upstash/redis: सर्वरलेस एनवायरनमेंट्स के लिए अपस्टैश रेडिस क्लाइंट @upstash/ratelimit: अपस्टैश रेडिस के लिए रेट लिमिटिंग लाइब्रेरी @hono/zod-validator: Hono के लिए रिक्वेस्ट वैलिडेशन मिडलवेयर zod: TypeScript-फर्स्ट स्कीमा वैलिडेशन लाइब्रेरी wrangler: वर्कर्स डेवलपमेंट और डिप्लॉयमेंट के लिए क्लाउडफ्लेयर का CLI

अपस्टैश रेडिस सेट अप करें

अपने अपस्टैश अकाउंट में लॉगिन करें और एक नया रेडिस डेटाबेस बनाएं

एक बार बन जाने पर, "REST API" सेक्शन पर जाएं

.env सेक्शन में UPSTASH_REDIS_REST_URL और UPSTASH_REDIS_REST_TOKEN कॉपी करें

क्लाउडफ्लेयर वर्कर्स कॉन्फ़िगर करें

अपने प्रोजेक्ट रूट में निम्न सामग्री के साथ एक wrangler.toml फ़ाइल बनाएं:

name = "keyflow" 
main = "src/index.ts" 
compatibility_date = "2023-05-18" 
[vars] 
UPSTASH_REDIS_REST_URL = "your-redis-url" 
UPSTASH_REDIS_REST_TOKEN = "your-redis-token"

"your-redis-url" और "your-redis-token" को अपस्टैश से कॉपी किए गए मानों से बदलें।

चरण 2: API टाइप्स परिभाषित करना

आइए अपने API अनुरोधों और प्रतिक्रियाओं के लिए TypeScript इंटरफेस को परिभाषित करके शुरू करें। ये टाइप्स हमारे पूरे एप्लिकेशन में टाइप सेफ्टी बनाए रखने में मदद करेंगे। src/types/api.ts नामक एक नई फ़ाइल बनाएं:

export type CreateKeyRequest = { 
  apiId: string; 
  prefix?: string; 
  byteLength?: number; 
  ownerId?: string; 
  name: string; 
  meta?: Record; 
  expires?: number; 
  ratelimit?: { 
    type: "fast" | "consistent"; 
    limit: number; 
    refillRate: number; 
    refillInterval: number; 
  }; 
}; 
export type CreateKeyResponse = { 
  key: string; 
  keyId: string; 
}; 
export type VerifyKeyRequest = { 
  key: string; 
}; 
export type VerifyKeyResponse = { 
  valid: boolean; 
  ownerId?: string; 
  meta?: Record; 
  expires?: number; 
  ratelimit?: { 
    limit: number; 
    remaining: number; 
    reset: number; 
  }; 
}; 
export type Env = { 
  UPSTASH_REDIS_REST_URL: string; 
  UPSTASH_REDIS_REST_TOKEN: string; 
};

चरण 3: API की जनरेशन लागू करना

अब, आइए अपनी API कीज़ जनरेट करने के लिए एक यूटिलिटी फंक्शन बनाएं। src/config/generateApiKey.ts नामक एक नई फ़ाइल बनाएं:

export function generateApiKey( 
  prefix: string | undefined, 
  byteLength: number, 
): string { 
  const randomBytes = crypto.getRandomValues(new Uint8Array(byteLength)); 
  const key = btoa(String.fromCharCode(...new Uint8Array(randomBytes))) 
    .replace(/\+/g, "-") 
    .replace(/\//g, "_") 
    .replace(/=/g, ""); 
  return prefix ? `${prefix}_${key}` : key; 
}

यह फंक्शन क्रिप्टोग्राफिकली सिक्योर रैंडम बाइट्स का उपयोग करके एक रैंडम API की जनरेट करता है, इसे बेस64 में एन्कोड करता है, और इसे URL-सेफ बनाता है।

चरण 4: रेट लिमिटिंग लागू करें

src/lib/ratelimit.ts नामक फ़ाइल बनाएं:

import { Ratelimit } from "@upstash/ratelimit"; 
import { Redis } from "@upstash/redis/cloudflare"; 
import type { Context, Next } from "hono"; 
import { env } from "hono/adapter"; 
import type { Env } from "../types/api"; 
// रेट लिमिटिंग के लिए मिडलवेयर 
export async function rateLimitMiddleware(c: Context, next: Next) { 
  const { UPSTASH_REDIS_REST_TOKEN, UPSTASH_REDIS_REST_URL } = env(c); 
  const redis = new Redis({ 
    url: UPSTASH_REDIS_REST_URL, 
    token: UPSTASH_REDIS_REST_TOKEN, 
  }); 
  const ratelimit = new Ratelimit({ 
    redis: redis, 
    limiter: Ratelimit.slidingWindow(5, "30 s"), 
  }); 
  const ip = c.req.header("CF-Connecting-IP") || "127.0.0.1"; 
  const { success, limit, remaining, reset } = await ratelimit.limit(ip); 
  if (!success) { 
    return c.json({ error: "Rate limit exceeded" }, 429); 
  } 
  c.header("X-RateLimit-Limit", limit.toString()); 
  c.header("X-RateLimit-Remaining", remaining.toString()); 
  c.header("X-RateLimit-Reset", reset.toString()); 
  await next(); 
}

चरण 5: API रूट्स बनाना

आइए अपनी मुख्य एप्लिकेशन फ़ाइल सेट अप करें और अपने API रूट्स बनाएं। यह फ़ाइल दो मुख्य रूट्स के साथ हमारे Hono एप्लिकेशन को सेट अप करती है: नई API कीज़ जनरेट करने के लिए /keys/create और मौजूदा कीज़ को उनके मेटाडेटा के साथ वैलिडेट करने के लिए /keys/verify, तीन अलग-अलग फ़ाइलों के साथ।

1. Create API Key Route लागू करें

src/routes/create.ts नामक फ़ाइल बनाएं:

import { zValidator } from "@hono/zod-validator" 
import { Redis } from "@upstash/redis/cloudflare" 
import { Hono } from "hono" 
import { generateApiKey } from "../config/generateApiKey" 
import { createApiKeySchema } from "../config/schema-validation" 
import type { CreateKeyRequest, CreateKeyResponse, Env } from "../types/api" 
const create = new Hono<{ Bindings: Env }>() 
create.post( 
  "/create", 
  zValidator("json", createApiKeySchema, (result, c) => { 
    if (!result.success) { 
      return c.text("Invalid!", 400) 
    } 
  }), 
  async (c) => { 
    // रेडिस क्लाइंट इनिशियलाइज़ करें 
    const { UPSTASH_REDIS_REST_TOKEN, UPSTASH_REDIS_REST_URL } = c.env 
    const redis = new Redis({ 
      url: UPSTASH_REDIS_REST_URL, 
      token: UPSTASH_REDIS_REST_TOKEN, 
    }) 
    const body = await c.req.json() 
    // यूनिक आइडेंटिफायर और API की जनरेट करें 
    const keyId = crypto.randomUUID() 
    const key = generateApiKey(body.prefix, body.byteLength || 16) 
    const keyData = { 
      ...body, 
      key, 
      keyId, 
      createdAt: Date.now(), 
    } 
    const encodedKey = encodeURIComponent(key) 
    try { 
      // रेडिस में की डेटा और लुकअप रेफरेंस स्टोर करें 
      await redis.set(`key:${keyId}`, JSON.stringify(keyData)) 
      await redis.set(`lookup:${encodedKey}`, keyId) 
      return c.json({ key, keyId }) 
    } catch (error) { 
      console.error("Error in /keys/create:", error) 
      return c.json({ error: "Internal Server Error" }, 500) 
    } 
  } 
) 
export default create

2. Verify API Key Route लागू करें

src/routes/verify.ts नामक फ़ाइल बनाएं:

import { zValidator } from "@hono/zod-validator"; 
import { Redis } from "@upstash/redis/cloudflare"; 
import { Hono } from "hono"; 
import { verifyApiKeySchema } from "../config/schema-validation"; 
import type { CreateKeyRequest, Env, VerifyKeyRequest, VerifyKeyResponse, } from "../types/api"; 
// एनवायरनमेंट बाइंडिंग्स के साथ Hono ऐप इनिशियलाइज़ करें 
const verify = new Hono<{ Bindings: Env }>(); 
// API की वैलिडेट करने के लिए POST रूट परिभाषित करें 
verify.post( 
  "/verify", 
  // स्कीमा के खिलाफ रिक्वेस्ट बॉडी वैलिडेट करें 
  zValidator("json", verifyApiKeySchema, (result, c) => { 
    if (!result.success) { 
      return c.text("Invalid!", 400); // वैलिडेशन फेल होने पर 400 लौटाएं 
    } 
  }), 
  async (c) => { 
    // एनवायरनमेंट वेरिएबल्स के साथ रेडिस सेट अप करें 
    const { UPSTASH_REDIS_REST_TOKEN, UPSTASH_REDIS_REST_URL } = c.env; 
    const redis = new Redis({ 
      url: UPSTASH_REDIS_REST_URL, 
      token: UPSTASH_REDIS_REST_TOKEN, 
    }); 
    const body = await c.req.json(); 
    if (!body.key) { 
      return c.json({ error: "key is required" }, 400); // रिक्वेस्ट बॉडी में की आवश्यक 
    } 
    const encodedKey = encodeURIComponent(body.key); 
    const keyId = await redis.get(`lookup:${encodedKey}`); // एन्कोडेड की का उपयोग करके की ID प्राप्त करें 
    if (!keyId) { 
      return c.json({ valid: false }); // की नहीं मिली 
    } 
    const keyDataString = await redis.get(`key:${keyId}`); // की ID द्वारा की डेटा प्राप्त करें 
    if (!keyDataString || typeof keyDataString !== "string") { 
      return c.json({ valid: false }); // की डेटा गायब या अमान्य 
    } 
    let keyData: CreateKeyRequest & { key: string; keyId: string; createdAt: number; }; 
    try { 
      keyData = JSON.parse(keyDataString); // की डेटा पार्स करें 
    } catch (parseError) { 
      // अमान्य डेटा को हटाकर पार्स एरर हैंडल करें 
      console.error("Key data parse error:", parseError); 
      await Promise.all([ 
        redis.del(`key:${keyId}`), 
        redis.del(`lookup:${encodedKey}`), 
      ]); 
      return c.json( 
        { 
          error: "Invalid key data in storage", 
          details: parseError instanceof Error ? parseError.message : "Unknown parse error", 
          valid: false, 
        }, 
        500, 
      ); 
    } 
    // जांचें कि क्या की एक्सपायर हो गई है 
    if (keyData.expires && keyData.expires < Date.now()) { 
      await Promise.all([ 
        redis.del(`key:${keyId}`), 
        redis.del(`lookup:${encodedKey}`), 
      ]); 
      return c.json({ valid: false }); 
    } 
    // वैलिडेशन स्टेटस और मेटाडेटा के साथ प्रतिक्रिया तैयार करें 
    const response: VerifyKeyResponse = { 
      valid: true, 
      ownerId: keyData.ownerId, 
      meta: keyData.meta, 
      expires: keyData.expires, 
    }; 
    if (keyData.ratelimit) { 
      response.ratelimit = { 
        limit: keyData.ratelimit.limit, 
        remaining: keyData.ratelimit.limit, 
        reset: Date.now() + keyData.ratelimit.refillInterval, 
      }; 
    } 
    return c.json(response); // वेरिफिकेशन प्रतिक्रिया लौटाएं 
  }, 
); 
export default verify;

3. मेन फ़ाइल index.ts लागू करें

src/index.ts मेन फ़ाइल को create.ts, verify.ts, और rateLimitMiddleWare इम्पोर्ट करने के लिए लागू करें

import { Hono } from "hono"; 
import { rateLimitMiddleware } from "./lib/ratelimit"; 
import create from "./routes/create"; 
import verify from "./routes/verify"; 
import type { Env } from "./types/api"; 
const app = new Hono<{ Bindings: Env; }>().basePath("/keys"); 
app.use("*", rateLimitMiddleware); // create फ़ाइल रूट और verify फ़ाइल रूट जोड़ें 
app.route("/", create); 
app.route("/", verify); 
export default app;

चरण 6: डिप्लॉयमेंट

अपने Keyflow एप्लिकेशन को क्लाउडफ्लेयर वर्कर्स पर डिप्लॉय करें:

Wrangler इंस्टॉल करें:
```
npm install -g wrangler
```
क्लाउडफ्लेयर के साथ ऑथेंटिकेट करें:
```
wrangler login
```
अपना वर्कर डिप्लॉय करें:
```
wrangler deploy
```

चरण 7: डिप्लॉयमेंट

अब जब हमारा एप्लिकेशन तैयार है, आइए इसे क्लाउडफ्लेयर वर्कर्स पर डिप्लॉय करें:

सुनिश्चित करें कि आपके पास Wrangler CLI इंस्टॉल्ड है:
```
npm install -g wrangler 
```
अपने क्लाउडफ्लेयर अकाउंट के साथ ऑथेंटिकेट करें:
```
wrangler login 
```
अपना वर्कर डिप्लॉय करें:
```
wrangler deploy 
```

चरण 8: अपने API का टेस्ट करें

आइए अपने नए डिप्लॉयड API का टेस्ट करें:

नई API की बनाना

curl -X POST https://keyflow..workers.dev/keys/create \ 
 -H "Content-Type: application/json" \ 
 -d '{ 
   "apiId": "my-api", 
   "prefix": "prod", 
   "name": "Production API Key", 
   "expires": 1735689600000, 
   "meta": { 
     "environment": "production", 
     "team": "backend" 
   } 
 }'

API की वैलिडेट करना

curl -X POST https://keyflow..workers.dev/keys/verify \ 
 -H "Content-Type: application/json" \ 
 -d '{ 
   "key": "prod_AbC123XyZ..." 
 }'

<your-subdomain> को अपने क्लाउडफ्लेयर वर्कर्स सबडोमेन से और prod_AbC123XyZ... को create एंडपॉइंट से जनरेट की गई वास्तविक की से बदलें।

निष्कर्ष

API की जनरेटर बनाना आपके एप्लिकेशन के APIs को सुरक्षित करने और यह प्रबंधित करने में एक महत्वपूर्ण कदम है कि कौन आपकी सेवाओं तक पहुंच सकता है। एक ऐसा सिस्टम बनाकर जो API कीज़ जनरेट, वैलिडेट, और प्रबंधित कर सकता है, आप एक्सेस कंट्रोल की एक मजबूत परत जोड़ते हैं जो आपके डेटा को सुरक्षित और व्यवस्थित रखने में मदद करती है।

यहां एक ठोस API की जनरेटर में क्या जाता है इसका त्वरित विवरण:

सुरक्षित की जनरेशन: कस्टम प्रीफिक्स या सेट लंबाई जैसे विकल्पों सहित यूनिक, सुरक्षित कीज़ प्रत्येक की को विशिष्ट और अनुमान लगाने में कठिन बनाती हैं।
वैलिडेशन और एक्सपायरेशन: चेक और एक्सपायरेशन डेट्स जोड़ने से यह सुनिश्चित होता है कि प्रत्येक की केवल एक निर्धारित समय के लिए वैध है, जिससे आवश्यकतानुसार एक्सेस को नियंत्रित और सीमित करना आसान हो जाता है।
मेटाडेटा और रेट लिमिट्स: प्रत्येक की के साथ अतिरिक्त जानकारी स्टोर करना और रेट लिमिट्स सेट करना आपको की उपयोग की निगरानी करने, गतिविधि ट्रैक करने, और आपके API के किसी भी दुरुपयोग से बचने देता है।

अपस्टैश रेडिस और क्लाउडफ्लेयर वर्कर्स जैसे टूल्स का उपयोग करके एक सर्वरलेस और विश्व स्तर पर वितरित की मैनेजमेंट सिस्टम बनाना आसान हो जाता है जो अच्छी तरह से स्केल करता है और कुशलता से काम करता है।

इस फाउंडेशन के साथ, आप अपने APIs तक पहुंच को सुरक्षित और प्रबंधनीय रखने के लिए तैयार हैं, जिससे आपको मानसिक शांति मिलती है कि आपके संसाधन सुरक्षित हैं और निगरानी करने में आसान हैं।