547 lines
18 KiB
Markdown
547 lines
18 KiB
Markdown
# 🔍 Аутентификация для микросервисов
|
||
|
||
## 🎯 Обзор
|
||
|
||
Руководство по интеграции системы аутентификации Discours Core с другими микросервисами через общий Redis connection pool.
|
||
|
||
## 🚀 Быстрый старт
|
||
|
||
### Подключение к Redis
|
||
|
||
```python
|
||
# Используйте тот же Redis connection pool
|
||
from storage.redis import redis
|
||
|
||
# Или создайте свой с теми же настройками
|
||
import aioredis
|
||
|
||
redis_client = aioredis.from_url(
|
||
"redis://localhost:6379/0",
|
||
max_connections=20,
|
||
retry_on_timeout=True,
|
||
socket_keepalive=True,
|
||
socket_keepalive_options={},
|
||
health_check_interval=30
|
||
)
|
||
```
|
||
|
||
### Проверка токена сессии
|
||
|
||
```python
|
||
from auth.tokens.sessions import SessionTokenManager
|
||
from auth.utils import extract_token_from_request
|
||
|
||
async def check_user_session(request) -> dict | None:
|
||
"""Проверка сессии пользователя в микросервисе"""
|
||
|
||
# 1. Извлекаем токен из запроса
|
||
token = await extract_token_from_request(request)
|
||
if not token:
|
||
return None
|
||
|
||
# 2. Проверяем сессию через SessionTokenManager
|
||
sessions = SessionTokenManager()
|
||
payload = await sessions.verify_session(token)
|
||
|
||
if payload:
|
||
return {
|
||
"authenticated": True,
|
||
"user_id": payload.get("user_id"),
|
||
"username": payload.get("username"),
|
||
"expires_at": payload.get("exp")
|
||
}
|
||
|
||
return {"authenticated": False, "error": "Invalid token"}
|
||
```
|
||
|
||
## 🔑 Redis ключи для поиска
|
||
|
||
### Структура данных
|
||
|
||
```bash
|
||
# Сессии пользователей
|
||
session:{user_id}:{token} # Hash: {user_id, username, device_info, last_activity}
|
||
user_sessions:{user_id} # Set: {token1, token2, ...}
|
||
|
||
# OAuth токены
|
||
oauth_access:{user_id}:{provider} # JSON: {token, expires_in, scope}
|
||
oauth_refresh:{user_id}:{provider} # JSON: {token, provider_data}
|
||
|
||
# Токены подтверждения
|
||
verification_token:{token} # JSON: {user_id, type, data, created_at}
|
||
|
||
# OAuth состояние
|
||
oauth_state:{state} # JSON: {provider, redirect_uri, code_verifier}
|
||
```
|
||
|
||
### Примеры поиска
|
||
|
||
```python
|
||
from storage.redis import redis
|
||
|
||
# 1. Поиск всех сессий пользователя
|
||
async def get_user_sessions(user_id: int) -> list[str]:
|
||
"""Получить все активные токены пользователя"""
|
||
session_key = f"user_sessions:{user_id}"
|
||
tokens = await redis.smembers(session_key)
|
||
return [token.decode() for token in tokens] if tokens else []
|
||
|
||
# 2. Получение данных конкретной сессии
|
||
async def get_session_data(user_id: int, token: str) -> dict | None:
|
||
"""Получить данные сессии"""
|
||
session_key = f"session:{user_id}:{token}"
|
||
data = await redis.hgetall(session_key)
|
||
|
||
if data:
|
||
return {k.decode(): v.decode() for k, v in data.items()}
|
||
return None
|
||
|
||
# 3. Проверка существования токена
|
||
async def token_exists(user_id: int, token: str) -> bool:
|
||
"""Проверить существование токена"""
|
||
session_key = f"session:{user_id}:{token}"
|
||
return await redis.exists(session_key)
|
||
|
||
# 4. Получение TTL токена
|
||
async def get_token_ttl(user_id: int, token: str) -> int:
|
||
"""Получить время жизни токена в секундах"""
|
||
session_key = f"session:{user_id}:{token}"
|
||
return await redis.ttl(session_key)
|
||
```
|
||
|
||
## 🛠️ Методы интеграции
|
||
|
||
### 1. Прямая проверка токена
|
||
|
||
```python
|
||
from auth.tokens.sessions import SessionTokenManager
|
||
|
||
async def authenticate_request(request) -> dict:
|
||
"""Аутентификация запроса в микросервисе"""
|
||
|
||
sessions = SessionTokenManager()
|
||
|
||
# Извлекаем токен
|
||
token = await extract_token_from_request(request)
|
||
if not token:
|
||
return {"authenticated": False, "error": "No token provided"}
|
||
|
||
try:
|
||
# Проверяем JWT и Redis сессию
|
||
payload = await sessions.verify_session(token)
|
||
|
||
if payload:
|
||
user_id = payload.get("user_id")
|
||
|
||
# Дополнительно получаем данные сессии из Redis
|
||
session_data = await sessions.get_session_data(token, user_id)
|
||
|
||
return {
|
||
"authenticated": True,
|
||
"user_id": user_id,
|
||
"username": payload.get("username"),
|
||
"session_data": session_data,
|
||
"expires_at": payload.get("exp")
|
||
}
|
||
else:
|
||
return {"authenticated": False, "error": "Invalid or expired token"}
|
||
|
||
except Exception as e:
|
||
return {"authenticated": False, "error": f"Authentication error: {str(e)}"}
|
||
```
|
||
|
||
### 2. Массовая проверка токенов
|
||
|
||
```python
|
||
from auth.tokens.batch import BatchTokenOperations
|
||
|
||
async def validate_multiple_tokens(tokens: list[str]) -> dict[str, bool]:
|
||
"""Массовая проверка токенов для API gateway"""
|
||
|
||
batch = BatchTokenOperations()
|
||
return await batch.batch_validate_tokens(tokens)
|
||
|
||
# Использование
|
||
async def api_gateway_auth(request_tokens: list[str]):
|
||
"""Пример использования в API Gateway"""
|
||
|
||
results = await validate_multiple_tokens(request_tokens)
|
||
|
||
authenticated_requests = []
|
||
for token, is_valid in results.items():
|
||
if is_valid:
|
||
# Получаем данные пользователя для валидных токенов
|
||
sessions = SessionTokenManager()
|
||
payload = await sessions.verify_session(token)
|
||
if payload:
|
||
authenticated_requests.append({
|
||
"token": token,
|
||
"user_id": payload.get("user_id"),
|
||
"username": payload.get("username")
|
||
})
|
||
|
||
return authenticated_requests
|
||
```
|
||
|
||
### 3. Получение данных пользователя
|
||
|
||
```python
|
||
from auth.utils import get_user_data_by_token
|
||
|
||
async def get_user_info(token: str) -> dict | None:
|
||
"""Получить информацию о пользователе по токену"""
|
||
|
||
try:
|
||
user_data = await get_user_data_by_token(token)
|
||
return user_data
|
||
except Exception as e:
|
||
print(f"Ошибка получения данных пользователя: {e}")
|
||
return None
|
||
|
||
# Использование
|
||
async def protected_endpoint(request):
|
||
"""Пример защищенного endpoint в микросервисе"""
|
||
|
||
token = await extract_token_from_request(request)
|
||
user_info = await get_user_info(token)
|
||
|
||
if not user_info:
|
||
return {"error": "Unauthorized", "status": 401}
|
||
|
||
return {
|
||
"message": f"Hello, {user_info.get('username')}!",
|
||
"user_id": user_info.get("user_id"),
|
||
"status": 200
|
||
}
|
||
```
|
||
|
||
## 🔧 HTTP заголовки и извлечение токенов
|
||
|
||
### Поддерживаемые форматы
|
||
|
||
```python
|
||
from auth.utils import extract_token_from_request, get_safe_headers
|
||
|
||
async def extract_auth_token(request) -> str | None:
|
||
"""Извлечение токена из различных источников"""
|
||
|
||
# 1. Автоматическое извлечение (рекомендуется)
|
||
token = await extract_token_from_request(request)
|
||
if token:
|
||
return token
|
||
|
||
# 2. Ручное извлечение из заголовков
|
||
headers = get_safe_headers(request)
|
||
|
||
# Bearer токен в Authorization
|
||
auth_header = headers.get("authorization", "")
|
||
if auth_header.startswith("Bearer "):
|
||
return auth_header[7:].strip()
|
||
|
||
# Кастомный заголовок X-Session-Token
|
||
session_token = headers.get("x-session-token")
|
||
if session_token:
|
||
return session_token.strip()
|
||
|
||
# Cookie (для веб-приложений)
|
||
if hasattr(request, "cookies"):
|
||
cookie_token = request.cookies.get("session_token")
|
||
if cookie_token:
|
||
return cookie_token
|
||
|
||
return None
|
||
```
|
||
|
||
### Примеры HTTP запросов
|
||
|
||
```bash
|
||
# 1. Bearer токен в Authorization header
|
||
curl -H "Authorization: Bearer your_jwt_token_here" \
|
||
http://localhost:8000/api/protected
|
||
|
||
# 2. Кастомный заголовок
|
||
curl -H "X-Session-Token: your_jwt_token_here" \
|
||
http://localhost:8000/api/protected
|
||
|
||
# 3. Cookie (автоматически для веб-приложений)
|
||
curl -b "session_token=your_jwt_token_here" \
|
||
http://localhost:8000/api/protected
|
||
```
|
||
|
||
## 📊 Мониторинг и статистика
|
||
|
||
### Health Check
|
||
|
||
```python
|
||
from auth.tokens.monitoring import TokenMonitoring
|
||
|
||
async def auth_health_check() -> dict:
|
||
"""Health check системы аутентификации"""
|
||
|
||
monitoring = TokenMonitoring()
|
||
|
||
try:
|
||
# Проверяем состояние системы токенов
|
||
health = await monitoring.health_check()
|
||
|
||
# Получаем статистику
|
||
stats = await monitoring.get_token_statistics()
|
||
|
||
return {
|
||
"status": health.get("status", "unknown"),
|
||
"redis_connected": health.get("redis_connected", False),
|
||
"active_sessions": stats.get("session_tokens", 0),
|
||
"oauth_tokens": stats.get("oauth_access_tokens", 0) + stats.get("oauth_refresh_tokens", 0),
|
||
"memory_usage_mb": stats.get("memory_usage", 0) / 1024 / 1024,
|
||
"timestamp": int(time.time())
|
||
}
|
||
|
||
except Exception as e:
|
||
return {
|
||
"status": "error",
|
||
"error": str(e),
|
||
"timestamp": int(time.time())
|
||
}
|
||
|
||
# Использование в endpoint
|
||
async def health_endpoint():
|
||
"""Endpoint для мониторинга"""
|
||
health_data = await auth_health_check()
|
||
|
||
if health_data["status"] == "healthy":
|
||
return {"health": health_data, "status": 200}
|
||
else:
|
||
return {"health": health_data, "status": 503}
|
||
```
|
||
|
||
### Статистика использования
|
||
|
||
```python
|
||
async def get_auth_statistics() -> dict:
|
||
"""Получить статистику использования аутентификации"""
|
||
|
||
monitoring = TokenMonitoring()
|
||
stats = await monitoring.get_token_statistics()
|
||
|
||
return {
|
||
"sessions": {
|
||
"active": stats.get("session_tokens", 0),
|
||
"total_memory": stats.get("memory_usage", 0)
|
||
},
|
||
"oauth": {
|
||
"access_tokens": stats.get("oauth_access_tokens", 0),
|
||
"refresh_tokens": stats.get("oauth_refresh_tokens", 0)
|
||
},
|
||
"verification": {
|
||
"pending": stats.get("verification_tokens", 0)
|
||
},
|
||
"redis": {
|
||
"connected": stats.get("redis_connected", False),
|
||
"memory_usage_mb": stats.get("memory_usage", 0) / 1024 / 1024
|
||
}
|
||
}
|
||
```
|
||
|
||
## 🔒 Безопасность для микросервисов
|
||
|
||
### Валидация токенов
|
||
|
||
```python
|
||
async def secure_token_validation(token: str) -> dict:
|
||
"""Безопасная валидация токена с дополнительными проверками"""
|
||
|
||
if not token or len(token) < 10:
|
||
return {"valid": False, "error": "Invalid token format"}
|
||
|
||
try:
|
||
sessions = SessionTokenManager()
|
||
|
||
# 1. Проверяем JWT структуру и подпись
|
||
payload = await sessions.verify_session(token)
|
||
if not payload:
|
||
return {"valid": False, "error": "Invalid JWT token"}
|
||
|
||
user_id = payload.get("user_id")
|
||
if not user_id:
|
||
return {"valid": False, "error": "Missing user_id in token"}
|
||
|
||
# 2. Проверяем существование сессии в Redis
|
||
session_exists = await redis.exists(f"session:{user_id}:{token}")
|
||
if not session_exists:
|
||
return {"valid": False, "error": "Session not found in Redis"}
|
||
|
||
# 3. Проверяем TTL
|
||
ttl = await redis.ttl(f"session:{user_id}:{token}")
|
||
if ttl <= 0:
|
||
return {"valid": False, "error": "Session expired"}
|
||
|
||
# 4. Обновляем last_activity
|
||
await redis.hset(f"session:{user_id}:{token}", "last_activity", int(time.time()))
|
||
|
||
return {
|
||
"valid": True,
|
||
"user_id": user_id,
|
||
"username": payload.get("username"),
|
||
"expires_in": ttl,
|
||
"last_activity": int(time.time())
|
||
}
|
||
|
||
except Exception as e:
|
||
return {"valid": False, "error": f"Validation error: {str(e)}"}
|
||
```
|
||
|
||
### Rate Limiting
|
||
|
||
```python
|
||
from collections import defaultdict
|
||
import time
|
||
|
||
# Простой in-memory rate limiter (для production используйте Redis)
|
||
request_counts = defaultdict(list)
|
||
|
||
async def rate_limit_check(user_id: str, max_requests: int = 100, window_seconds: int = 60) -> bool:
|
||
"""Проверка rate limiting для пользователя"""
|
||
|
||
current_time = time.time()
|
||
user_requests = request_counts[user_id]
|
||
|
||
# Удаляем старые запросы
|
||
user_requests[:] = [req_time for req_time in user_requests if current_time - req_time < window_seconds]
|
||
|
||
# Проверяем лимит
|
||
if len(user_requests) >= max_requests:
|
||
return False
|
||
|
||
# Добавляем текущий запрос
|
||
user_requests.append(current_time)
|
||
return True
|
||
|
||
# Использование в middleware
|
||
async def auth_with_rate_limiting(request):
|
||
"""Аутентификация с rate limiting"""
|
||
|
||
auth_result = await authenticate_request(request)
|
||
|
||
if auth_result["authenticated"]:
|
||
user_id = str(auth_result["user_id"])
|
||
|
||
if not await rate_limit_check(user_id):
|
||
return {"error": "Rate limit exceeded", "status": 429}
|
||
|
||
return auth_result
|
||
```
|
||
|
||
## 🧪 Тестирование интеграции
|
||
|
||
### Unit тесты
|
||
|
||
```python
|
||
import pytest
|
||
from unittest.mock import AsyncMock, patch
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_microservice_auth():
|
||
"""Тест аутентификации в микросервисе"""
|
||
|
||
# Mock request с токеном
|
||
mock_request = AsyncMock()
|
||
mock_request.headers = {"authorization": "Bearer valid_token"}
|
||
|
||
# Mock SessionTokenManager
|
||
with patch('auth.tokens.sessions.SessionTokenManager') as mock_sessions:
|
||
mock_sessions.return_value.verify_session.return_value = {
|
||
"user_id": "123",
|
||
"username": "testuser",
|
||
"exp": int(time.time()) + 3600
|
||
}
|
||
|
||
result = await authenticate_request(mock_request)
|
||
|
||
assert result["authenticated"] is True
|
||
assert result["user_id"] == "123"
|
||
assert result["username"] == "testuser"
|
||
|
||
@pytest.mark.asyncio
|
||
async def test_batch_token_validation():
|
||
"""Тест массовой валидации токенов"""
|
||
|
||
tokens = ["token1", "token2", "token3"]
|
||
|
||
with patch('auth.tokens.batch.BatchTokenOperations') as mock_batch:
|
||
mock_batch.return_value.batch_validate_tokens.return_value = {
|
||
"token1": True,
|
||
"token2": False,
|
||
"token3": True
|
||
}
|
||
|
||
results = await validate_multiple_tokens(tokens)
|
||
|
||
assert results["token1"] is True
|
||
assert results["token2"] is False
|
||
assert results["token3"] is True
|
||
```
|
||
|
||
### Integration тесты
|
||
|
||
```python
|
||
@pytest.mark.asyncio
|
||
async def test_redis_integration():
|
||
"""Тест интеграции с Redis"""
|
||
|
||
from storage.redis import redis
|
||
|
||
# Тестируем подключение
|
||
ping_result = await redis.ping()
|
||
assert ping_result is True
|
||
|
||
# Тестируем операции с сессиями
|
||
test_key = "session:test:token123"
|
||
test_data = {"user_id": "123", "username": "testuser"}
|
||
|
||
# Сохраняем данные
|
||
await redis.hset(test_key, mapping=test_data)
|
||
await redis.expire(test_key, 3600)
|
||
|
||
# Проверяем данные
|
||
stored_data = await redis.hgetall(test_key)
|
||
assert stored_data[b"user_id"].decode() == "123"
|
||
assert stored_data[b"username"].decode() == "testuser"
|
||
|
||
# Проверяем TTL
|
||
ttl = await redis.ttl(test_key)
|
||
assert ttl > 0
|
||
|
||
# Очищаем
|
||
await redis.delete(test_key)
|
||
```
|
||
|
||
## 📋 Checklist для интеграции
|
||
|
||
### Подготовка
|
||
- [ ] Настроен Redis connection pool с теми же параметрами
|
||
- [ ] Установлены зависимости: `auth.tokens.*`, `auth.utils`
|
||
- [ ] Настроены environment variables (JWT_SECRET_KEY, REDIS_URL)
|
||
|
||
### Реализация
|
||
- [ ] Реализована функция извлечения токенов из запросов
|
||
- [ ] Добавлена проверка сессий через SessionTokenManager
|
||
- [ ] Настроена обработка ошибок аутентификации
|
||
- [ ] Добавлен health check endpoint
|
||
|
||
### Безопасность
|
||
- [ ] Валидация токенов включает проверку Redis сессий
|
||
- [ ] Настроен rate limiting (опционально)
|
||
- [ ] Логирование событий аутентификации
|
||
- [ ] Обработка истекших токенов
|
||
|
||
### Мониторинг
|
||
- [ ] Health check интегрирован в систему мониторинга
|
||
- [ ] Метрики аутентификации собираются
|
||
- [ ] Алерты настроены для проблем с Redis/JWT
|
||
|
||
### Тестирование
|
||
- [ ] Unit тесты для функций аутентификации
|
||
- [ ] Integration тесты с Redis
|
||
- [ ] E2E тесты с реальными токенами
|
||
- [ ] Load тесты для проверки производительности
|