1
// Example: Express.js-based API Gateway routing configuration
2
const express = require("express");
3
const httpProxy = require("http-proxy-middleware");
4
const app = express();
5

6
// Service registry for dynamic routing
7
const serviceRegistry = {
8
  users: ["http://user-service-1:3001", "http://user-service-2:3001"],
9
  orders: ["http://order-service:3002"],
10
  products: ["http://product-service:3003", "http://product-service-2:3003"],
11
};
12

13
// Load balancer implementation
14
class LoadBalancer {
15
  constructor(servers) {
16
    this.servers = servers;
17
    this.current = 0;
18
  }
19

20
  getNext() {
21
    const server = this.servers[this.current];
22
    this.current = (this.current + 1) % this.servers.length;
23
    return server;
24
  }
25
}
26

27
// Create load balancers for each service
28
const balancers = {
29
  users: new LoadBalancer(serviceRegistry.users),
30
  orders: new LoadBalancer(serviceRegistry.orders),
31
  products: new LoadBalancer(serviceRegistry.products),
32
};
33

34
// Dynamic routing middleware
35
app.use("/api/:service/*", (req, res, next) => {
36
  const service = req.params.service;
37
  const balancer = balancers[service];
38

39
  if (!balancer) {
40
    return res.status(404).json({ error: "Service not found" });
41
  }
42

43
  const target = balancer.getNext();
44

45
  httpProxy.createProxyMiddleware({
46
    target,
47
    changeOrigin: true,
48
    pathRewrite: {
49
      [`^/api/${service}`]: "",
50
    },
51
    onError: (err, req, res) => {
52
      console.error(`Error proxying to ${service}:`, err);
53
      res.status(503).json({ error: "Service temporarily unavailable" });
54
    },
55
  })(req, res, next);
56
});

1
sequenceDiagram
2
    participant Client
3
    participant Gateway
4
    participant AuthService
5
    participant UserService
6
    participant Cache
7

8
    Client->>Gateway: Request with JWT token
9
    Gateway->>Gateway: Extract token from header
10

11
    alt Token in cache
12
        Gateway->>Cache: Check token validity
13
        Cache-->>Gateway: Token valid + user context
14
    else Token not in cache
15
        Gateway->>AuthService: Validate token
16
        AuthService->>AuthService: Verify signature
17
        AuthService->>AuthService: Check expiration
18
        AuthService-->>Gateway: Token valid + claims
19
        Gateway->>Cache: Store validation result
20
    end
21

22
    Gateway->>Gateway: Check permissions
23

24
    alt Authorized
25
        Gateway->>UserService: Forward request + user context
26
        UserService-->>Gateway: Response
27
        Gateway-->>Client: Success response
28
    else Unauthorized
29
        Gateway-->>Client: 403 Forbidden
30
    end

1
// TypeScript implementation of authentication middleware
2
import { Request, Response, NextFunction } from "express";
3
import jwt from "jsonwebtoken";
4
import { Redis } from "ioredis";
5

6
interface AuthenticatedRequest extends Request {
7
  user?: {
8
    id: string;
9
    email: string;
10
    roles: string[];
11
  };
12
}
13

14
class AuthenticationMiddleware {
15
  private redis: Redis;
16
  private jwtSecret: string;
17

18
  constructor(redis: Redis, jwtSecret: string) {
19
    this.redis = redis;
20
    this.jwtSecret = jwtSecret;
21
  }
22

23
  async authenticate(
24
    req: AuthenticatedRequest,
25
    res: Response,
26
    next: NextFunction
27
  ): Promise<void> {
28
    try {
29
      const token = this.extractToken(req);
30

31
      if (!token) {
32
        return res.status(401).json({ error: "No token provided" });
33
      }
34

35
      // Check cache first
36
      const cachedUser = await this.redis.get(`auth:${token}`);
37

38
      if (cachedUser) {
39
        req.user = JSON.parse(cachedUser);
40
        return next();
41
      }
42

43
      // Verify token
44
      const decoded = jwt.verify(token, this.jwtSecret) as any;
45

46
      // Create user context
47
      const user = {
48
        id: decoded.sub,
49
        email: decoded.email,
50
        roles: decoded.roles || [],
51
      };
52

53
      // Cache for 5 minutes
54
      await this.redis.setex(`auth:${token}`, 300, JSON.stringify(user));
55

56
      req.user = user;
57
      next();
58
    } catch (error) {
59
      if (error.name === "TokenExpiredError") {
60
        return res.status(401).json({ error: "Token expired" });
61
      }
62

63
      return res.status(401).json({ error: "Invalid token" });
64
    }
65
  }
66

67
  authorize(requiredRoles: string[]) {
68
    return (req: AuthenticatedRequest, res: Response, next: NextFunction) => {
69
      if (!req.user) {
70
        return res.status(401).json({ error: "Not authenticated" });
71
      }
72

73
      const hasRole = requiredRoles.some(role =>
74
        req.user!.roles.includes(role)
75
      );
76

77
      if (!hasRole) {
78
        return res.status(403).json({ error: "Insufficient permissions" });
79
      }
80

81
      next();
82
    };
83
  }
84

85
  private extractToken(req: Request): string | null {
86
    const authHeader = req.headers.authorization;
87

88
    if (authHeader && authHeader.startsWith("Bearer ")) {
89
      return authHeader.substring(7);
90
    }
91

92
    return req.cookies?.token || null;
93
  }
94
}

