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

एपीआई कुंजी क्या है?

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

1. कस्टम सेटिंग्स के साथ नई एपीआई कुंजी उत्पन्न करना
2. अपने मेटाडेटा को पुनः प्राप्त करते समय एपीआई कुंजियों को मान्य करना

• अनुकूलन योग्य कुंजी उपसर्ग
• समाप्ति दिनांक
• दर सीमित करना
• मेटाडेटा भंडारण
• मालिक की पहचान

आइए हमारे एपीआई कुंजी सिस्टम की कल्पना करें

आवश्यकताएँ

• एक्लाउडफ्लेयर वर्कर्स  खाता
• एक अपस्टैश  खाता
• 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

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

1. अपने अपस्टैश खाते में लॉग इन करें और एक नया रेडिस डेटाबेस बनाएं

1. एक बार बन जाने के बाद, "REST API" अनुभाग पर जाएँ

1. UPSTASH_REDIS_REST_URL कॉपी करें  और UPSTASH_REDIS_REST_TOKEN .env में अनुभाग

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

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"

चरण 2:एपीआई प्रकारों को परिभाषित करना

export type CreateKeyRequest = {
 apiId: string;
 prefix?: string;
 byteLength?: number;
 ownerId?: string;
 name: string;
 meta?: Record<string, unknown>;
 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<string, unknown>;
 expires?: number;
 ratelimit?: {
 limit: number;
 remaining: number;
 reset: number;
 };
};
 
export type Env = {
 UPSTASH_REDIS_REST_URL: string;
 UPSTASH_REDIS_REST_TOKEN: string;
};
 

चरण 3:एपीआई कुंजी जनरेशन लागू करना

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;
}
 

चरण 4:दर सीमित लागू करें

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";
 
// Middleware for rate limiting
export async function rateLimitMiddleware(c: Context, next: Next) {
 const { UPSTASH_REDIS_REST_TOKEN, UPSTASH_REDIS_REST_URL } = env<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:एपीआई रूट बनाना

1. एपीआई कुंजी रूट बनाएं लागू करें

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) => {
 // Initialize Redis client
 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<CreateKeyRequest>()
 
 // Generate unique identifier and API key
 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 {
 // Store key data and lookup reference in Redis
 await redis.set(`key:${keyId}`, JSON.stringify(keyData))
 await redis.set(`lookup:${encodedKey}`, keyId)
 
 return c.json<CreateKeyResponse>({ key, keyId })
 } catch (error) {
 console.error("Error in /keys/create:", error)
 return c.json({ error: "Internal Server Error" }, 500)
 }
 }
)
 
export default create

2. एपीआई कुंजी रूट सत्यापित करें

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";
 
// Initialize Hono app with environment bindings
const verify = new Hono<{ Bindings: Env }>();
 
// Define POST route for verifying an API key
verify.post(
 "/verify",
 // Validate request body against schema
 zValidator("json", verifyApiKeySchema, (result, c) => {
 if (!result.success) {
 return c.text("Invalid!", 400); // Return 400 if validation fails
 }
 }),
 async (c) => {
 // Set up Redis with environment variables
 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<VerifyKeyRequest>();
 if (!body.key) {
 return c.json({ error: "key is required" }, 400); // Require key in the request body
 }
 
 const encodedKey = encodeURIComponent(body.key);
 const keyId = await redis.get<string>(`lookup:${encodedKey}`); // Retrieve key ID using encoded key
 
 if (!keyId) {
 return c.json<VerifyKeyResponse>({ valid: false }); // Key not found
 }
 
 const keyDataString = await redis.get<string>(`key:${keyId}`); // Retrieve key data by key ID
 
 if (!keyDataString || typeof keyDataString !== "string") {
 return c.json<VerifyKeyResponse>({ valid: false }); // Key data missing or invalid
 }
 
 let keyData: CreateKeyRequest & {
 key: string;
 keyId: string;
 createdAt: number;
 };
 
 try {
 keyData = JSON.parse(keyDataString); // Parse key data
 } catch (parseError) {
 // Handle parse error by deleting invalid data
 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,
 );
 }
 
 // Check if key has expired
 if (keyData.expires && keyData.expires < Date.now()) {
 await Promise.all([
 redis.del(`key:${keyId}`),
 redis.del(`lookup:${encodedKey}`),
 ]);
 return c.json<VerifyKeyResponse>({ valid: false });
 }
 
 // Formulate response with validation status and metadata
 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); // Return verification response
 },
);
 
export default verify;
 

3. मुख्य फ़ाइल Index.ts

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);
 
// add the create file route and verify file route
app.route("/", create);
app.route("/", verify);
 
export default app;
 

चरण 6:परिनियोजन

1. <पी> रैंगलर स्थापित करें:

   npm install -g wrangler

2. <पी> Cloudflare से प्रमाणित करें:

   wrangler login

3. <पी> अपना कार्यकर्ता तैनात करें:

   wrangler deploy

चरण 7:परिनियोजन

1. <पी> सुनिश्चित करें कि आपके पास रैंगलर सीएलआई स्थापित है:

   npm install -g wrangler
   

2. <पी> अपने क्लाउडफ़ेयर खाते से प्रमाणित करें:

   wrangler login
   

3. <पी> अपना कार्यकर्ता तैनात करें:

   wrangler deploy
   

चरण 8:अपने एपीआई का परीक्षण

एक नई एपीआई कुंजी बनाना

curl -X POST https://keyflow.<your-subdomain>.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"
 }
 }'

एपीआई कुंजी का सत्यापन

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

निष्कर्ष

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