Reverse Proxy & API Gateway

Čo je Reverse Proxy?

Reverse proxy je server, ktorý stojí pred backend servermi a preposiela klientské požiadavky na správny backend. Klient komunikuje len s proxy — nevie o skutočných serveroch za ním.

Reverse Proxy vs Forward Proxy

Vlastnosť	Forward Proxy	Reverse Proxy
Kto ho používa	Klient (browser, app)	Server (backend infraštruktúra)
Smer	Klient → Proxy → Internet	Internet → Proxy → Backend
Účel	Anonymita, filtrovanie, caching na strane klienta	Load balancing, SSL termination, caching, ochrana backendu
Príklad	Squid, firemný proxy	Nginx, Traefik, Caddy, Envoy
Kto vie o proxy	Klient vie, server nie	Server vie, klient nie

Forward Proxy:
  Klient → [Forward Proxy] → Internet → Server

Reverse Proxy:
  Klient → Internet → [Reverse Proxy] → Backend Server(s)

Prečo používať reverse proxy?

• Load balancing — rozloženie záťaže na viacero backendov
• SSL/TLS termination — proxy rieši šifrovanie, backend dostáva plain HTTP
• Caching — statický obsah sa servuje priamo z proxy
• Kompresia — gzip/brotli na úrovni proxy
• Ochrana — backend nie je priamo vystavený internetu
• Centrálne logovanie — všetky requesty na jednom mieste

---

Nginx

Nginx je najrozšírenejší reverse proxy a web server. Podrobne ho rozoberáme v samostatnom článku — pozri Nginx.

Tu len stručne — typická reverse proxy konfigurácia:

upstream backend {
    server app1:8080;
    server app2:8080;
}

