Como desenvolvedor sênior que trabalha extensivamente com APIs, segurança e eficiência são sempre as principais prioridades. Quando se trata de proteger APIs REST, existem vários métodos de autenticação disponíveis, mas nem todos são criados iguais.

O

ASAP (Autenticação para Serviços e Projetos) Auth da Atlassian se destaca como uma opção robusta, escalonável e segura, principalmente ao lidar com microsserviços ou APIs que exigem mecanismos de autenticação fortes. Mas antes de nos aprofundarmos no porquê do ASAP ser uma ótima escolha, vamos dar uma olhada rápida no que são APIs REST e por que elas são importantes.

O que são APIs REST? ?

APIs

REST (Representational State Transfer) são um conjunto de regras que permitem a criação de serviços da web que são leves, fáceis de manter e escalonáveis. Eles seguem uma arquitetura cliente-servidor sem estado, onde o servidor processa a solicitação do cliente e envia de volta uma resposta, geralmente em formato JSON ou XML. APIs REST são amplamente utilizadas devido à sua simplicidade, escalabilidade e capacidade de separar a interface do usuário do servidor, o que as torna ideais para construir serviços web que podem ser acessados ​​por vários clientes, incluindo navegadores web, dispositivos móveis dispositivos e outros servidores.

O que é autenticação ASAP? ?️

ASAP (Autenticação para Serviços e Projetos) é um mecanismo de autenticação baseado em token desenvolvido pela Atlassian. Ele foi projetado especificamente para comunicação entre serviços, onde um serviço precisa ligar para outro com segurança. Em vez de confiar nas credenciais do usuário ou no OAuth (que é mais centrado no usuário), o ASAP usa JWT (JSON Web Tokens) para conceder acesso temporário aos serviços. Isto é particularmente útil em arquiteturas de microsserviços, onde os serviços precisam autenticar e autorizar solicitações de forma eficiente, sem a sobrecarga de gerenciamento de sessões ou credenciais de usuários.

Principais recursos do ASAP Auth:

• Baseado em JWT: ASAP depende de tokens JWT, que são compactos, seguros para URL e podem conter declarações que representam a identidade e as permissões do solicitante.
• Stateless: O servidor não precisa armazenar nenhuma informação de sessão, pois todas as informações necessárias estão codificadas no JWT.
• Seguro: Os tokens ASAP são assinados usando uma chave privada, garantindo que apenas serviços autorizados possam gerar tokens válidos.
*
• Escalável: * Ideal para arquiteturas de microsserviços, onde os serviços se comunicam frequentemente entre si.

Como implementar autenticação ASAP em Python, Java e Go?

Agora que entendemos os fundamentos do ASAP Auth, vamos ver como você pode implementá-lo em várias linguagens de programação.

Implementação Python

importar jwt solicitações de importação de data e hora importar data e hora, timedelta importar sistema operacional # Definir função de criação de token ASAP def create_asap_token(emissor, público, private_key): hora_atual = datetime.utcnow() carga útil = { 'iss': emissor, 'aud': público, 'iat': horário_atual, 'exp': tempo_atual timedelta(minutos=5), } token = jwt.encode(carga útil, chave_privada, algoritmo='RS256') token de retorno # Carrega a chave privada da variável de ambiente ou arquivo chave_privada = os.getenv('PRIVATE_KEY') se não for private_key: com open('path_to_private_key.pem', 'r') como key_file: chave_privada = arquivo_chave.read() emissor = 'seu serviço' público = 'serviço-alvo' token = create_asap_token(emissor, público, chave_privada) if isinstance(token, bytes): token = token.decode('utf-8') cabeçalhos = { 'Autorização': f'Bearer {token}' } tentar: resposta = solicitações.get('https://api.target-service.com/data', headers=headers) response.raise_for_status() # Gera HTTPError para respostas ruins imprimir(response.json()) exceto requests.exceptions.RequestException como e: print(f"Falha na solicitação: {e}")

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

Implementação Java

