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

एटलसियन का ASAP (सेवाओं और परियोजनाओं के लिए प्रमाणीकरण) प्रमाणीकरण एक मजबूत, स्केलेबल और सुरक्षित विकल्प के रूप में सामने आता है, खासकर जब माइक्रोसर्विसेज या एपीआई से निपटते समय मजबूत प्रमाणीकरण तंत्र की आवश्यकता होती है। लेकिन ASAP इतना बढ़िया विकल्प क्यों है, इस पर विचार करने से पहले, आइए एक नज़र डालें कि REST API क्या हैं और वे क्यों मायने रखते हैं।

REST API क्या हैं? ?

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

यथाशीघ्र प्रमाणीकरण क्या है? ?️

एएसएपी (सेवाओं और परियोजनाओं के लिए प्रमाणीकरण) एटलसियन द्वारा विकसित एक टोकन-आधारित प्रमाणीकरण तंत्र है। इसे विशेष रूप से सेवा-से-सेवा संचार के लिए डिज़ाइन किया गया है, जहां एक सेवा को दूसरे को सुरक्षित रूप से कॉल करने की आवश्यकता होती है। उपयोगकर्ता क्रेडेंशियल्स या OAuth (जो अधिक उपयोगकर्ता-केंद्रित है) पर भरोसा करने के बजाय, ASAP सेवाओं तक अस्थायी पहुंच प्रदान करने के लिए JWT (JSON वेब टोकन) का उपयोग करता है। यह विशेष रूप से माइक्रोसर्विस आर्किटेक्चर में उपयोगी है, जहां सेवाओं को उपयोगकर्ता सत्र या क्रेडेंशियल्स को प्रबंधित करने के ओवरहेड के बिना कुशलतापूर्वक अनुरोधों को प्रमाणित और अधिकृत करने की आवश्यकता होती है।

यथाशीघ्र प्रमाणीकरण की मुख्य विशेषताएं:

• JWT-आधारित: ASAP JWT टोकन पर निर्भर करता है, जो कॉम्पैक्ट, URL-सुरक्षित हैं, और ऐसे दावे कर सकते हैं जो अनुरोधकर्ता की पहचान और अनुमतियों का प्रतिनिधित्व करते हैं।
• स्टेटलेस: सर्वर को किसी भी सत्र की जानकारी संग्रहीत करने की आवश्यकता नहीं है, क्योंकि सभी आवश्यक जानकारी JWT में एन्कोड की गई है।
• सुरक्षित: ASAP टोकन पर एक निजी कुंजी का उपयोग करके हस्ताक्षर किए जाते हैं, यह सुनिश्चित करते हुए कि केवल अधिकृत सेवाएं ही वैध टोकन उत्पन्न कर सकती हैं।
• *स्केलेबल: * माइक्रोसर्विस आर्किटेक्चर के लिए आदर्श, जहां सेवाएं एक-दूसरे के साथ अक्सर संवाद करती हैं।

पायथन, जावा और गो में यथाशीघ्र प्रमाणीकरण कैसे लागू करें?

अब जब हम ASAP ऑथ की मूल बातें समझ गए हैं, तो आइए देखें कि आप इसे विभिन्न प्रोग्रामिंग भाषाओं में कैसे लागू कर सकते हैं।

पायथन कार्यान्वयन

import jwt
import requests
from datetime import datetime, timedelta
import os

# Define ASAP token creation function
def create_asap_token(issuer, audience, private_key):
    current_time = datetime.utcnow()
    payload = {
        'iss': issuer,
        'aud': audience,
        'iat': current_time,
        'exp': current_time   timedelta(minutes=5),
    }
    token = jwt.encode(payload, private_key, algorithm='RS256')
    return token

# Load private key from environment variable or file
private_key = os.getenv('PRIVATE_KEY')
if not private_key:
    with open('path_to_private_key.pem', 'r') as key_file:
        private_key = key_file.read()

issuer = 'your-service'
audience = 'target-service'

token = create_asap_token(issuer, audience, private_key)
if isinstance(token, bytes):
    token = token.decode('utf-8')

headers = {
    'Authorization': f'Bearer {token}'
}

try:
    response = requests.get('https://api.target-service.com/data', headers=headers)
    response.raise_for_status()  # Raises HTTPError for bad responses
    print(response.json())
except requests.exceptions.RequestException as e:
    print(f"Request failed: {e}")

जावा कार्यान्वयन

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;

import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.time.Instant;
import java.util.Date;

public class ASAPAuthExample {

    public static PrivateKey loadPrivateKey(String filename) throws Exception {
        String key = new String(Files.readAllBytes(Paths.get(filename)))
                        .replace("-----BEGIN PRIVATE KEY-----", "")
                        .replace("-----END PRIVATE KEY-----", "")
                        .replaceAll("\\s", "");

        byte[] keyBytes = java.util.Base64.getDecoder().decode(key);

        PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory kf = KeyFactory.getInstance("RSA");
        return kf.generatePrivate(spec);
    }

