作为一名广泛使用 API 的高级开发人员，安全性和效率始终是重中之重。在保护 REST API 方面，有多种身份验证方法可用，但并非所有方法都是相同的。

Atlassian 的 ASAP（服务和项目身份验证）Auth 作为一个强大、可扩展且安全的选项而脱颖而出，特别是在处理需要强大身份验证机制的微服务或 API 时。但在深入探讨为什么 ASAP 是一个不错的选择之前，让我们快速了解一下 REST API 是什么以及它们为何重要。

什么是 REST API？ ？

REST（表述性状态传输）API 是一组规则，允许创建轻量级、可维护和可扩展的 Web 服务。它们遵循无状态的客户端-服务器架构，其中服务器处理客户端的请求并发回响应，通常采用 JSON 或 XML 格式。 REST API 因其简单性、可扩展性以及将用户界面与服务器分离的能力而被广泛使用，这使得它们非常适合构建可由各种客户端访问的 Web 服务，包括 Web 浏览器、移动设备设备和其他服务器。

什么是 ASAP Auth？ ？️

ASAP（服务和项目身份验证）是 Atlassian 开发的基于令牌的身份验证机制。它专为服务到服务通信而设计，其中一个服务需要安全地调用另一个服务。 ASAP 不依赖用户凭据或 OAuth（更以用户为中心），而是使用 JWT（JSON Web 令牌）授予对服务的临时访问权限。这在微服务架构中特别有用，其中服务需要有效地对请求进行身份验证和授权，而无需管理用户会话或凭据的开销。

ASAP Auth 的主要特点：

• 基于 JWT： ASAP 依赖于 JWT 令牌，它是紧凑的、URL 安全的，并且可以携带代表请求者身份和权限的声明。
• 无状态： 服务器不需要存储任何会话信息，因为所有必要的信息都编码在 JWT 中。
• 安全： ASAP 令牌使用私钥进行签名，确保只有授权服务才能生成有效令牌。
• *可扩展：* 非常适合服务之间频繁通信的微服务架构。

如何在 Python、Java 和 Go 中实现 ASAP Auth？

现在我们了解了 ASAP Auth 的基础知识，让我们看看如何用各种编程语言实现它。

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

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

实施

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 Auth？

测试 ASAP 身份验证需要可以发送带有自定义标头的 HTTP 请求的工具。以下是使用 EchoAPI 和 cURL 的方法。

使用 EchoAPI 进行测试？

选择API方法和URL：
选择正确的 HTTP 方法（例如 POST、GET）并输入 API 端点 URL。

导航到“身份验证”选项卡：
单击请求面板中的“身份验证”选项卡。

尽快选择 (Atlassian) Auth:
从类型下拉列表中，选择 ASAP (Atlassian)。

配置算法和字段：

• 算法： 选择签名算法（例如 HS256）。
• 发行人：输入生成令牌的身份。
• 受众： 提供令牌的预期接收者。
• 密钥 ID： 输入签名密钥的标识符。
• 私钥： 输入签名密钥。

保存并发送：
单击“保存”，然后单击“发送”以使用 ASAP 身份验证执行请求

使用 cURL 进行测试

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

此命令将 ASAP 令牌作为 HTTP 标头的一部分发送，您可以直接在终端中检查响应。

结论 ？

ASAP Auth 提供了一种强大、可扩展且安全的方式来处理服务间通信中的身份验证，尤其是在微服务架构中。通过利用 JWT，ASAP 可以实现无状态、基于令牌的身份验证，这对于保持高安全性和性能至关重要。无论您使用 Python、Java 还是 Go，实施 ASAP Auth 都很简单，并且可以很好地集成到现有工作流程中。

此外，使用 EchoAPI 或 cURL 等工具测试此身份验证方法可确保您的实施安全且正常运行。当您继续构建和保护 REST API 时，请考虑使用 ASAP Auth 来增强整个服务的安全性和效率。