Шаблон API Gateway в микросервисной архитектуре

async function getUserProfilePage(userId) {
  const [
    userProfile,
    orderHistory,
    currentCart,
    recommendations,
    reviews
  ] = await Promise.all([
    userService.getUserProfile(userId),
    orderService.getUserOrders(userId),
    cartService.getUserCart(userId),
    recommendationService.getForUser(userId),
    reviewService.getUserReviews(userId)
  ]);
 
  return {
    userProfile,
    orderHistory,
    currentCart,
    recommendations,
    reviews
  };
}

// Пример обработки аутентификации в API Gateway
app.post('/auth/login', async (req, res) => {
  const { username, password } = req.body;
  
  try {
    // Проверка учетных данных через сервис аутентификации
    const authResult = await authService.verify(username, password);
    if (!authResult.success) {
      return res.status(401).json({ error: 'Неверные учетные данные' });
    }
    
    // Генерация JWT-токена с информацией о пользователе и его правах
    const token = jwt.sign({
      userId: authResult.user.id,
      roles: authResult.user.roles,
      permissions: authResult.user.permissions
    }, JWT_SECRET, { expiresIn: '1h' });
    
    res.json({ token });
  } catch (error) {
    res.status(500).json({ error: 'Ошибка аутентификации' });
  }
});

// Middleware для проверки прав доступа на основе ролей
function checkRole(requiredRoles) {
  return (req, res, next) => {
    const token = req.headers.authorization?.split(' ')[1];
    if (!token) {
      return res.status(401).json({ error: 'Требуется аутентификация' });
    }
    
    try {
      const decoded = jwt.verify(token, JWT_SECRET);
      const userRoles = decoded.roles || [];
      
      // Проверка наличия требуемой роли у пользователя
      if (!requiredRoles.some(role => userRoles.includes(role))) {
        return res.status(403).json({ error: 'Недостаточно прав' });
      }
      
      next();
    } catch (error) {
      res.status(401).json({ error: 'Неверный или просроченный токен' });
    }
  };
}
 
// Применение middleware к маршруту
app.get('/admin/users', checkRole(['admin']), (req, res) => {
  // Запрос будет обработан только если у пользователя есть роль 'admin'
  res.json({ users: [...] });
});

class CircuitBreaker {
  constructor(service, options = {}) {
    this.service = service;
    this.failureThreshold = options.failureThreshold || 5;
    this.resetTimeout = options.resetTimeout || 10000;
    this.state = 'CLOSED';
    this.failureCount = 0;
    this.lastFailureTime = null;
  }
 
  async call(request) {
    if (this.state === 'OPEN') {
      if (Date.now() - this.lastFailureTime > this.resetTimeout) {
        this.state = 'HALF-OPEN';
      } else {
        throw new Error('Circuit breaker is OPEN');
      }
    }
 
    try {
      const response = await this.service(request);
      this.success();
      return response;
    } catch (error) {
      this.failure();
      throw error;
    }
  }
 
  success() {
    this.failureCount = 0;
    this.state = 'CLOSED';
  }
 
  failure() {
    this.failureCount++;
    this.lastFailureTime = Date.now();
    
    if (this.state === 'HALF-OPEN' || this.failureCount >= this.failureThreshold) {
      this.state = 'OPEN';
    }
  }
}

function createCacheKey(req) {
  // Формируем уникальный ключ на основе URL, метода и параметров запроса
  return `${req.method}:${req.path}:${JSON.stringify(req.query)}`;
}
 
async function handleRequest(req, res) {
  const cacheKey = createCacheKey(req);
  
  // Проверяем, есть ли ответ в кэше
  const cachedResponse = await cache.get(cacheKey);
  if (cachedResponse) {
    return res.json(JSON.parse(cachedResponse));
  }
  
  // Если нет в кэше, делаем запрос к сервису
  const serviceResponse = await callService(req);
  
  // Сохраняем результат в кэш с указанным TTL (time-to-live)
  await cache.set(cacheKey, JSON.stringify(serviceResponse), 'EX', 300);
  
  return res.json(serviceResponse);
}

