Какие знаешь решения для использования в качестве Gateway?

Решения для API Gateway в Java экосистеме

API Gateway — это критический компонент микросервисной архитектуры, обеспечивающий единую точку входа для всех клиентов. Рассмотрим основные решения и их характеристики.

Spring Cloud Gateway

Spring Cloud Gateway — официальное решение от Spring для построения API Gateway с полной интеграцией в Spring Boot экосистему.

@SpringBootApplication
public class ApiGatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(ApiGatewayApplication.class, args);
    }
}

@Configuration
public class GatewayConfig {
    @Bean
    public RouteLocator customRoutes(RouteLocatorBuilder builder) {
        return builder.routes()
            .route("user-service", r -> r
                .path("/users/**")
                .filters(f -> f
                    .stripPrefix(1)
                    .addRequestHeader("X-Request-ID", "123")
                )
                .uri("http://user-service:8081")
            )
            .route("order-service", r -> r
                .path("/orders/**")
                .filters(f -> f
                    .stripPrefix(1)
                    .requestRateLimiter(c -> c
                        .setRateLimiter(redisRateLimiter())
                    )
                )
                .uri("http://order-service:8082")
            )
            .build();
    }

    @Bean
    public RedisRateLimiter redisRateLimiter() {
        return new RedisRateLimiter(10, 20); // 10 req/sec, burst 20
    }
}

Преимущества:

• Полная интеграция с Spring Boot и Spring Security
• Асинхронная обработка на базе Project Reactor
• Встроенная поддержка rate limiting и circuit breaker
• Динамическая маршрутизация

Недостатки:

• Потребление памяти выше, чем у альтернатив
• Кривая обучения при работе с реактивными потоками

Netflix Zuul 2.x

Zuul — проверенное решение от Netflix для маршрутизации и фильтрации трафика:

@SpringBootApplication
@EnableZuulProxy
public class ZuulGatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(ZuulGatewayApplication.class, args);
    }
}

@Configuration
public class ZuulConfig {
    @Bean
    public ZuulProperties zuulProperties() {
        ZuulProperties props = new ZuulProperties();
        
        ZuulProperties.ZuulRoute userRoute = new ZuulProperties.ZuulRoute();
        userRoute.setPath("/api/users/**");
        userRoute.setUrl("http://user-service:8081");
        userRoute.setStripPrefix(true);
        
        ZuulProperties.ZuulRoute orderRoute = new ZuulProperties.ZuulRoute();
        orderRoute.setPath("/api/orders/**");
        orderRoute.setUrl("http://order-service:8082");
        
        props.getRoutes().put("users", userRoute);
        props.getRoutes().put("orders", orderRoute);
        
        return props;
    }
}

@Component
public class AuthenticationFilter extends ZuulFilter {
    @Override
    public String filterType() {
        return "pre"; // pre, routing, post, error
    }

    @Override
    public int filterOrder() {
        return 1;
    }

    @Override
    public boolean shouldFilter() {
        return true;
    }

    @Override
    public Object run() throws ZuulException {
        RequestContext ctx = RequestContext.getCurrentContext();
        String token = ctx.getRequest().getHeader("Authorization");
        
        if (token == null || !validateToken(token)) {
            ctx.setSendZuulResponse(false);
            ctx.setResponseStatusCode(401);
            ctx.setResponseBody("Unauthorized");
        }
        return null;
    }

    private boolean validateToken(String token) {
        // Валидация JWT токена
        return true;
    }
}

Преимущества:

• Стабильно и проверено на production
• Простая фильтрация через ZuulFilter
• Хорошая документация

Недостатки:

• Синхронная архитектура, менее подходит для высоконагруженных систем
• Spring Cloud поддержка Zuul 2 не активна

Kong

Kong — независимое open-source решение, написанное на Lua/nginx с RESTful API:

// Java клиент для управления Kong через API
@Service
public class KongAdminService {
    @Autowired
    private RestTemplate restTemplate;

    private final String KONG_ADMIN_URL = "http://kong:8001";

    public void registerService(String serviceName, String url) {
        HttpEntity<Map<String, String>> request = new HttpEntity<>(
            Map.of(
                "name", serviceName,
                "url", url,
                "connect_timeout", "60000",
                "read_timeout", "30000"
            )
        );
        
        restTemplate.postForObject(
            KONG_ADMIN_URL + "/services",
            request,
            Map.class
        );
    }