1
graph LR
2
    subgraph "Rate Limiting Process"
3
        Request[Incoming Request]
4
        Identifier[Identify Client]
5
        Counter[Check Counter]
6
        Decision{Within Limit?}
7
        Allow[Allow Request]
8
        Reject[Reject - 429]
9
        Update[Update Counter]
10
        Reset[Reset Window]
11
    end
12

13
    subgraph "Storage"
14
        Redis[(Redis)]
15
    end
16

17
    Request --> Identifier
18
    Identifier --> Counter
19
    Counter --> Redis
20
    Redis --> Decision
21
    Decision -->|Yes| Allow
22
    Allow --> Update
23
    Update --> Redis
24
    Decision -->|No| Reject
25

26
    Reset -.->|Periodic| Redis
27

28
    style Decision fill:#ffd,stroke:#333,stroke-width:2px
29
    style Redis fill:#fbb,stroke:#333,stroke-width:2px

1
// Advanced rate limiting with sliding window
2
class SlidingWindowRateLimiter {
3
  constructor(redis, windowSize = 60, maxRequests = 100) {
4
    this.redis = redis;
5
    this.windowSize = windowSize; // seconds
6
    this.maxRequests = maxRequests;
7
  }
8

9
  async checkLimit(identifier) {
10
    const now = Date.now();
11
    const windowStart = now - this.windowSize * 1000;
12
    const key = `rate:${identifier}`;
13

14
    // Remove old entries
15
    await this.redis.zremrangebyscore(key, "-inf", windowStart);
16

17
    // Count requests in current window
18
    const currentCount = await this.redis.zcard(key);
19

20
    if (currentCount >= this.maxRequests) {
21
      // Calculate when the oldest request will expire
22
      const oldestRequest = await this.redis.zrange(key, 0, 0, "WITHSCORES");
23
      const resetTime = oldestRequest[1]
24
        ? Math.ceil(
25
            (parseInt(oldestRequest[1]) + this.windowSize * 1000 - now) / 1000
26
          )
27
        : this.windowSize;
28

29
      return {
30
        allowed: false,
31
        limit: this.maxRequests,
32
        remaining: 0,
33
        resetIn: resetTime,
34
      };
35
    }
36

37
    // Add current request
38
    await this.redis.zadd(key, now, `${now}-${Math.random()}`);
39
    await this.redis.expire(key, this.windowSize);
40

41
    return {
42
      allowed: true,
43
      limit: this.maxRequests,
44
      remaining: this.maxRequests - currentCount - 1,
45
      resetIn: this.windowSize,
46
    };
47
  }
48

49
  middleware() {
50
    return async (req, res, next) => {
51
      // Identify client by API key, user ID, or IP
52
      const identifier = req.user?.id || req.headers["x-api-key"] || req.ip;
53

54
      const result = await this.checkLimit(identifier);
55

56
      // Set rate limit headers
57
      res.setHeader("X-RateLimit-Limit", result.limit);
58
      res.setHeader("X-RateLimit-Remaining", result.remaining);
59
      res.setHeader("X-RateLimit-Reset", Date.now() + result.resetIn * 1000);
60

61
      if (!result.allowed) {
62
        res.setHeader("Retry-After", result.resetIn);
63
        return res.status(429).json({
64
          error: "Too many requests",
65
          retryAfter: result.resetIn,
66
        });
67
      }
68

69
      next();
70
    };
71
  }
72
}