function shouldCache(req) {
  // Не кэшируем, если клиент запросил свежие данные
  if (req.headers['cache-control'] === 'no-cache') {
    return false;
  }
  
  // Кэшируем только для определенных клиентов
  if (!req.headers['x-api-key'] || !allowedClients.has(req.headers['x-api-key'])) {
    return false;
  }
  
  return true;
}

// Пример middleware для логирования запросов в Express
app.use((req, res, next) => {
  const start = Date.now();
  const requestId = uuidv4();
  
  // Добавляем ID запроса в заголовки для сквозной трассировки
  req.headers['x-request-id'] = requestId;
  
  // Логируем начало запроса
  logger.info({
    type: 'request',
    id: requestId,
    method: req.method,
    path: req.path,
    query: req.query,
    client: req.ip,
    userAgent: req.headers['user-agent']
  });
  
  // Перехватываем окончание запроса
  res.on('finish', () => {
    const duration = Date.now() - start;
    
    logger.info({
      type: 'response',
      id: requestId,
      status: res.statusCode,
      duration,
      size: res.getHeader('content-length')
    });
    
    // Отправляем метрику в систему мониторинга
    metrics.recordRequestDuration(req.path, req.method, res.statusCode, duration);
  });
  
  next();
});

const express = require('express');
const httpProxy = require('http-proxy');
const app = express();
const proxy = httpProxy.createProxyServer();
const Redis = require('ioredis');
const redis = new Redis();
const jwt = require('jsonwebtoken');
const axios = require('axios');
 
// Реестр сервисов
const services = {
  users: 'http://user-service:3001',
  products: 'http://product-service:3002',
  orders: 'http://order-service:3003',
  auth: 'http://auth-service:3004'
};
 
// Middleware для аутентификации
app.use(async (req, res, next) => {
  // Пропускаем запросы к сервису аутентификации
  if (req.path.startsWith('/auth/')) {
    return next();
  }
  
  const token = req.headers.authorization?.split(' ')[1];
  if (!token) {
    return res.status(401).json({ error: 'Требуется аутентификация' });
  }
  
  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    req.user = decoded;
    next();
  } catch (error) {
    res.status(401).json({ error: 'Неверный или просроченный токен' });
  }
});
 
// Middleware для логирования
app.use((req, res, next) => {
  const start = Date.now();
  
  res.on('finish', () => {
    const duration = Date.now() - start;
    console.log(`${req.method} ${req.path} ${res.statusCode} - ${duration}ms`);
  });
  
  next();
});
 
// Маршрутизация
app.use('/users', (req, res) => {
  proxy.web(req, res, { target: services.users });
});
 
app.use('/products', (req, res) => {
  proxy.web(req, res, { target: services.products });
});
 
app.use('/orders', (req, res) => {
  proxy.web(req, res, { target: services.orders });
});
 
app.use('/auth', (req, res) => {
  proxy.web(req, res, { target: services.auth });
});
 
// Пример агрегации данных
app.get('/product-details/:id', async (req, res) => {
  const productId = req.params.id;
  const cacheKey = `product-details:${productId}`;
  
  // Проверка кэша
  const cachedData = await redis.get(cacheKey);
  if (cachedData) {
    return res.json(JSON.parse(cachedData));
  }
  
  try {
    // Параллельное получение данных из разных сервисов
    const [product, reviews, recommendations] = await Promise.all([
      axios.get(`${services.products}/products/${productId}`),
      axios.get(`${services.products}/products/${productId}/reviews`),
      axios.get(`${services.products}/products/${productId}/recommendations`)
    ]);
    
    const result = {
      product: product.data,
      reviews: reviews.data,
      recommendations: recommendations.data
    };
    
    // Сохранение в кэш на 5 минут
    await redis.set(cacheKey, JSON.stringify(result), 'EX', 300);
    
    res.json(result);
  } catch (error) {
    res.status(500).json({ error: 'Ошибка при получении данных о продукте' });
  }
});
 
// Circuit Breaker для сервиса продуктов
const productServiceBreaker = {
  failures: 0,
  threshold: 5,
  state: 'CLOSED',
  lastFailure: null,
  reset() {
    this.failures = 0;
    this.state = 'CLOSED';
  }
};
 