importar com.auth0.jwt.JWT; importar com.auth0.jwt.algorithms.Algorithm; importar java.nio.file.Files; importar java.nio.file.Paths; importar java.security.KeyFactory; importar java.security.PrivateKey; importar java.security.spec.PKCS8EncodedKeySpec; importar java.time.Instant; importar java.util.Date; classe pública ASAPAuthExample { public static PrivateKey loadPrivateKey(String nome do arquivo) lança exceção { Chave de string = new String(Files.readAllBytes(Paths.get(nome do arquivo))) .replace("-----INÍCIO DA CHAVE PRIVADA-----", "") .replace("-----FIM CHAVE PRIVADA-----", "") .replaceAll("\\s", ""); byte[] keyBytes = java.util.Base64.getDecoder().decode(chave); Especificação PKCS8EncodedKeySpec = novo PKCS8EncodedKeySpec(keyBytes); KeyFactory kf = KeyFactory.getInstance("RSA"); retornar kf.generatePrivate(especificação); } public static String createASAPToken(String emissor, String público, PrivateKey privateKey) { Algoritmo algoritmo = Algorithm.RSA256(null, privateKey); Instantâneo agora = Instant.now(); retornar JWT.create() .withIssuer(emissor) .withAudience(público) .withIssuedAt(Data.de(agora)) .withExpiresAt(Date.from(now.plusSeconds(300))) // expiração de 5 minutos .sinal(algoritmo); } public static void main(String[] args) { tentar { String emissor = "seu serviço"; String público = "serviço-alvo"; PrivateKey privateKey = loadPrivateKey("path_to_private_key.pem"); String token = createASAPToken(emissor, público, privateKey); // Use o token para fazer uma solicitação de API segura (usando seu cliente HTTP preferido) System.out.println("Token Gerado: "token); } catch (Exceção e) { System.err.println("Erro ao criar token: "e.getMessage()); } } }

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

Implementação Go

pacote principal importar ( "fmt" "io/ioutil" "tempo" "github.com/golang-jwt/jwt" ) func loadPrivateKey(caminho string) (*rsa.PrivateKey, erro) { keyData, err := ioutil.ReadFile(caminho) se errar! = nulo { retornar nulo, errar } retornar jwt.ParseRSAPrivateKeyFromPEM(keyData) } func createASAPToken(emissor, público, string privateKeyPath) (string, erro) { privateKey, err := loadPrivateKey(privateKeyPath) se errar! = nulo { retornar "", errar } token := jwt.NewWithClaims(jwt.SigningMethodRS256, jwt.MapClaims{ "iss": emissor, "aud": público, "iat": time.Now().Unix(), "exp": time.Now().Add(5 * time.Minute).Unix(), }) tokenString, err := token.SignedString(privateKey) se errar! = nulo { retornar "", errar } retornar tokenString, nulo } função principal() { emissor := "seu serviço" público := "serviço-alvo" privateKeyPath := "caminho_para_chave_privada.pem" token, err := createASAPToken(emissor, público, privateKeyPath) se errar! = nulo { fmt.Println("Erro ao criar token:", err) retornar } // Use o token para fazer uma solicitação de API segura (usando seu cliente HTTP preferido) fmt.Println("Token Gerado:", token) }

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

Como testar a autenticação ASAP usando ferramentas?

O teste da autenticação ASAP requer ferramentas que possam enviar solicitações HTTP com cabeçalhos personalizados. Veja como você pode fazer isso usando EchoAPI e cURL.

Testando com EchoAPI?

Selecione o método API e o URL: Escolha o método HTTP correto (por exemplo, POST, GET) e insira o URL do endpoint da API.

Navegue até a guia 'Autenticação': Clique na guia Auth no painel de solicitação.

Escolha autenticação ASAP (Atlassian): No menu suspenso Tipo, selecione ASAP (Atlassian).

Configurar algoritmo e campos:

• Algoritmo: Escolha o algoritmo de assinatura (por exemplo, HS256).
• Emissor: Insira a identidade que gera o token.
• Público: Forneça os destinatários pretendidos do token.
• ID da chave: Insira o identificador da chave de assinatura.
• Chave privada: Insira a chave de assinatura.

Salvar e enviar: Clique em Salvar e em Enviar para executar a solicitação com autenticação ASAP

Testando com cURL

curl -X GET "https://api.target-service.com/data"\ -H "Autorização: Portador "

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

Este comando envia o token ASAP como parte do cabeçalho HTTP e você pode inspecionar a resposta diretamente no terminal.

Conclusão?

ASAP Auth fornece uma maneira robusta, escalonável e segura de lidar com autenticação em comunicações serviço a serviço, especialmente em arquiteturas de microsserviços. Ao aproveitar o JWT, o ASAP permite autenticação sem estado e baseada em token, o que é crucial para manter alta segurança e desempenho. Esteja você trabalhando em Python, Java ou Go, implementar o ASAP Auth é simples e se integra bem aos fluxos de trabalho existentes.

Além disso, testar esse método de autenticação usando ferramentas como EchoAPI ou cURL garante que sua implementação seja segura e funcione corretamente. À medida que você continua a criar e proteger suas APIs REST, considere usar o ASAP Auth para aumentar a segurança e a eficiência em seus serviços.