Pourquoi ASAP (Atlassian) Auth est le choix rapide et sûr pour l'authentification API REST ?

En tant que développeur senior travaillant beaucoup avec les API, la sécurité et l'efficacité sont toujours des priorités absolues. Lorsqu'il s'agit de sécuriser les API REST, il existe de nombreuses méthodes d'authentification disponibles, mais toutes ne sont pas égales.

ASAP (Authentification pour les services et les projets) d'Atlassian se distingue comme une option robuste, évolutive et sécurisée, en particulier lorsqu'il s'agit de microservices ou d'API qui nécessitent des mécanismes d'authentification forts. Mais avant de comprendre pourquoi ASAP est un si bon choix, jetons un coup d'œil rapide à ce que sont les API REST et pourquoi elles sont importantes.

Que sont les API REST ? ?

Les API

REST (Representational State Transfer) sont un ensemble de règles qui permettent la création de services Web légers, maintenables et évolutifs. Ils suivent une architecture client-serveur sans état dans laquelle le serveur traite la demande du client et renvoie une réponse, généralement au format JSON ou XML. Les API REST sont largement utilisées en raison de leur simplicité, de leur évolutivité et de leur capacité à séparer l'interface utilisateur du serveur, ce qui les rend idéales pour créer des services Web accessibles par divers clients, notamment les navigateurs Web, les appareils mobiles. appareils et autres serveurs.

Qu’est-ce que l’authentification ASAP ? ?️

ASAP (Authentication for Services and Projects) est un mécanisme d'authentification basé sur des jetons développé par Atlassian. Il est spécialement conçu pour la communication de service à service, où un service doit en appeler un autre en toute sécurité. Au lieu de s'appuyer sur les informations d'identification de l'utilisateur ou sur OAuth (qui est plus centré sur l'utilisateur), ASAP utilise JWT (JSON Web Tokens) pour accorder un accès temporaire aux services. Ceci est particulièrement utile dans les architectures de microservices, où les services doivent authentifier et autoriser les demandes efficacement sans avoir à gérer les sessions ou les informations d'identification des utilisateurs.

Principales fonctionnalités de l'authentification ASAP :

• Basé sur JWT : ASAP s'appuie sur des jetons JWT, qui sont compacts, sécurisés pour les URL et peuvent contenir des revendications qui représentent l'identité et les autorisations du demandeur.
• Apatride : Le serveur n'a pas besoin de stocker d'informations de session, car toutes les informations nécessaires sont codées dans le JWT.
• Sécurisé : Les jetons ASAP sont signés à l'aide d'une clé privée, garantissant que seuls les services autorisés peuvent générer des jetons valides.
• *Évolutif : * Idéal pour les architectures de microservices, où les services communiquent fréquemment entre eux.

Comment implémenter ASAP Auth en Python, Java et Go ?

Maintenant que nous comprenons les bases d'ASAP Auth, voyons comment vous pouvez l'implémenter dans différents langages de programmation.

Implémentation Python

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}")

Implémentation Java

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

Aller à la mise en œuvre

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

Comment tester l'authentification ASAP à l'aide d'outils ?

Le test de l'authentification ASAP nécessite des outils capables d'envoyer des requêtes HTTP avec des en-têtes personnalisés. Voici comment procéder en utilisant EchoAPI et cURL.

Tester avec EchoAPI ?

Sélectionnez la méthode API et l'URL :
Choisissez la bonne méthode HTTP (par exemple, POST, GET) et saisissez l'URL du point de terminaison de l'API.

Accédez à l'onglet « Auth » :
Cliquez sur l'onglet Auth dans le panneau de demande.

Choisissez ASAP (Atlassian) Auth :
Dans la liste déroulante Type, sélectionnez dès que possible (Atlassian).

Configurer l'algorithme et les champs :

• Algorithme : Choisissez l'algorithme de signature (par exemple, HS256).
• Émetteur : Saisissez l'identité qui génère le jeton.
• Audience : Indiquez les destinataires prévus du jeton.
• ID de clé : Saisissez l'identifiant de la clé de signature.
• Clé privée : Entrez la clé de signature.

Enregistrer et envoyer :
Cliquez sur Enregistrer, puis sur Envoyer pour exécuter la demande avec l'authentification ASAP

Test avec cURL

curl -X GET "https://api.target-service.com/data" \
-H "Authorization: Bearer <your-asap-token>"

Cette commande envoie le jeton ASAP dans le cadre de l'en-tête HTTP et vous pouvez inspecter la réponse directement dans le terminal.

Conclusion ?

ASAP Auth fournit un moyen robuste, évolutif et sécurisé de gérer l'authentification dans les communications de service à service, en particulier dans les architectures de microservices. En tirant parti de JWT, ASAP permet une authentification sans état basée sur des jetons, ce qui est crucial pour maintenir une sécurité et des performances élevées. Que vous travailliez avec Python, Java ou Go, la mise en œuvre d'ASAP Auth est simple et s'intègre bien aux flux de travail existants.

De plus, tester cette méthode d'authentification à l'aide d'outils comme EchoAPI ou cURL garantit que votre implémentation est sécurisée et fonctionne correctement. Alors que vous continuez à créer et à sécuriser vos API REST, envisagez d'utiliser ASAP Auth pour améliorer à la fois la sécurité et l'efficacité de vos services.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!