Como desarrollador senior que trabaja extensamente con API, la seguridad y la eficiencia son siempre las principales prioridades. Cuando se trata de proteger las API REST, existen numerosos métodos de autenticación disponibles, pero no todos son iguales.

La autenticación ASAP (Autenticación para servicios y proyectos) de Atlassian se destaca como una opción robusta, escalable y segura, particularmente cuando se trata de microservicios o API que requieren mecanismos de autenticación sólidos. Pero antes de profundizar en por qué ASAP es una excelente opción, echemos un vistazo rápido a qué son las API REST y por qué son importantes.

¿Qué son las API REST? ?

REST (Transferencia de estado representacional) son un conjunto de reglas que permiten la creación de servicios web que son livianos, mantenibles y escalables. Siguen una arquitectura cliente-servidor sin estado donde el servidor procesa la solicitud del cliente y envía una respuesta, generalmente en formato JSON o XML. Las API REST se utilizan ampliamente debido a su simplicidad, escalabilidad y capacidad de separar la interfaz de usuario del servidor, lo que las hace ideales para crear servicios web a los que puedan acceder varios clientes, incluidos navegadores web, dispositivos móviles. dispositivos y otros servidores.

¿Qué es la autenticación ASAP? ?️

ASAP (Autenticación para Servicios y Proyectos) es un mecanismo de autenticación basado en tokens desarrollado por Atlassian. Está diseñado específicamente para la comunicación de servicio a servicio, donde un servicio necesita llamar a otro de forma segura. En lugar de depender de las credenciales del usuario o de OAuth (que está más centrado en el usuario), ASAP utiliza JWT (JSON Web Tokens) para otorgar acceso temporal a los servicios. Esto es particularmente útil en arquitecturas de microservicios, donde los servicios necesitan autenticar y autorizar solicitudes de manera eficiente sin la sobrecarga de administrar sesiones o credenciales de usuarios.

Características clave de la autenticación ASAP:

• Basado en JWT: ASAP se basa en tokens JWT, que son compactos, seguros para URL y pueden contener afirmaciones que representan la identidad y los permisos del solicitante.
• Sin estado: El servidor no necesita almacenar ninguna información de la sesión, ya que toda la información necesaria está codificada en el JWT.
• Seguro: Los tokens ASAP se firman utilizando una clave privada, lo que garantiza que solo los servicios autorizados puedan generar tokens válidos.
• *Escalable: * Ideal para arquitecturas de microservicios, donde los servicios se comunican frecuentemente entre sí.

¿Cómo implementar la autenticación ASAP en Python, Java y Go?

Ahora que entendemos los conceptos básicos de ASAP Auth, veamos cómo implementarlo en varios lenguajes de programación.

Implementación de 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}")

Implementación de 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());
        }
    }
}

Ir Implementación

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

¿Cómo probar la autenticación ASAP utilizando herramientas?

Para probar la autenticación ASAP se requieren herramientas que puedan enviar solicitudes HTTP con encabezados personalizados. Así es como puedes hacerlo usando EchoAPI y cURL.

¿Probando con EchoAPI?

Seleccione el método API y la URL:
Elija el método HTTP correcto (por ejemplo, POST, GET) e ingrese la URL del punto final de la API.

Vaya a la pestaña 'Auth':
Haga clic en la pestaña Autenticación en el panel de solicitud.

Elija autenticación lo antes posible (Atlassian):
En el menú desplegable Tipo, seleccione Lo antes posible (Atlassian).

Configurar algoritmo y campos:

• Algoritmo: Elija el algoritmo de firma (por ejemplo, HS256).
• Emisor: Ingrese la identidad que genera el token.
• Audiencia: Proporcione los destinatarios previstos del token.
• ID de clave: Ingrese el identificador de la clave de firma.
• Clave privada: Ingrese la clave de firma.

Guardar y enviar:
Haga clic en Guardar y luego en Enviar para ejecutar la solicitud con autenticación ASAP

Prueba con cURL

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

Este comando envía el token ASAP como parte del encabezado HTTP y puedes inspeccionar la respuesta directamente en la terminal.

Conclusión ?

ASAP Auth proporciona una forma sólida, escalable y segura de manejar la autenticación en las comunicaciones entre servicios, especialmente dentro de arquitecturas de microservicios. Al aprovechar JWT, ASAP permite la autenticación sin estado basada en tokens, lo cual es crucial para mantener un alto nivel de seguridad y rendimiento. Ya sea que esté trabajando en Python, Java o Go, implementar ASAP Auth es sencillo y se integra bien en los flujos de trabajo existentes.

Además, probar este método de autenticación utilizando herramientas como EchoAPI o cURL garantiza que su implementación sea segura y funcione correctamente. A medida que continúas creando y protegiendo tus API REST, considera usar ASAP Auth para mejorar la seguridad y la eficiencia en todos tus servicios.