1
// Request/Response transformation pipeline
2
class TransformationPipeline {
3
  private transformers: Map<string, Transformer[]> = new Map();
4

5
  register(path: string, transformer: Transformer) {
6
    if (!this.transformers.has(path)) {
7
      this.transformers.set(path, []);
8
    }
9
    this.transformers.get(path)!.push(transformer);
10
  }
11

12
  async transformRequest(path: string, data: any): Promise<any> {
13
    const transformers = this.matchTransformers(path);
14
    let transformed = data;
15

16
    for (const transformer of transformers) {
17
      if (transformer.transformRequest) {
18
        transformed = await transformer.transformRequest(transformed);
19
      }
20
    }
21

22
    return transformed;
23
  }
24

25
  async transformResponse(path: string, data: any): Promise<any> {
26
    const transformers = this.matchTransformers(path);
27
    let transformed = data;
28

29
    // Apply transformers in reverse order for responses
30
    for (const transformer of transformers.reverse()) {
31
      if (transformer.transformResponse) {
32
        transformed = await transformer.transformResponse(transformed);
33
      }
34
    }
35

36
    return transformed;
37
  }
38

39
  private matchTransformers(path: string): Transformer[] {
40
    const matched: Transformer[] = [];
41

42
    for (const [pattern, transformers] of this.transformers) {
43
      if (this.pathMatches(path, pattern)) {
44
        matched.push(...transformers);
45
      }
46
    }
47

48
    return matched;
49
  }
50

51
  private pathMatches(path: string, pattern: string): boolean {
52
    // Convert pattern to regex (e.g., /api/*/users -> /api/.*/users)
53
    const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
54
    return regex.test(path);
55
  }
56
}
57

58
// Example transformers
59
const versionTransformer: Transformer = {
60
  transformRequest: async data => {
61
    // Convert v1 API format to internal format
62
    if (data.user_name) {
63
      data.username = data.user_name;
64
      delete data.user_name;
65
    }
66
    return data;
67
  },
68

69
  transformResponse: async data => {
70
    // Convert internal format to v1 API format
71
    if (data.username) {
72
      data.user_name = data.username;
73
      delete data.username;
74
    }
75
    return data;
76
  },
77
};
78

79
const aggregationTransformer: Transformer = {
80
  transformResponse: async data => {
81
    // Aggregate data from multiple services
82
    if (data.userId && !data.userDetails) {
83
      const userDetails = await userService.getUser(data.userId);
84
      data.userDetails = userDetails;
85
    }
86
    return data;
87
  },
88
};

1
graph TB
2
    subgraph "Service Discovery Flow"
3
        Gateway[API Gateway]
4
        Registry[Service Registry]
5
        Health[Health Checker]
6

7
        subgraph "Service Instances"
8
            S1[Service A - Instance 1]
9
            S2[Service A - Instance 2]
10
            S3[Service B - Instance 1]
11
            S4[Service C - Instance 1]
12
            S5[Service C - Instance 2]
13
            S6[Service C - Instance 3]
14
        end
15
    end
16

17
    S1 -->|Register| Registry
18
    S2 -->|Register| Registry
19
    S3 -->|Register| Registry
20
    S4 -->|Register| Registry
21
    S5 -->|Register| Registry
22
    S6 -->|Register| Registry
23

24
    Health -->|Check| S1
25
    Health -->|Check| S2
26
    Health -->|Check| S3
27
    Health -->|Check| S4
28
    Health -->|Check| S5
29
    Health -->|Check| S6
30

31
    Gateway -->|Query Services| Registry
32
    Registry -->|Return Healthy Instances| Gateway
33

34
    Gateway -->|Route Request| S1
35
    Gateway -->|Route Request| S2
36
    Gateway -->|Route Request| S3
37

38
    style Gateway fill:#f9f,stroke:#333,stroke-width:4px
39
    style Registry fill:#bbf,stroke:#333,stroke-width:2px
40
    style Health fill:#bfb,stroke:#333,stroke-width:2px

