माइक्रोसर्विस आर्किटेक्चर के लिए प्रॉक्सी: एपीआई सुरक्षा, लोड बैलेंसिंग और सुरक्षा

महत्वपूर्ण: माइक्रोसर्विस आर्किटेक्चर में प्रॉक्सी दो स्तरों पर काम करती हैं — ग्राहकों के लिए एक बाहरी गेटवे (API गेटवे) के रूप में और सेवाओं के बीच आंतरिक प्रॉक्सी (सर्विस मेष) के रूप में। दोनों स्तर सिस्टम की सुरक्षा और विश्वसनीयता के लिए महत्वपूर्ण हैं।

// NGINX को API गेटवे के रूप में कॉन्फ़िगर करने का उदाहरण
upstream auth_service {
    server auth:8001;
}

upstream user_service {
    server user:8002;
}

upstream order_service {
    server order:8003;
}

server {
    listen 80;
    server_name api.example.com;

    # अनुरोधों की दर सीमित करना
    limit_req_zone $binary_remote_addr zone=api_limit:10m rate=10r/s;

    location /api/auth/ {
        limit_req zone=api_limit burst=20;
        proxy_pass http://auth_service/;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }

    location /api/users/ {
        # प्रॉक्सी करने से पहले टोकन की जांच
        auth_request /auth/verify;
        proxy_pass http://user_service/;
    }

    location /api/orders/ {
        auth_request /auth/verify;
        proxy_pass http://order_service/;
    }

    # टोकनों की जांच के लिए आंतरिक एंडपॉइंट
    location = /auth/verify {
        internal;
        proxy_pass http://auth_service/verify;
        proxy_pass_request_body off;
        proxy_set_header Content-Length "";
    }
}

# Istio वर्चुअल सर्विस के लिए रूटिंग कॉन्फ़िगरेशन का उदाहरण
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: user-service
spec:
  hosts:
  - user-service
  http:
  - match:
    - headers:
        version:
          exact: "v2"
    route:
    - destination:
        host: user-service
        subset: v2
  - route:
    - destination:
        host: user-service
        subset: v1
      weight: 90
    - destination:
        host: user-service
        subset: v2
      weight: 10  # कैनरी तैनाती: v2 पर 10% ट्रैफ़िक

---
# सर्किट ब्रेकर कैस्केडिंग विफलताओं से सुरक्षा के लिए
apiVersion: networking.istio.io/v1beta1
kind: DestinationRule
metadata:
  name: user-service
spec:
  host: user-service
  trafficPolicy:
    connectionPool:
      tcp:
        maxConnections: 100
      http:
        http1MaxPendingRequests: 50
        maxRequestsPerConnection: 2
    outlierDetection:
      consecutiveErrors: 5
      interval: 30s
      baseEjectionTime: 30s
      maxEjectionPercent: 50

// Python: बाहरी API के लिए अनुरोधों के लिए प्रॉक्सी सेटअप
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

class ExternalAPIClient:
    def __init__(self, proxy_url, proxy_rotation=False):
        self.session = requests.Session()
        
        # प्रॉक्सी सेटअप
        self.proxies = {
            'http': proxy_url,
            'https': proxy_url
        }
        
        # विफलता के लिए पुनः प्रयास लॉजिक
        retry_strategy = Retry(
            total=3,
            backoff_factor=1,
            status_forcelist=[429, 500, 502, 503, 504],
            allowed_methods=["GET", "POST"]
        )
        adapter = HTTPAdapter(max_retries=retry_strategy)
        self.session.mount("http://", adapter)
        self.session.mount("https://", adapter)
    
    def call_payment_api(self, data):
        """प्रॉक्सी के माध्यम से भुगतान API के लिए अनुरोध"""
        try:
            response = self.session.post(
                'https://api.payment-provider.com/charge',
                json=data,
                proxies=self.proxies,
                timeout=10,
                headers={'User-Agent': 'MyService/1.0'}
            )
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            # त्रुटि लॉगिंग
            print(f"Payment API error: {e}")
            raise

# रोटेशन के लिए प्रॉक्सी पूल के साथ उपयोग
class ProxyPool:
    def __init__(self, proxy_list):
        self.proxies = proxy_list
        self.current = 0
    
    def get_next(self):
        proxy = self.proxies[self.current]
        self.current = (self.current + 1) % len(self.proxies)
        return proxy

# प्रारंभ
proxy_pool = ProxyPool([
    'http://user:pass@proxy1.example.com:8080',
    'http://user:pass@proxy2.example.com:8080',
    'http://user:pass@proxy3.example.com:8080'
])

# प्रत्येक अनुरोध के लिए अगला प्रॉक्सी का उपयोग करें
client = ExternalAPIClient(proxy_pool.get_next())

// Node.js: बाहरी API के लिए प्रॉक्सी के साथ स्वचालित रोटेशन
const axios = require('axios');
const HttpsProxyAgent = require('https-proxy-agent');

class ExternalAPIService {
  constructor(proxyList) {
    this.proxyList = proxyList;
    this.currentProxyIndex = 0;
    this.requestCounts = new Map(); // दर सीमित करने के लिए अनुरोध काउंटर
  }

  getNextProxy() {
    const proxy = this.proxyList[this.currentProxyIndex];
    this.currentProxyIndex = (this.currentProxyIndex + 1) % this.proxyList.length;
    return proxy;
  }

  async callAPI(endpoint, data, options = {}) {
    const proxyUrl = this.getNextProxy();
    const agent = new HttpsProxyAgent(proxyUrl);

    // दर सीमित करना: प्रॉक्सी पर प्रति मिनट 100 अनुरोधों से अधिक नहीं
    const proxyKey = proxyUrl;
    const now = Date.now();
    const count = this.requestCounts.get(proxyKey) || { count: 0, resetTime: now + 60000 };
    
    if (count.count >= 100 && now < count.resetTime) {
      // अगले प्रॉक्सी पर स्विच करें
      return this.callAPI(endpoint, data, options);
    }

    try {
      const response = await axios({
        method: options.method || 'POST',
        url: endpoint,
        data: data,
        httpsAgent: agent,
        timeout: options.timeout || 10000,
        headers: {
          'User-Agent': 'Mozilla/5.0 (compatible; MyService/1.0)',
          ...options.headers
        }
      });

      // काउंटर को अपडेट करें
      if (now >= count.resetTime) {
        this.requestCounts.set(proxyKey, { count: 1, resetTime: now + 60000 });
      } else {
        count.count++;
      }

      return response.data;
    } catch (error) {
      if (error.response?.status === 429) {
        // दर सीमा पार हो गई - दूसरे प्रॉक्सी पर स्विच करें
        console.log(`Rate limit on ${proxyUrl}, switching proxy`);
        return this.callAPI(endpoint, data, options);
      }
      throw error;
    }
  }
}

// उपयोग
const apiService = new ExternalAPIService([
  'http://user:pass@proxy1.example.com:8080',
  'http://user:pass@proxy2.example.com:8080'
]);

module.exports = apiService;

# HAProxy कॉन्फ़िगरेशन स्वास्थ्य जांच के साथ लोड बैलेंसिंग के लिए
global
    maxconn 4096
    log stdout format raw local0

defaults
    mode http
    timeout connect 5s
    timeout client 50s
    timeout server 50s
    option httplog

frontend api_frontend
    bind *:80
    default_backend api_servers

backend api_servers
    balance roundrobin
    
    # स्वास्थ्य जांच: हर 2 सेकंड में /health की जांच
    option httpchk GET /health
    http-check expect status 200
    
    # पुनः प्रयास लॉजिक
    retries 3
    option redispatch
    
    # वजन के साथ सर्वर (server3 2 गुना शक्तिशाली)
    server server1 10.0.1.10:8080 check weight 1 maxconn 500
    server server2 10.0.1.11:8080 check weight 1 maxconn 500
    server server3 10.0.1.12:8080 check weight 2 maxconn 1000
    
    # बैकअप सर्वर (केवल तभी उपयोग किया जाता है जब मुख्य अनुपलब्ध हों)
    server backup1 10.0.2.10:8080 check backup

// Python: बाहरी सेवाओं के लिए प्रॉक्सी के लिए सर्किट ब्रेकर का कार्यान्वयन
from datetime import datetime, timedelta
from enum import Enum

class CircuitState(Enum):
    CLOSED = "closed"      # सामान्य कार्य
    OPEN = "open"          # सेवा अनुपलब्ध है, अनुरोधों को ब्लॉक किया गया है
    HALF_OPEN = "half_open"  # पुनर्प्राप्ति के बाद परीक्षण मोड

class CircuitBreaker:
    def __init__(self, failure_threshold=5, timeout=60, success_threshold=2):
        self.failure_threshold = failure_threshold  # खोलने से पहले त्रुटियाँ
        self.timeout = timeout  # पुनर्प्राप्ति के प्रयासों के लिए सेकंड
        self.success_threshold = success_threshold  # बंद करने के लिए सफलताएँ
        
        self.state = CircuitState.CLOSED
        self.failures = 0
        self.successes = 0
        self.last_failure_time = None
    
    def call(self, func, *args, **kwargs):
        if self.state == CircuitState.OPEN:
            if datetime.now() - self.last_failure_time > timedelta(seconds=self.timeout):
                self.state = CircuitState.HALF_OPEN
                print("Circuit breaker: HALF_OPEN में स्विच करना")
            else:
                raise Exception("Circuit breaker OPEN: सेवा अनुपलब्ध है")
        
        try:
            result = func(*args, **kwargs)
            self._on_success()
            return result
        except Exception as e:
            self._on_failure()
            raise e
    
    def _on_success(self):
        self.failures = 0
        if self.state == CircuitState.HALF_OPEN:
            self.successes += 1
            if self.successes >= self.success_threshold:
                self.state = CircuitState.CLOSED
                self.successes = 0
                print("Circuit breaker: पुनर्प्राप्ति, CLOSED में स्विच करना")
    
    def _on_failure(self):
        self.failures += 1
        self.last_failure_time = datetime.now()
        if self.failures >= self.failure_threshold:
            self.state = CircuitState.OPEN
            print(f"Circuit breaker OPEN: {self.failures} लगातार त्रुटियाँ")

# उपयोग
breaker = CircuitBreaker(failure_threshold=3, timeout=30)

def call_external_service():
    # प्रॉक्सी के माध्यम से बाहरी API के लिए अनुरोध करने का आपका कोड
    pass

try:
    result = breaker.call(call_external_service)
except Exception as e:
    # फॉलबैक लॉजिक: कैश, डिफ़ॉल्ट मान आदि।
    print(f"सेवा अनुपलब्ध है: {e}")

# SSL/TLS और सुरक्षा के साथ NGINX कॉन्फ़िगरेशन
server {
    listen 443 ssl http2;
    server_name api.internal.example.com;

    # SSL प्रमाणपत्र
    ssl_certificate /etc/nginx/certs/api.crt;
    ssl_certificate_key /etc/nginx/certs/api.key;
    
    # आधुनिक प्रोटोकॉल और सिफर
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;
    
    # mTLS के लिए क्लाइंट प्रमाणपत्र
    ssl_client_certificate /etc/nginx/certs/ca.crt;
    ssl_verify_client on;
    
    # सुरक्षित हेडर
    add_header Strict-Transport-Security "max-age=31536000" always;
    add_header X-Frame-Options "DENY" always;
    add_header X-Content-Type-Options "nosniff" always;
    
    # दर सीमित करना
    limit_req_zone $binary_remote_addr zone=api:10m rate=100r/s;
    limit_req zone=api burst=200 nodelay;
    
    # कनेक्शन सीमित करना
    limit_conn_zone $binary_remote_addr zone=addr:10m;
    limit_conn addr 10;
    
    # IP व्हाइटलिस्टिंग
    allow 10.0.0.0/8;      # आंतरिक नेटवर्क
    allow 172.16.0.0/12;   # VPC
    deny all;
    
    location / {
        # JWT टोकन की जांच
        auth_jwt "Restricted API";
        auth_jwt_key_file /etc/nginx/jwt_key.json;
        
        proxy_pass http://backend_service;
        
        # क्लाइंट प्रमाणपत्र की जानकारी को प्रॉक्सी करना
        proxy_set_header X-Client-DN $ssl_client_s_dn;
        proxy_set_header X-Client-Verify $ssl_client_verify;
    }
}

प्रोडक्शन के लिए महत्वपूर्ण: सेवाओं के बीच आंतरिक संचार के लिए हमेशा mTLS का उपयोग करें, भले ही वे एक ही निजी नेटवर्क में हों। यह मैन-इन-द-मिडल प्रकार के हमलों से सुरक्षा करता है और सेवाओं के स्तर पर प्रमाणीकरण सुनिश्चित करता है, न कि केवल नेटवर्क स्तर पर।

# NGINX कॉन्फ़िगरेशन मेट्रिक्स को Prometheus में निर्यात करने के लिए
server {
    listen 9113;
    location /metrics {
        stub_status;
        access_log off;
        allow 10.0.0.0/8;  # केवल Prometheus सर्वर के लिए
        deny all;
    }
}

# संरचित लॉगिंग के लिए JSON प्रारूप में लॉगिंग
log_format json_combined escape=json
  '{'
    '"time_local":"$time_local",'
    '"remote_addr":"$remote_addr",'
    '"request":"$request",'
    '"status": "$status",'
    '"body_bytes_sent":"$body_bytes_sent",'
    '"request_time":"$request_time",'
    '"upstream_response_time":"$upstream_response_time",'
    '"upstream_addr":"$upstream_addr",'
    '"http_referrer":"$http_referer",'
    '"http_user_agent":"$http_user_agent",'
    '"http_x_forwarded_for":"$http_x_forwarded_for"'
  '}';

access_log /var/log/nginx/access.log json_combined;

// Node.js: प्रॉक्सी मिडलवेयर में ट्रेसिंग जोड़ना
const express = require('express');
const { v4: uuidv4 } = require('uuid');
const axios = require('axios');

const app = express();

// ट्रेस ID जोड़ने के लिए मिडलवेयर
app.use((req, res, next) => {
  // हेडर से ट्रेस ID प्राप्त करें या नया बनाएं
  const traceId = req.headers['x-trace-id'] || uuidv4();
  const spanId = uuidv4();
  
  // आगे बढ़ाने के लिए हेडर में जोड़ें
  req.traceId = traceId;
  req.spanId = spanId;
  res.setHeader('x-trace-id', traceId);
  
  // संसाधन शुरू होने का लॉग करें
  const startTime = Date.now();
  
  res.on('finish', () => {
    const duration = Date.now() - startTime;
    
    // विश्लेषण के लिए संरचित लॉग
    console.log(JSON.stringify({
      timestamp: new Date().toISOString(),
      traceId: traceId,
      spanId: spanId,
      method: req.method,
      path: req.path,
      status: res.statusCode,
      duration: duration,
      userAgent: req.headers['user-agent'],
      ip: req.ip
    }));
  });
  
  next();
});

// प्रॉक्सी एंडपॉइंट ट्रेसिंग हेडर के साथ
app.all('/api/*', async (req, res) => {
  const targetService = determineTargetService(req.path);
  
  try {
    const response = await axios({
      method: req.method,
      url: `http://${targetService}${req.path}`,
      data: req.body,
      headers: {
        ...req.headers,
        'x-trace-id': req.traceId,
        'x-parent-span-id': req.spanId,
        'x-span-id': uuidv4()  // डाउनस्ट्रीम अनुरोध के लिए नया स्पैन
      }
    });
    
    res.status(response.status).json(response.data);
  } catch (error) {
    console.error(JSON.stringify({
      traceId: req.traceId,
      error: error.message,
      service: targetService
    }));
    res.status(500).json({ error: 'सेवा अनुपलब्ध है' });
  }
});

function determineTargetService(path) {
  if (path.startsWith('/api/users')) return 'user-service:8080';
  if (path.startsWith('/api/orders')) return 'order-service:8080';
  return 'default-service:8080';
}

app.listen(3000);

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import httpx
import asyncio
from typing import List, Optional
import logging

app = FastAPI()
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class ProxyConfig(BaseModel):
    url: str
    max_requests_per_minute: int = 60

class ProxyPool:
    def __init__(self, proxies: List[ProxyConfig]):
        self.proxies = proxies
        self.current_index = 0
        self.request_counts = {p.url: 0 for p in proxies}
        self.reset_time = asyncio.get_event_loop().time() + 60
    
    async def get_next_proxy(self) -> str:
        # हर मिनट काउंटर रीसेट करें
        current_time = asyncio.get_event_loop().time()
        if current_time >= self.reset_time:
            self.request_counts = {p.url: 0 for p in self.proxies}
            self.reset_time = current_time + 60
        
        # उपलब्ध अनुरोधों के साथ प्रॉक्सी खोजें
        for _ in range(len(self.proxies)):
            proxy = self.proxies[self.current_index]
            self.current_index = (self.current_index + 1) % len(self.proxies)
            
            if self.request_counts[proxy.url] < proxy.max_requests_per_minute:
                self.request_counts[proxy.url] += 1
                return proxy.url
        
        # सभी प्रॉक्सी सीमा से बाहर हो गई हैं
        raise HTTPException(status_code=429, detail="सभी प्रॉक्सी दर सीमित हैं")

# प्रॉक्सी पूल का प्रारंभ
proxy_pool = ProxyPool([
    ProxyConfig(url="http://user:pass@proxy1.example.com:8080", max_requests_per_minute=100),
    ProxyConfig(url="http://user:pass@proxy2.example.com:8080", max_requests_per_minute=100),
    ProxyConfig(url="http://user:pass@proxy3.example.com:8080", max_requests_per_minute=100)
])

class ExternalAPIClient:
    def __init__(self, proxy_pool: ProxyPool):
        self.proxy_pool = proxy_pool
    
    async def fetch_data(self, endpoint: str, params: dict = None) -> dict:
        proxy_url = await self.proxy_pool.get_next_proxy()
        
        async with httpx.AsyncClient(proxies={"http://": proxy_url, "https://": proxy_url}) as client:
            try:
                response = await client.get(
                    endpoint,
                    params=params,
                    timeout=10.0,
                    headers={"User-Agent": "MyMicroservice/1.0"}
                )
                response.raise_for_status()
                
                logger.info(f"{proxy_url} के माध्यम से {endpoint} से सफलतापूर्वक प्राप्त किया");
                return response.json()
            
            except httpx.HTTPStatusError as e:
                logger.error(f"{endpoint} से HTTP त्रुटि {e.response.status_code}");
                raise HTTPException(status_code=e.response.status_code, detail=str(e))
            
            except httpx.RequestError as e:
                logger.error(f"{endpoint} के लिए अनुरोध त्रुटि: {e}");
                raise HTTPException(status_code=503, detail="बाहरी API अनुपलब्ध है");

api_client = ExternalAPIClient(proxy_pool)

@app.get("/data/{resource_id}")
async def get_external_data(resource_id: str):
    """एंडपॉइंट, जो प्रॉक्सी के माध्यम से बाहरी API से डेटा प्राप्त करता है"""
    external_endpoint = f"https://api.external-service.com/v1/resources/{resource_id}"
    
    try:
        data = await api_client.fetch_data(external_endpoint)
        return {"status": "success", "data": data}
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"अप्रत्याशित त्रुटि: {e}");
        raise HTTPException(status_code=500, detail="आंतरिक सर्वर त्रुटि");

