Mengapa ASAP (Atlassian) Auth ialah Pilihan Pantas & Selamat untuk Pengesahan API REST?

Sebagai pembangun kanan yang bekerja secara meluas dengan API, keselamatan dan kecekapan sentiasa menjadi keutamaan. Apabila ia datang untuk mendapatkan REST API, terdapat banyak kaedah pengesahan yang tersedia, tetapi tidak semuanya dicipta sama.

Pengesahan

Atlassian ASAP (Pengesahan untuk Perkhidmatan dan Projek) menonjol sebagai pilihan yang teguh, berskala dan selamat, terutamanya apabila berurusan dengan perkhidmatan mikro atau API yang memerlukan mekanisme pengesahan yang kukuh. Tetapi sebelum menyelami sebab ASAP ialah pilihan yang sangat baik, mari kita lihat dengan pantas apa itu REST API dan sebab ia penting.

Apakah itu REST API? ?

API

REST (Pemindahan Negeri Perwakilan) ialah satu set peraturan yang membenarkan penciptaan perkhidmatan web yang ringan, boleh diselenggara dan berskala. Mereka mengikuti seni bina pelayan pelanggan tanpa kewarganegaraan di mana pelayan memproses permintaan pelanggan dan menghantar semula respons, biasanya dalam format JSON atau XML. API REST digunakan secara meluas kerana kesederhanaan, skalabiliti dan keupayaan untuk memisahkan antara muka pengguna daripada pelayan, yang menjadikannya ideal untuk membina perkhidmatan web yang boleh diakses oleh pelbagai pelanggan, termasuk penyemak imbas web, mudah alih. peranti dan pelayan lain.

Apakah ASAP Auth? ?️

ASAP (Pengesahan untuk Perkhidmatan dan Projek) ialah mekanisme pengesahan berasaskan token yang dibangunkan oleh Atlassian. Ia direka khusus untuk komunikasi perkhidmatan ke perkhidmatan, di mana satu perkhidmatan perlu menghubungi yang lain dengan selamat. Daripada bergantung pada bukti kelayakan pengguna atau OAuth (yang lebih mengutamakan pengguna), ASAP menggunakan JWT (Token Web JSON) untuk memberikan akses sementara kepada perkhidmatan. Ini amat berguna dalam seni bina perkhidmatan mikro, di mana perkhidmatan perlu mengesahkan dan membenarkan permintaan dengan cekap tanpa overhed mengurus sesi atau bukti kelayakan pengguna.

Ciri Utama ASAP Auth:

• Berasaskan JWT: ASAP bergantung pada token JWT, yang padat, selamat URL dan boleh membawa tuntutan yang mewakili identiti dan kebenaran peminta.
• Tanpa status: Pelayan tidak perlu menyimpan sebarang maklumat sesi, kerana semua maklumat yang diperlukan dikodkan dalam JWT.
• Selamat: Token ASAP ditandatangani menggunakan kunci persendirian, memastikan hanya perkhidmatan yang dibenarkan boleh menjana token yang sah.
• *Boleh skala: * Sesuai untuk seni bina perkhidmatan mikro, di mana perkhidmatan berkomunikasi dengan kerap antara satu sama lain.

Bagaimana untuk Melaksanakan ASAP Auth dalam Python, Java, dan Go ?

Sekarang kita memahami asas ASAP Auth, mari lihat cara anda boleh melaksanakannya dalam pelbagai bahasa pengaturcaraan.

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

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

Perlaksanaan Go

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

Bagaimana untuk Menguji Auth ASAP Menggunakan Alat?

Menguji pengesahan ASAP memerlukan alat yang boleh menghantar permintaan HTTP dengan pengepala tersuai. Begini cara anda boleh melakukannya menggunakan EchoAPI dan cURL.

Menguji dengan EchoAPI?

Pilih Kaedah API dan URL:
Pilih kaedah HTTP yang betul (cth., POST, GET) dan masukkan URL titik akhir API.

Navigasi ke Tab 'Auth':
Klik pada tab Pengesahan dalam panel permintaan.

Pilih ASAP (Atlassian) Pengesahan:
Daripada menu lungsur Jenis, pilih ASAP (Atlassian).

Konfigurasikan Algoritma dan Medan:

• Algoritma: Pilih algoritma tandatangan (cth., HS256).
• Pengeluar: Masukkan identiti yang menjana token.
• Khalayak: Sediakan penerima token yang dimaksudkan.
• ID Kunci: Masukkan pengecam untuk kunci tandatangan.
• Kunci Peribadi: Masukkan kunci tandatangan.

Simpan dan Hantar:
Klik Simpan, kemudian Hantar untuk melaksanakan permintaan dengan pengesahan ASAP

Menguji dengan cURL

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

Arahan ini menghantar token ASAP sebagai sebahagian daripada pengepala HTTP dan anda boleh memeriksa respons terus dalam terminal.

Kesimpulan ?

ASAP Auth menyediakan cara yang teguh, berskala dan selamat untuk mengendalikan pengesahan dalam komunikasi perkhidmatan ke perkhidmatan, terutamanya dalam seni bina perkhidmatan mikro. Dengan memanfaatkan JWT, ASAP mendayakan pengesahan berasaskan token tanpa kewarganegaraan, yang penting untuk mengekalkan keselamatan dan prestasi yang tinggi. Sama ada anda menggunakan Python, Java atau Go, melaksanakan ASAP Auth adalah mudah dan disepadukan dengan baik ke dalam aliran kerja sedia ada.

Selain itu, menguji kaedah pengesahan ini menggunakan alatan seperti EchoAPI atau cURL memastikan pelaksanaan anda selamat dan berfungsi dengan betul. Sambil anda terus membina dan menjamin REST API anda, pertimbangkan untuk menggunakan ASAP Auth untuk meningkatkan keselamatan dan kecekapan merentas perkhidmatan anda.

Atas ialah kandungan terperinci Mengapa ASAP (Atlassian) Auth ialah Pilihan Pantas & Selamat untuk Pengesahan API REST?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!