1
@SpringBootApplication
2
@EnableDiscoveryClient
3
public class ApiGatewayApplication {
4

5
    public static void main(String[] args) {
6
        SpringApplication.run(ApiGatewayApplication.class, args);
7
    }
8

9
    @Bean
10
    public RouteLocator customRouteLocator(
11
            RouteLocatorBuilder builder,
12
            AuthenticationFilter authFilter,
13
            RateLimitFilter rateLimitFilter) {
14

15
        return builder.routes()
16
            // User service routes
17
            .route("user-service", r -> r
18
                .path("/api/users/**")
19
                .filters(f -> f
20
                    .filter(authFilter)
21
                    .filter(rateLimitFilter)
22
                    .stripPrefix(2)
23
                    .circuitBreaker(config -> config
24
                        .setName("userServiceCB")
25
                        .setFallbackUri("/fallback/users"))
26
                    .retry(config -> config
27
                        .setRetries(3)
28
                        .setBackoff(Duration.ofSeconds(1),
29
                                   Duration.ofSeconds(5), 2, true)))
30
                .uri("lb://user-service"))
31

32
            // Order service routes
33
            .route("order-service", r -> r
34
                .path("/api/orders/**")
35
                .filters(f -> f
36
                    .filter(authFilter)
37
                    .filter(rateLimitFilter)
38
                    .stripPrefix(2)
39
                    .requestRateLimiter(config -> config
40
                        .setRateLimiter(redisRateLimiter())
41
                        .setKeyResolver(userKeyResolver()))
42
                    .modifyRequestBody(OrderV1.class, OrderV2.class,
43
                        (exchange, orderV1) -> Mono.just(transformToV2(orderV1))))
44
                .uri("lb://order-service"))
45

46
            // Product service with caching
47
            .route("product-service", r -> r
48
                .path("/api/products/**")
49
                .filters(f -> f
50
                    .filter(authFilter)
51
                    .stripPrefix(2)
52
                    .cache(Duration.ofMinutes(5)))
53
                .uri("lb://product-service"))
54

55
            .build();
56
    }
57

58
    @Bean
59
    public RedisRateLimiter redisRateLimiter() {
60
        return new RedisRateLimiter(100, 200, 1);
61
    }
62

63
    @Bean
64
    KeyResolver userKeyResolver() {
65
        return exchange -> Mono.justOrEmpty(
66
            exchange.getRequest()
67
                .getHeaders()
68
                .getFirst("X-User-Id")
69
        );
70
    }
71
}
72

73
@Component
74
public class AuthenticationFilter extends AbstractGatewayFilterFactory<AuthenticationFilter.Config> {
75

76
    @Autowired
77
    private JwtValidator jwtValidator;
78

79
    @Override
80
    public GatewayFilter apply(Config config) {
81
        return (exchange, chain) -> {
82
            ServerHttpRequest request = exchange.getRequest();
83

84
            if (!request.getHeaders().containsKey(HttpHeaders.AUTHORIZATION)) {
85
                return onError(exchange, "No authorization header", HttpStatus.UNAUTHORIZED);
86
            }
87

88
            String authHeader = request.getHeaders().get(HttpHeaders.AUTHORIZATION).get(0);
89
            String token = authHeader.substring(7); // Remove "Bearer "
90

91
            return jwtValidator.validateToken(token)
92
                .flatMap(claims -> {
93
                    // Add user context to headers
94
                    ServerHttpRequest modifiedRequest = request.mutate()
95
                        .header("X-User-Id", claims.getSubject())
96
                        .header("X-User-Roles", String.join(",", claims.getRoles()))
97
                        .build();
98

99
                    return chain.filter(exchange.mutate()
100
                        .request(modifiedRequest)
101
                        .build());
102
                })
103
                .onErrorResume(error -> onError(exchange, "Invalid token", HttpStatus.UNAUTHORIZED));
104
        };
105
    }
106

107
    private Mono<Void> onError(ServerWebExchange exchange, String err, HttpStatus httpStatus) {
108
        ServerHttpResponse response = exchange.getResponse();
109
        response.setStatusCode(httpStatus);
110

111
        byte[] bytes = err.getBytes(StandardCharsets.UTF_8);
112
        DataBuffer buffer = response.bufferFactory().wrap(bytes);
113

114
        return response.writeWith(Mono.just(buffer));
115
    }
116

117
    public static class Config {
118
        // Configuration properties
119
    }
120
}

1
# kong.yml - Declarative configuration
2
_format_version: "2.1"
3

4
services:
5
  - name: user-service
6
    url: http://user-service.default.svc.cluster.local:8080
7
    routes:
8
      - name: user-routes
9
        paths:
10
          - /api/users
11
        strip_path: true
12
    plugins:
13
      - name: jwt
14
        config:
15
          key_claim_name: kid
16
          secret_is_base64: false
17
      - name: rate-limiting
18
        config:
19
          minute: 100
20
          hour: 10000
21
          policy: redis
22
          redis_host: redis.default.svc.cluster.local