// Обработка ошибок прокси
proxy.on('error', (err, req, res) => {
  if (req.path.startsWith('/products')) {
    productServiceBreaker.failures++;
    productServiceBreaker.lastFailure = Date.now();
    
    if (productServiceBreaker.failures >= productServiceBreaker.threshold) {
      productServiceBreaker.state = 'OPEN';
    }
  }
  
  res.status(500).json({ error: 'Сервис временно недоступен' });
});
 
// Проверка состояния Circuit Breaker перед запросами к сервису продуктов
app.use('/products', (req, res, next) => {
  if (productServiceBreaker.state === 'OPEN') {
    // Проверяем, прошло ли достаточно времени для перехода в полуоткрытое состояние
    const now = Date.now();
    const resetTimeout = 30000; // 30 секунд
    
    if (now - productServiceBreaker.lastFailure > resetTimeout) {
      productServiceBreaker.state = 'HALF-OPEN';
    } else {
      return res.status(503).json({
        error: 'Сервис временно недоступен',
        retry: Math.ceil((resetTimeout - (now - productServiceBreaker.lastFailure)) / 1000)
      });
    }
  }
  
  // Если выключатель закрыт или полуоткрыт, пропускаем запрос
  next();
});
 
// Отслеживаем успешные запросы для сброса Circuit Breaker
proxy.on('proxyRes', (proxyRes, req, res) => {
  if (req.path.startsWith('/products') && productServiceBreaker.state === 'HALF-OPEN') {
    if (proxyRes.statusCode < 500) {
      productServiceBreaker.reset();
    } else {
      productServiceBreaker.state = 'OPEN';
      productServiceBreaker.lastFailure = Date.now();
    }
  }
});
 
// Запуск сервера
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`API Gateway запущен на порту ${PORT}`);
});

resource "aws_api_gateway_rest_api" "example_api" {
  name = "example-api"
}
 
resource "aws_api_gateway_resource" "users_resource" {
  rest_api_id = aws_api_gateway_rest_api.example_api.id
  parent_id   = aws_api_gateway_rest_api.example_api.root_resource_id
  path_part   = "users"
}
 
resource "aws_api_gateway_method" "users_method" {
  rest_api_id   = aws_api_gateway_rest_api.example_api.id
  resource_id   = aws_api_gateway_resource.users_resource.id
  http_method   = "ANY"
  authorization = "COGNITO_USER_POOLS"
  authorizer_id = aws_api_gateway_authorizer.cognito.id
}
 
resource "aws_api_gateway_integration" "users_integration" {
  rest_api_id             = aws_api_gateway_rest_api.example_api.id
  resource_id             = aws_api_gateway_resource.users_resource.id
  http_method             = aws_api_gateway_method.users_method.http_method
  integration_http_method = "ANY"
  type                    = "HTTP_PROXY"
  uri                     = "http://user-service.internal:3001/{proxy}"
}

// Пример трансформации запроса в Node.js API Gateway
app.use('/legacy-api/users', (req, res, next) => {
  // Преобразуем параметры из нового формата в старый
  if (req.query.fullName) {
    const nameParts = req.query.fullName.split(' ');
    req.query.firstName = nameParts[0];
    req.query.lastName = nameParts[1] || '';
    delete req.query.fullName;
  }
  
  // Изменяем путь запроса для совместимости со старым сервисом
  req.url = req.url.replace('/legacy-api', '');
  
  next();
});
 
// Трансформация ответа
app.use('/products/:id', async (req, res) => {
  const productId = req.params.id;
  
  // Получаем данные от микросервиса
  const product = await axiosClient.get(`http://product-service/products/${productId}`);
  
  // Трансформируем ответ перед отправкой клиенту
  const transformedProduct = {
    id: product.data.id,
    title: product.data.name, // переименовываем поле
    price: {
      amount: product.data.price,
      currency: product.data.currency || 'USD'
    },
    // Удаляем внутренние служебные поля
    ...product.data,
    internalCode: undefined,
    supplierInfo: undefined
  };
  
  res.json(transformedProduct);
});

// Фильтрация чувствительных данных в ответе
function sanitizeResponseData(user) {
  return {
    ...user,
    password: undefined,
    ssn: user.ssn ? "*[B]-[/B]-" + user.ssn.slice(-4) : null,
    creditCard: user.creditCard ? "[B][/B]-[B][/B]-[B][/B]-" + user.creditCard.slice(-4) : null
  };
}