API Proxy Design

spring:
  cloud:
    gateway:
      routes:
        - id: admin-service
          uri: http://localhost:8080
          predicates:
            - Path=/api/**,/services/**
          filters:
            - RewritePath=/(?<segment>.*), /$\{segment}
            - name: Retry
              args:
                retries: 3
                statuses: BAD_GATEWAY,GATEWAY_TIMEOUT
                methods: GET,POST,PUT,DELETE
                backoff:
                  firstBackoff: 10ms
                  maxBackoff: 50ms
                  factor: 2
                  basedOnPreviousValue: false
        - id: admin-service-websocket
          uri: ws://localhost:8080
          predicates:
            - Path=/websocket/**

@Injectable({ providedIn: 'root' })
export class ApplicationConfigService {
  private endpointPrefix = '';

  setEndpointPrefix(endpointPrefix: string): void {
    this.endpointPrefix = endpointPrefix;
  }

  getEndpointFor(api: string, microservice?: string): string {
    if (microservice) {
      return `${this.endpointPrefix}services/${microservice}/${api}`;
    }
    return `${this.endpointPrefix}${api}`;
  }
}

// Proxied to admin-service
this.applicationConfigService.getEndpointFor('api/people', 'admin-service')
// Returns: "services/admin-service/api/people"

// Direct gateway endpoint
this.applicationConfigService.getEndpointFor('api/account')
// Returns: "api/account"

@Injectable({ providedIn: 'root' })
export class PeopleService {
  readonly peopleUrl = 'services/admin-service/api/people';

  getPerson(id: number): Observable<IPerson> {
    return this.personResourceService.getPerson(id)
      .pipe(mergeMap(response => this.blobUtils.parseBlob<IPerson>(response)));
  }
}

@Injectable({ providedIn: 'root' })
export class LinkedPersonStateService {
  linkEdPersonUrl = this.applicationConfigService
    .getEndpointFor('api/linked-people/link', 'admin-service');

  linkPerson(id: number, type: string, userKey: string): Observable<ILinkedPerson> {
    return this.http.post<ILinkedPerson>(
      `${this.linkEdPersonUrl}/${id}/${type}?userKey=${userKey}&organisationId=8`,
      { observe: 'response' }
    );
  }
}

import {
  FormResourceService,
  PersonResourceService,
  MembershipPeriodResourceService
} from '@christhonie/registration-api-ts';

@Injectable({ providedIn: 'root' })
export class FormService {
  private formResourceService = inject(FormResourceService);

  getFormMembership(membershipPeriodId: number, userKey: string):
    Observable<FormDTO> {
    return this.formResourceService
      .getFormMembership(membershipPeriodId, userKey)
      .pipe(mergeMap(response => this.blobUtils.parseBlob<FormDTO>(response)));
  }
}

resilience4j:
  circuitbreaker:
    instances:
      admin-service:
        failureRateThreshold: 50
        waitDurationInOpenState: 10s
        slidingWindowSize: 10
        minimumNumberOfCalls: 5

filters:
  - name: Retry
    args:
      retries: 3
      statuses: BAD_GATEWAY,GATEWAY_TIMEOUT
      methods: GET,POST,PUT,DELETE
      backoff:
        firstBackoff: 10ms
        maxBackoff: 50ms
        factor: 2

export class TimeoutInterceptor {
  static getHeadersWithTimeout(timeout: number): HttpHeaders {
    return new HttpHeaders({
      'X-Timeout': timeout.toString()
    });
  }
}

// Usage in FormService
const headers = TimeoutInterceptor.getHeadersWithTimeout(15000);
return this.formResourceService.next(data, 'body', false, { headers });

Authorization: Bearer eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...
Accept-Language: en
Content-Type: application/json

Authorization: Bearer eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...
X-Forwarded-For: 192.168.1.100
X-Forwarded-Proto: https
X-Forwarded-Host: app.example.com

spring:
  cloud:
    gateway:
      httpclient:
        pool:
          max-connections: 100
          max-idle-time: 30s
          acquire-timeout: 45s

spring:
  cloud:
    gateway:
      routes:
        - id: admin-service
          uri: lb://admin-service  # Load balanced
          predicates:
            - Path=/api/**

gateway.requests{route=admin-service,status=200} 1523
gateway.requests{route=admin-service,status=500} 12
gateway.requests.duration{route=admin-service} 145ms

{
  "status": "UP",
  "components": {
    "gateway": {
      "status": "UP"
    },
    "admin-service": {
      "status": "UP",
      "details": {
        "responseTime": "45ms"
      }
    },
    "diskSpace": {
      "status": "UP"
    }
  }
}