server {
    listen 80;
    server_name example.com;

    location / {
        proxy_pass http://backend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

---

Traefik

Traefik je moderný reverse proxy navrhnutý pre dynamické, kontajnerové prostredia.

Kľúčové vlastnosti

• Auto-discovery — automaticky detekuje nové služby z Dockeru, Kubernetes, Consul…
• Let's Encrypt integrácia — automatické HTTPS certifikáty bez manuálnej konfigurácie
• Middlewares — reťazenie transformácií (headers, rate limiting, auth, redirect…)
• Dashboard — vstavaný web UI pre monitorovanie

Docker Compose príklad

version: "3.8"

services:
  traefik:
    image: traefik:v3.0
    command:
      - "--api.dashboard=true"
      - "--providers.docker=true"
      - "--providers.docker.exposedByDefault=false"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.websecure.address=:443"
      - "--certificatesresolvers.letsencrypt.acme.email=admin@example.com"
      - "--certificatesresolvers.letsencrypt.acme.storage=/letsencrypt/acme.json"
      - "--certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web"
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - letsencrypt:/letsencrypt

  app:
    image: myapp:latest
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.app.rule=Host(`app.example.com`)"
      - "traefik.http.routers.app.entrypoints=websecure"
      - "traefik.http.routers.app.tls.certresolver=letsencrypt"

volumes:
  letsencrypt:

Middleware — rate limiting

labels:
  - "traefik.http.middlewares.rate-limit.ratelimit.average=100"
  - "traefik.http.middlewares.rate-limit.ratelimit.burst=50"
  - "traefik.http.routers.app.middlewares=rate-limit"

---

Caddy

Caddy je web server s automatic HTTPS by default — stačí špecifikovať doménu a Caddy sám získa a obnoví certifikát.

Caddyfile

app.example.com {
    reverse_proxy app:8080
}

api.example.com {
    reverse_proxy api:3000

    rate_limit {
        zone dynamic {
            key    {remote_host}
            events 100
            window 1m
        }
    }
}

Prečo Caddy?

• Zero-config HTTPS — automatický Let's Encrypt + OCSP stapling
• Jednoduchá konfigurácia — Caddyfile je čitateľný aj pre začiatočníkov
• Jeden binárka — Go binary, žiadne závislosti
• HTTP/3 podpora — natívne

Docker Compose

services:
  caddy:
    image: caddy:2
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile
      - caddy_data:/data
      - caddy_config:/config

volumes:
  caddy_data:
  caddy_config:

---

Envoy

Envoy je high-performance proxy pôvodne vyvinutý v Lyft. Je základom pre service mesh riešenia (Istio, Linkerd).

Kľúčové koncepty

• xDS API (x Discovery Service) — dynamická konfigurácia cez API:
  • LDS — Listener Discovery Service
  • RDS — Route Discovery Service
  • CDS — Cluster Discovery Service
  • EDS — Endpoint Discovery Service
• L4/L7 proxy — funguje na transportnej aj aplikačnej vrstve
• Observability — distributed tracing, metriky, štruktúrované logy natívne
• gRPC natívne — plná podpora HTTP/2 a gRPC

Envoy konfigurácia (static)

static_resources:
  listeners:
    - name: listener_0
      address:
        socket_address:
          address: 0.0.0.0
          port_value: 8080
      filter_chains:
        - filters:
            - name: envoy.filters.network.http_connection_manager
              typed_config:
                "@type": type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager
                stat_prefix: ingress_http
                route_config:
                  name: local_route
                  virtual_hosts:
                    - name: backend
                      domains: ["*"]
                      routes:
                        - match:
                            prefix: "/"
                          route:
                            cluster: app_cluster
                http_filters:
                  - name: envoy.filters.http.router
                    typed_config:
                      "@type": type.googleapis.com/envoy.extensions.filters.http.router.v3.Router

  clusters:
    - name: app_cluster
      type: STRICT_DNS
      load_assignment:
        cluster_name: app_cluster
        endpoints:
          - lb_endpoints:
              - endpoint:
                  address:
                    socket_address:
                      address: app
                      port_value: 8080

Kedy Envoy?

• Microservices s service mesh (Istio)
• Potrebuješ advanced load balancing (circuit breaking, outlier detection, retries)
• gRPC-heavy architektúra
• Dynamická konfigurácia cez control plane

---

API Gateway

API Gateway je špecializovaný reverse proxy pre API management. Okrem smerovania requestov poskytuje:

• Autentifikácia & autorizácia (OAuth2, JWT, API keys)
• Rate limiting — ochrana pred abuse
• Request/response transformácie
• API versioning
• Developer portal & dokumentácia
• Analytics & monitoring

Kong

Kong — open-source API gateway postavený na Nginx/OpenResty.

# kong.yml (declarative config)
services:
  - name: user-service
    url: http://user-api:3000
    routes:
      - name: user-route
        paths:
          - /api/users
    plugins:
      - name: rate-limiting
        config:
          minute: 100
          policy: local
      - name: jwt
      - name: cors

Apache APISIX

APISIX — vysokovýkonný API gateway s plugin architektúrou.

routes:
  - uri: /api/*
    upstream:
      type: roundrobin
      nodes:
        "backend:8080": 1
    plugins:
      limit-count:
        count: 100
        time_window: 60
        key: remote_addr
      jwt-auth: {}

API Gateway vs Reverse Proxy

Vlastnosť	Reverse Proxy	API Gateway
Routing	Host/path based	+ API versioning, header-based
Auth	Basic (ak vôbec)	OAuth2, JWT, API keys, OIDC
Rate limiting	Jednoduchý	Per-user, per-API, tiered
Transformácie	Minimálne	Request/response rewriting
Developer experience	Žiadna	Portal, dokumentácia, SDK
Analytika	Access logy	API metriky, usage dashboards

---

Rate Limiting

Rate limiting chráni služby pred preťažením a abuse.

Stratégie

Algoritmus	Popis	Výhoda
Fixed Window	Counter za fixný interval (napr. 100 req/min)	Jednoduché
Sliding Window	Vážený priemer dvoch okien	Presnejšie
Token Bucket	Tokeny sa dopĺňajú konštantne, burst povolený	Flexibilné
Leaky Bucket	Requesty sa spracovávajú konštantnou rýchlosťou	Hladký traffic

Príklad — Nginx rate limiting

http {
    limit_req_zone $binary_remote_addr zone=api:10m rate=10r/s;

    server {
        location /api/ {
            limit_req zone=api burst=20 nodelay;
            proxy_pass http://backend;
        }
    }
}

---

Auth Offloading

Auth offloading presúva autentifikáciu z aplikácie na reverse proxy / API gateway.

Výhody

• Centralizácia — auth logika na jednom mieste, nie v každej službe
• Konzistentnosť — rovnaké pravidlá pre všetky služby
• Jednoduchší backend — služba dostane už overený request s user info v headeroch
• Zmena auth — stačí zmeniť konfiguráciu proxy, nie kód aplikácie

Traefik + ForwardAuth

labels:
  - "traefik.http.middlewares.auth.forwardauth.address=http://auth-service:4181"
  - "traefik.http.middlewares.auth.forwardauth.authResponseHeaders=X-User-Id,X-User-Role"
  - "traefik.http.routers.app.middlewares=auth"

Flow

Klient → Reverse Proxy → Auth Service (overenie)
                        ↓ (OK + headers)
                   Backend Service (dostane X-User-Id, X-User-Role)

---

Porovnávacia tabuľka

Vlastnosť	Nginx	Traefik	Caddy	Envoy	Kong	APISIX
Typ	Web server + RP	RP + LB	Web server + RP	L4/L7 proxy	API Gateway	API Gateway
Auto HTTPS	Manuálne/certbot	✅ Let's Encrypt	✅ Automatické	Manuálne	Manuálne	Manuálne
Auto-discovery	❌	✅ Docker/K8s	❌	✅ xDS API	❌	❌
Konfigurácia	Statické súbory	Labels/YAML	Caddyfile	YAML/xDS	YAML/Admin API	YAML/Admin API
Service mesh	❌	❌	❌	✅ (Istio sidecar)	❌	❌
Plugins	Moduly (C)	Middlewares	Moduly (Go)	Filtre (C++)	Plugins (Lua)	Plugins (Lua/Wasm)
gRPC	Čiastočne	✅	✅	✅ Natívne	✅	✅
Rate limiting	Vstavaný	Middleware	Plugin	Filter	Plugin	Plugin
Auth	Basic/JWT modul	ForwardAuth	–	ext_authz	OAuth2/JWT/OIDC	JWT/OIDC
Dashboard	❌ (tretie strany)	✅ Vstavaný	❌	❌ (tretie strany)	✅ Kong Manager	✅ Dashboard
Výkon	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐⭐
Krivka učenia	Stredná	Nízka	Veľmi nízka	Vysoká	Stredná	Stredná

---

Best Practices

1. Vždy používaj HTTPS

# Caddy — automaticky
example.com {
    reverse_proxy backend:8080
}

# Traefik — certresolver
- "traefik.http.routers.app.tls.certresolver=letsencrypt"

2. Nastavuj správne headers

proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;

3. Health checks

Každý reverse proxy by mal kontrolovať stav backendov:

# Traefik
- "traefik.http.services.app.loadbalancer.healthcheck.path=/health"
- "traefik.http.services.app.loadbalancer.healthcheck.interval=10s"

4. Timeouty a circuit breaking

# Nginx
proxy_connect_timeout 5s;
proxy_read_timeout 30s;
proxy_send_timeout 30s;

5. Rate limiting na edge

Vždy limituj na úrovni reverse proxy, nie len v aplikácii. Dvojitá ochrana je ideálna.

6. Centralizované logovanie

# Nginx — JSON access log
log_format json_combined escape=json
  '{"time":"$time_iso8601","remote_addr":"$remote_addr",'
   '"method":"$request_method","uri":"$request_uri",'
   '"status":$status,"body_bytes_sent":$body_bytes_sent,'
   '"upstream_response_time":"$upstream_response_time"}';

7. Oddeľ statický obsah od API

location /static/ {
    root /var/www;
    expires 30d;
    add_header Cache-Control "public, immutable";
}

location /api/ {
    proxy_pass http://backend;
}

8. Kedy čo použiť?

• Jednoduchý web/app → Nginx alebo Caddy
• Docker/Kubernetes → Traefik (auto-discovery)
• Microservices + service mesh → Envoy (+ Istio)
• API management → Kong alebo APISIX
• Rýchly prototyp s HTTPS → Caddy

---

Zhrnutie

Reverse proxy je základný stavebný blok modernej infraštruktúry. Rozhodnutie medzi Nginx, Traefik, Caddy, Envoy či API gateway závisí od komplexnosti projektu:

• Malý projekt — Caddy alebo Nginx stačia
• Kontajnery — Traefik s auto-discovery šetrí čas
• Microservices — Envoy + service mesh pre pokročilú kontrolu
• API-first — Kong/APISIX pre plný API lifecycle management

Kľúčové je mať vždy HTTPS, správne headers, health checks a rate limiting — bez ohľadu na zvolený nástroj.