23
      - name: request-transformer
24
        config:
25
          add:
26
            headers:
27
              - X-Gateway-Version:v2.0
28
              - X-Request-ID:$(uuid)
29
      - name: prometheus
30

31
  - name: order-service
32
    url: http://order-service.default.svc.cluster.local:8080
33
    routes:
34
      - name: order-routes
35
        paths:
36
          - /api/orders
37
        strip_path: true
38
    plugins:
39
      - name: oauth2
40
        config:
41
          enable_client_credentials: true
42
          enable_authorization_code: true
43
          auth_header_name: Authorization
44
      - name: circuit-breaker
45
        config:
46
          error_threshold_percentage: 50
47
          volume_threshold: 10
48
          timeout: 30
49
          recovery_timeout: 60
50
      - name: correlation-id
51
        config:
52
          header_name: X-Correlation-ID
53
          generator: uuid
54
          echo_downstream: true
55

56
plugins:
57
  - name: cors
58
    config:
59
      origins:
60
        - https://app.example.com
61
        - https://mobile.example.com
62
      methods:
63
        - GET
64
        - POST
65
        - PUT
66
        - DELETE
67
      headers:
68
        - Authorization
69
        - Content-Type
70
      credentials: true
71
      max_age: 3600
72

73
  - name: bot-detection
74
    config:
75
      allow:
76
        - "(Googlebot|Bingbot|Slurp|DuckDuckBot)"
77
      deny:
78
        - "(bot|crawler|spider)"
79

80
  - name: ip-restriction
81
    config:
82
      allow:
83
        - 10.0.0.0/8
84
        - 172.16.0.0/12

1
// Advanced custom API Gateway implementation
2
import express from "express";
3
import { createProxyMiddleware } from "http-proxy-middleware";
4
import CircuitBreaker from "opossum";
5
import { Cache } from "./cache";
6
import { ServiceRegistry } from "./service-registry";
7
import { MetricsCollector } from "./metrics";
8