@app.get("/health")
async def health_check():
    return {"status": "healthy", "service": "external-api-proxy"}

# प्रारंभ: uvicorn main:app --host 0.0.0.0 --port 8000

const express = require('express');
const axios = require('axios');
const rateLimit = require('express-rate-limit');

const app = express();
app.use(express.json());

// माइक्रोसर्विसेज की कॉन्फ़िगरेशन
const services = {
  users: [
    { url: 'http://user-service-1:8001', healthy: true, activeConnections: 0 },
    { url: 'http://user-service-2:8001', healthy: true, activeConnections: 0 },
    ...
  ],
  orders: [
    { url: 'http://order-service-1:8002', healthy: true, activeConnections: 0 },
    { url: 'http://order-service-2:8002', healthy: true, activeConnections: 0 },
    ...
  ]
};

// लोड बैलेंसिंग और रूटिंग लॉजिक
app.use('/api/users', (req, res) => {
  const service = getAvailableService(services.users);
  if (service) {
    axios({
      method: req.method,
      url: `${service.url}${req.path}`,
      data: req.body,
      headers: req.headers
    })
    .then(response => res.status(response.status).json(response.data))
    .catch(error => res.status(500).json({ error: 'सेवा अनुपलब्ध है' }));
  } else {
    res.status(503).json({ error: 'सभी सेवाएँ अनुपलब्ध हैं' });
  }
});

// सेवा उपलब्धता की जांच करने के लिए सहायक कार्य
function getAvailableService(serviceList) {
  return serviceList.find(service => service.healthy);
}

app.listen(3000, () => {
  console.log('API गेटवे 3000 पोर्ट पर सुन रहा है');
});