    public static String createASAPToken(String issuer, String audience, PrivateKey privateKey) {
        Algorithm algorithm = Algorithm.RSA256(null, privateKey);
        Instant now = Instant.now();

        return JWT.create()
                .withIssuer(issuer)
                .withAudience(audience)
                .withIssuedAt(Date.from(now))
                .withExpiresAt(Date.from(now.plusSeconds(300))) // 5 minutes expiry
                .sign(algorithm);
    }

    public static void main(String[] args) {
        try {
            String issuer = "your-service";
            String audience = "target-service";
            PrivateKey privateKey = loadPrivateKey("path_to_private_key.pem");

            String token = createASAPToken(issuer, audience, privateKey);

            // Use the token to make a secure API request (using your preferred HTTP client)
            System.out.println("Generated Token: "   token);
        } catch (Exception e) {
            System.err.println("Error creating token: "   e.getMessage());
        }
    }
}

कार्यान्वयन जाओ

package main

import (
    "fmt"
    "io/ioutil"
    "time"
    "github.com/golang-jwt/jwt"
)

func loadPrivateKey(path string) (*rsa.PrivateKey, error) {
    keyData, err := ioutil.ReadFile(path)
    if err != nil {
        return nil, err
    }

    return jwt.ParseRSAPrivateKeyFromPEM(keyData)
}

func createASAPToken(issuer, audience, privateKeyPath string) (string, error) {
    privateKey, err := loadPrivateKey(privateKeyPath)
    if err != nil {
        return "", err
    }

    token := jwt.NewWithClaims(jwt.SigningMethodRS256, jwt.MapClaims{
        "iss": issuer,
        "aud": audience,
        "iat": time.Now().Unix(),
        "exp": time.Now().Add(5 * time.Minute).Unix(),
    })

    tokenString, err := token.SignedString(privateKey)
    if err != nil {
        return "", err
    }

    return tokenString, nil
}

func main() {
    issuer := "your-service"
    audience := "target-service"
    privateKeyPath := "path_to_private_key.pem"

    token, err := createASAPToken(issuer, audience, privateKeyPath)
    if err != nil {
        fmt.Println("Error creating token:", err)
        return
    }

    // Use the token to make a secure API request (using your preferred HTTP client)
    fmt.Println("Generated Token:", token)
}

टूल का उपयोग करके यथाशीघ्र प्रामाणिकता का परीक्षण कैसे करें?

ASAP प्रमाणीकरण के परीक्षण के लिए ऐसे टूल की आवश्यकता होती है जो कस्टम हेडर के साथ HTTP अनुरोध भेज सकें। यहां बताया गया है कि आप इसे EchoAPI और cURL का उपयोग करके कैसे कर सकते हैं।

इकोएपीआई के साथ परीक्षण?

एपीआई विधि और यूआरएल चुनें:
सही HTTP विधि चुनें (उदाहरण के लिए, POST, GET) और API एंडपॉइंट URL दर्ज करें।

'प्रामाणिक' टैब पर नेविगेट करें:
अनुरोध पैनल में प्रामाणिक टैब पर क्लिक करें।

जितनी जल्दी हो सके (एटलसियन) प्रामाणिक चुनें:
टाइप ड्रॉपडाउन से, ASAP (एटलसियन) चुनें।

एल्गोरिदम और फ़ील्ड कॉन्फ़िगर करें:

• एल्गोरिदम: हस्ताक्षर एल्गोरिथ्म चुनें (जैसे, HS256)।
• जारीकर्ता: टोकन उत्पन्न करने वाली पहचान दर्ज करें।
• दर्शक: टोकन के इच्छित प्राप्तकर्ता प्रदान करें।
• कुंजी आईडी: हस्ताक्षर कुंजी के लिए पहचानकर्ता इनपुट करें।
• निजी कुंजी: हस्ताक्षर कुंजी दर्ज करें।

सहेजें और भेजें:
यथाशीघ्र प्रमाणीकरण के साथ अनुरोध निष्पादित करने के लिए सहेजें पर क्लिक करें, फिर भेजें पर क्लिक करें

कर्ल के साथ परीक्षण

curl -X GET "https://api.target-service.com/data" \
-H "Authorization: Bearer "

यह कमांड HTTP हेडर के हिस्से के रूप में ASAP टोकन भेजता है, और आप सीधे टर्मिनल में प्रतिक्रिया का निरीक्षण कर सकते हैं।

निष्कर्ष ?

एएसएपी ऑथ सर्विस-टू-सर्विस संचार में प्रमाणीकरण को संभालने के लिए एक मजबूत, स्केलेबल और सुरक्षित तरीका प्रदान करता है, खासकर माइक्रोसर्विस आर्किटेक्चर के भीतर। JWT का लाभ उठाकर, ASAP स्टेटलेस, टोकन-आधारित प्रमाणीकरण को सक्षम बनाता है, जो उच्च सुरक्षा और प्रदर्शन को बनाए रखने के लिए महत्वपूर्ण है। चाहे आप पायथन, जावा, या गो में काम कर रहे हों, एएसएपी ऑथ को लागू करना सीधा है और मौजूदा वर्कफ़्लो में अच्छी तरह से एकीकृत होता है।

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