9
class APIGateway {
10
  private app: express.Application;
11
  private serviceRegistry: ServiceRegistry;
12
  private cache: Cache;
13
  private metrics: MetricsCollector;
14
  private circuitBreakers: Map<string, CircuitBreaker> = new Map();
15

16
  constructor() {
17
    this.app = express();
18
    this.serviceRegistry = new ServiceRegistry();
19
    this.cache = new Cache();
20
    this.metrics = new MetricsCollector();
21

22
    this.setupMiddleware();
23
    this.setupRoutes();
24
  }
25

26
  private setupMiddleware() {
27
    // Global middleware
28
    this.app.use(express.json());
29
    this.app.use(this.correlationId());
30
    this.app.use(this.requestLogging());
31
    this.app.use(this.metrics.middleware());
32

33
    // Security middleware
34
    this.app.use(helmet());
35
    this.app.use(this.rateLimiting());
36
    this.app.use(this.authentication());
37
  }
38

39
  private setupRoutes() {
40
    // Health check endpoint
41
    this.app.get("/health", (req, res) => {
42
      res.json({
43
        status: "healthy",
44
        timestamp: new Date().toISOString(),
45
        services: this.serviceRegistry.getHealthStatus(),
46
      });
47
    });
48

49
    // Dynamic service routing
50
    this.app.use("/api/:service/*", this.serviceRouter());
51
  }
52

53
  private serviceRouter() {
54
    return async (req: Request, res: Response, next: NextFunction) => {
55
      const serviceName = req.params.service;
56
      const path = req.params[0];
57

58
      try {
59
        // Check cache for GET requests
60
        if (req.method === "GET") {
61
          const cacheKey = `${serviceName}:${path}:${JSON.stringify(req.query)}`;
62
          const cachedResponse = await this.cache.get(cacheKey);
63

64
          if (cachedResponse) {
65
            this.metrics.recordCacheHit(serviceName);
66
            return res.json(cachedResponse);
67
          }
68
        }
69

70
        // Get service instances from registry
71
        const instances =
72
          await this.serviceRegistry.getHealthyInstances(serviceName);
73

74
        if (instances.length === 0) {
75
          return res.status(503).json({
76
            error: "Service unavailable",
77
            service: serviceName,
78
          });
79
        }
80

81
        // Get or create circuit breaker for service
82
        const circuitBreaker = this.getCircuitBreaker(serviceName);
83

84
        // Execute request through circuit breaker
85
        const response = await circuitBreaker.fire(async () => {
86
          const instance = this.selectInstance(instances);
87
          return this.proxyRequest(req, instance, path);
88
        });
89

90
        // Cache successful GET responses
91
        if (req.method === "GET" && response.status === 200) {
92
          const cacheKey = `${serviceName}:${path}:${JSON.stringify(req.query)}`;
93
          await this.cache.set(cacheKey, response.data, 300); // 5 minutes
94
        }
95

96
        res.status(response.status).json(response.data);
97
      } catch (error) {
98
        if (error.code === "EOPENBREAKER") {
99
          this.metrics.recordCircuitOpen(serviceName);
100
          return res.status(503).json({
101
            error: "Service temporarily unavailable",
102
            service: serviceName,
103
            retryAfter: 60,
104
          });
105
        }
106

107
        this.metrics.recordError(serviceName, error);
108
        next(error);
109
      }
110
    };
111
  }
112

113
  private getCircuitBreaker(serviceName: string): CircuitBreaker {
114
    if (!this.circuitBreakers.has(serviceName)) {
115
      const options = {
116
        timeout: 3000,
117
        errorThresholdPercentage: 50,
118
        resetTimeout: 30000,
119
        rollingCountTimeout: 10000,
120
        rollingCountBuckets: 10,
121
        name: serviceName,
122
      };
123

124
      const breaker = new CircuitBreaker(this.proxyRequest.bind(this), options);
125

126
      breaker.on("open", () => {
127
        console.log(`Circuit breaker opened for ${serviceName}`);
128
      });
129

130
      breaker.on("halfOpen", () => {
131
        console.log(`Circuit breaker half-open for ${serviceName}`);
132
      });
133

134
      breaker.on("close", () => {
135
        console.log(`Circuit breaker closed for ${serviceName}`);
136
      });
137

138
      this.circuitBreakers.set(serviceName, breaker);
139
    }
140

141
    return this.circuitBreakers.get(serviceName)!;
142
  }
143

144
  private selectInstance(instances: ServiceInstance[]): ServiceInstance {
145
    // Weighted round-robin selection based on health scores
146
    const totalWeight = instances.reduce(
147
      (sum, inst) => sum + inst.healthScore,
148
      0
149
    );
150
    let random = Math.random() * totalWeight;
151

152
    for (const instance of instances) {
153
      random -= instance.healthScore;
154
      if (random <= 0) {
155
        return instance;
156
      }
157
    }
158

159
    return instances[0]; // Fallback
160
  }
161

162
  private async proxyRequest(
163
    req: Request,
164
    instance: ServiceInstance,
165
    path: string
166
  ): Promise<any> {
167
    // Implementation of actual HTTP proxy logic
168
    const url = `${instance.url}/${path}`;
169
    const response = await axios({
170
      method: req.method,
171
      url,
172
      data: req.body,
173
      headers: this.prepareHeaders(req.headers),
174
      params: req.query,
175
      timeout: 5000,
176
    });
177

178
    return {
179
      status: response.status,
180
      data: response.data,
181
    };
182
  }
183

184
  start(port: number) {
185
    this.app.listen(port, () => {
186
      console.log(`API Gateway listening on port ${port}`);
187
    });
188
  }
189
}

1
# Example: Kubernetes deployment for HA
2
apiVersion: apps/v1
3
kind: Deployment
4
metadata:
5
  name: api-gateway
6
spec:
7
  replicas: 3
8
  selector:
9
    matchLabels:
10
      app: api-gateway
11
  template:
12
    metadata:
13
      labels:
14
        app: api-gateway
15
    spec:
16
      affinity:
17
        podAntiAffinity:
18
          requiredDuringSchedulingIgnoredDuringExecution:
19
            - labelSelector:
20
                matchExpressions:
21
                  - key: app
22
                    operator: In
23
                    values:
24
                      - api-gateway
25
              topologyKey: kubernetes.io/hostname
26
      containers:
27
        - name: gateway
28
          image: api-gateway:latest
29
          resources:
30
            requests:
31
              memory: "512Mi"
32
              cpu: "500m"
33
            limits:
34
              memory: "1Gi"
35
              cpu: "1000m"
36
          livenessProbe:
37
            httpGet:
38
              path: /health
39
              port: 8080
40
            initialDelaySeconds: 30
41
            periodSeconds: 10
42
          readinessProbe:
43
            httpGet:
44
              path: /ready
45
              port: 8080
46
            initialDelaySeconds: 5
47
            periodSeconds: 5