    public void registerRoute(String serviceName, String path) {
        HttpEntity<Map<String, Object>> request = new HttpEntity<>(
            Map.of(
                "paths", List.of(path),
                "service", Map.of("name", serviceName)
            )
        );
        
        restTemplate.postForObject(
            KONG_ADMIN_URL + "/routes",
            request,
            Map.class
        );
    }

    public void enableRateLimiting(String routeId, int requestsPerMinute) {
        HttpEntity<Map<String, Object>> request = new HttpEntity<>(
            Map.of(
                "name", "rate-limiting",
                "config", Map.of(
                    "minute", requestsPerMinute
                )
            )
        );
        
        restTemplate.postForObject(
            KONG_ADMIN_URL + "/routes/" + routeId + "/plugins",
            request,
            Map.class
        );
    }
}

Преимущества:

• Не зависит от Java/Spring
• Огромное количество плагинов
• Превосходная масштабируемость
• Управление через API

Недостатки:

• Требует отдельного процесса
• Дополнительная сложность в операциях

AWS API Gateway

AWS API Gateway — управляемый сервис в облаке:

// Java SDK для управления API Gateway
@Service
public class AwsApiGatewayService {
    @Autowired
    private AmazonApiGateway apiGateway;

    public String createRestApi(String apiName, String description) {
        CreateRestApiRequest request = new CreateRestApiRequest()
            .withName(apiName)
            .withDescription(description)
            .withEndpointConfiguration(
                new EndpointConfiguration()
                    .withTypes(EndpointType.REGIONAL)
            );

        CreateRestApiResult result = apiGateway.createRestApi(request);
        return result.getId();
    }

    public void createResource(String apiId, String resourceName) {
        GetResourcesRequest getResourcesRequest = new GetResourcesRequest()
            .withRestApiId(apiId);
        
        GetResourcesResult getResourcesResult = 
            apiGateway.getResources(getResourcesRequest);
        
        String rootId = getResourcesResult.getItems().get(0).getId();

        CreateResourceRequest createResourceRequest = 
            new CreateResourceRequest()
                .withRestApiId(apiId)
                .withParentId(rootId)
                .withPathPart(resourceName);

        apiGateway.createResource(createResourceRequest);
    }

    public void attachLambda(String apiId, String resourceId, String httpMethod) {
        PutIntegrationRequest putIntegrationRequest = 
            new PutIntegrationRequest()
                .withRestApiId(apiId)
                .withResourceId(resourceId)
                .withHttpMethod(httpMethod)
                .withType(IntegrationType.AWS_PROXY)
                .withIntegrationHttpMethod("POST")
                .withUri("arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:ACCOUNT:function:myFunction/invocations");

        apiGateway.putIntegration(putIntegrationRequest);
    }
}

Преимущества:

• Полностью управляемый сервис
• Встроенная аутентификация (Cognito)
• Rate limiting и DDoS защита из коробки
• Масштабируется автоматически

Недостатки:

• Привязка к AWS экосистеме
• Дорого на высоконагруженных системах
• Меньше гибкости по сравнению с self-hosted решениями

Traefik

Traefik — модерное решение с поддержкой контейнеризации и микросервисов:

@Service
public class TraefikConfigService {
    // Конфигурация через Traefik Dashboard или File/API
    // Java приложения могут использовать Traefik как обратный прокси
}

// Docker Compose пример
/*
version: '3.8'
services:
  traefik:
    image: traefik:v2.10
    command:
      - "--api.insecure=true"
      - "--providers.docker=true"
      - "--providers.docker.exposedbydefault=false"
      - "--entrypoints.web.address=:80"
    ports:
      - "80:80"
      - "8080:8080"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock

  user-service:
    image: myapp:user-service
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.users.rule=Host(`api.example.com`) && PathPrefix(`/users`)"
      - "traefik.http.services.users.loadbalancer.server.port=8081"
*/

Преимущества:

• Отлично интегрируется с Docker/Kubernetes
• Автоматическое открытие сервисов
• Встроенная поддержка SSL/TLS
• Простая конфигурация

Недостатки:

• Меньше встроенных плагинов чем Kong
• Кривая обучения для Kubernetes

Сравнительная таблица

Рекомендации по выбору

• Spring Cloud Gateway — для Java-only экосистем с Spring Boot
• Kong — для независимых, высоконагруженных систем
• AWS API Gateway — для облачных приложений на AWS
• Traefik — для Docker/Kubernetes окружения
• Zuul — для legacy систем, которые уже используют Netflix Stack