Что быстрее JWT или STS?

JWT vs STS: Производительность и вариант использования

Краткий ответ

JWT быстрее в большинстве случаев, но это не простое сравнение — нужно понимать, что мы сравниваем. JWT и STS (AWS Security Token Service) решают разные проблемы.

Что такое JWT

JWT (JSON Web Token) — это токен, который содержит информацию прямо в себе:

import jwt
from datetime import datetime, timedelta

# Создание JWT
payload = {
    "user_id": 123,
    "email": "user@example.com",
    "exp": datetime.utcnow() + timedelta(hours=1)
}

token = jwt.encode(payload, "secret_key", algorithm="HS256")
print(token)
# eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ1c2VyX2lkIjogMTIzfQ...

# Проверка JWT
try:
    decoded = jwt.decode(token, "secret_key", algorithms=["HS256"])
    print(decoded)  # {"user_id": 123, "email": "user@example.com", ...}
except jwt.ExpiredSignatureError:
    print("Token expired")

Характеристики JWT:

• Stateless — сервер не хранит информацию о токене
• Self-contained — данные внутри самого токена
• Проверка локальная — не нужен запрос в БД

Что такое STS (AWS)

STS (Security Token Service) — AWS сервис для выдачи временных credentials:

import boto3

client = boto3.client('sts')

# Запрос временного токена
response = client.assume_role(
    RoleArn='arn:aws:iam::123456789012:role/MyRole',
    RoleSessionName='MySession',
    DurationSeconds=3600  # 1 час
)

# Получаём временные credentials
temp_credentials = response['Credentials']
print(temp_credentials)
# {
#     'AccessKeyId': 'AKIA...',
#     'SecretAccessKey': '...',
#     'SessionToken': '...',
#     'Expiration': datetime(...)
# }

Характеристики STS:

• Stateful — AWS хранит информацию о сессии
• Вызывает внешний сервис — нужен запрос к AWS
• Предназначена для AWS — управление доступом к AWS ресурсам

Сравнение производительности

1. Время проверки токена

import time
import jwt
import requests

# JWT проверка (локально)
def verify_jwt(token):
    start = time.time()
    try:
        payload = jwt.decode(token, "secret_key", algorithms=["HS256"])
        return time.time() - start
    except:
        return None

# STS проверка (удалённый запрос)
def verify_sts(token):
    start = time.time()
    response = requests.get(
        'https://sts.amazonaws.com/',
        params={'Token': token}
    )
    return time.time() - start

jwt_time = verify_jwt(token)  # ~1-5 мс (очень быстро)
sts_time = verify_sts(token)  # ~100-500 мс (медленнее)

print(f"JWT: {jwt_time}ms")
print(f"STS: {sts_time}ms")
print(f"JWT в {sts_time/jwt_time:.0f}x быстрее")

Результаты:

• JWT: 1-5 мс (локальное шифрование)
• STS: 100-500 мс (сетевой запрос + AWS обработка)
• JWT быстрее в 50-200 раз

2. Пропускная способность (throughput)

# JWT: может обработать миллионы проверок в секунду
# Ограничение только CPU локальной машины

jwt_requests_per_second = 1_000_000  # ~1М на одном сервере

# STS: ограничена квотами AWS и сетевой задержкой
# По умолчанию ~100 requests per second
# Можно увеличить, но дороже

sts_requests_per_second = 100  # начальная квота

Когда использовать JWT

# Подходит для:
use_jwt_when = {
    "микросервисная архитектура": "Каждый сервис проверяет локально",
    "высокая нагрузка": "Не нужны удалённые запросы",
    "распределённые системы": "Stateless, легко масштабировать",
    "мобильные приложения": "Быстро, не зависит от соединения",
    "low latency требования": "Критически важна скорость",
}

# Пример: API Gateway
from fastapi import FastAPI, HTTPException, Depends
from fastapi.security import HTTPBearer, HTTPAuthCredentials

app = FastAPI()
security = HTTPBearer()

async def verify_token(credentials: HTTPAuthCredentials = Depends(security)):
    try:
        payload = jwt.decode(
            credentials.credentials,
            "secret_key",
            algorithms=["HS256"]
        )
        return payload
    except jwt.InvalidTokenError:
        raise HTTPException(status_code=401, detail="Invalid token")

@app.get("/api/users")
async def get_users(token = Depends(verify_token)):
    return {"user_id": token['user_id']}

# Быстро: проверка за 1-5 мс

Когда использовать STS

# Подходит для:
use_sts_when = {
    "AWS экосистема": "Управление доступом к S3, DynamoDB и т.д.",
    "временные credentials": "Нужны auto-rotating credentials",
    "fine-grained access control": "STS умеет в IAM политики",
    "audit и compliance": "Вся история в CloudTrail",
    "сложные permission rules": "IAM политики мощнее чем JWT claims",
}

# Пример: временный доступ к S3
import boto3

sts = boto3.client('sts')

# Выдаём пользователю временный доступ к S3 бакету
response = sts.assume_role(
    RoleArn='arn:aws:iam::123456789012:role/S3AccessRole',
    RoleSessionName=f'user-{user_id}',
    DurationSeconds=3600,
    Policy=json.dumps({
        "Version": "2012-10-17",
        "Statement": [{
            "Effect": "Allow",
            "Action": "s3:GetObject",
            "Resource": f"arn:aws:s3:::my-bucket/{user_id}/*"
        }]
    })
)

# Пользователь получает временные ключи для S3
temp_credentials = response['Credentials']
s3_client = boto3.client(
    's3',
    aws_access_key_id=temp_credentials['AccessKeyId'],
    aws_secret_access_key=temp_credentials['SecretAccessKey'],
    aws_session_token=temp_credentials['SessionToken']
)

# Может скачать файл из S3, но ТОЛЬКО из своей папки
file = s3_client.get_object(Bucket='my-bucket', Key=f'{user_id}/file.txt')

Таблица сравнения

Практический совет

# Гибридный подход: лучшее из двух

# 1. Используй JWT для основной аутентификации
jwt_token = create_jwt(user_id, 3600)  # Быстро

# 2. Для доступа к AWS, обменивай JWT на STS токен
sts_token = sts.assume_role(
    RoleArn=...,
    RoleSessionName=user_id
)  # Один раз при необходимости

# Так получаешь:
# - Скорость JWT для основных запросов
# - Безопасность STS для AWS ресурсов
# - Гибкость управления доступом

Вывод: JWT значительно быстрее благодаря локальной проверке. Используй JWT для аутентификации и быстрого доступа к API. Используй STS, если нужно управлять доступом к AWS ресурсам или требуется мгновенная revocation.