Plagines და middleware API Gateway

1) რატომ გვჭირდება მოდულები და middleware

• უსაფრთხოების სტანდარტიზაცია (authN/authZ, WAF, CORS),
• იცავს სტაბილურობას (rate limit, circuit breaker, retry-policies),
• აკონტროლებს კონტრაქტს (სქემების შესაბამისობა, ტრანსფორმაცია),
• იძლევა დაკვირვებას (მეტრიკა, ლოგები, ტრეკერი),
• ამცირებს ღირებულებას (ქეშირება, დედუპლიკაცია, კანარის წესები).

გასაღები: მინიმალური ლატენტობა და გამოყენების მკაფიო თანმიმდევრობა.

2) დანამატების კლასები და რას აკეთებენ ისინი

1. იდენტიფიკაცია/ავთენტიფიკაცია

JWT/JWKS პროვაიდერები, OAuth2/OIDC, API გასაღებები, mTLS (client cert).
HMAC ხელმოწერები (ვებჰუკი/პარტნიორები), DPOP/PoP ზღვარზე.

2. ავტორიზაცია

RBAC/ABAC/OPA/Cedar (PDP) ადგილობრივი გადაწყვეტილებების ქეშით.
BOLA სახელმძღვანელო: 'tenant '/' owner' შემოწმება სათაურებში/კონტექსტში.

3. ქსელური და პროტოკოლის დაცვა

WAF (OWASP CRS), ანტიბოტი (rate/behavioral), Geo/IP/ASN ფილტრები, TLS პროფილები.
CORS, CSP სათაურები, Fetch-Metadata ფილტრები, CORP/COOP/COEP.

4. სტაბილურობა

Rate limiting (token bucket/GCRA), კვოტები და კონკურენტუნარიანობა.
Circuit breaker, Timauts, adaptive concurrence, load shedding.
Retry-policy ერთად per-try timeout და jitter.

5. ტრანსფორმაციები და შესაბამისობა

ბილიკების/სათაურების აღწერილობა, ბოდიში, JSON/XML, gRPC და HTTP.
სქემების შესაბამისობა (OpenAPI/JSON Schema/Protobuf), ID- ის ნორმალიზაცია.

6. ქეშირება და შესრულება

Response/fragment cache, ETag/If-None-Match, კომპრესია, brotli.
რეკონსტრუქცია იგივე გასაღებებისთვის.

7. დაკვირვება და აუდიტი

მეტრიკა RED/USE, გადაწყვეტილებების ლოგიკა (429/403/5xx), ტრეკერი (W3C Trace-Context/OpenTelemetry), სამფეხა (tail/adaptive).
პოლიტიკოსის უსაფრთხოების სათაურებისა და ვერსიების აუდიტი.

8. სასიცოცხლო ციკლი და ოპერაცია

Canary/blue-green, feature-flags, shadow გადაწყვეტილებები (ლოგიკური, არ გამოყენება), ვერსიების მიგრაცია.

3) გამოყენების წესი (რეკომენდებული ჯაჭვი)

[Ingress TLS]
→ Early-Deny (ASN/Geo, IP allow/deny)
→ mTLS / Client Cert Auth
→ JWT/OAuth2 AuthN (JWKS cache)
→ OPA/ABAC AuthZ (solution cache)
→ Rate Limit / Concurrency
→ Circuit / Timeout / Retries (пер-try)
→ Schema Validation (request)
→ Transform (headers/path/body) / CORS
→ Caching (lookup)
→ Upstream Proxy (app)
← Caching (store) / Compression
← Response Transform / Schema Validation (response)
← Logging / Tracing / Metrics / Security Headers

პრინციპი: ადრე - იაფი/საბედისწერო (deny, auth, limites), მოგვიანებით - „კოსმეტიკა“ (ტრანსფორმაციები, ქეში).

4) პროდუქტიულობა და კარდინალობა

დაიცავით O (1) ნაბიჯები გარე მოთხოვნების გარეშე ცხელ გზაზე.
მოდულების ყველა „გარე ზარი“ (PDP/JWKS) - მოკლე TTL და asynchronous refresh მეშვეობით.
ეტიკეტები/ეტიკეტები მეტრიკისთვის - შეზღუდული კარდინალობა ('tenant', 'plan', 'route', მაგრამ არა 'user _ id').
„მძიმე“ მოდულები (WAF, body-transform) - შეიტანეთ შერჩევითი per-route.

5) კონფიგურაციის მაგალითები

5. 1 Envoy: JWT + RateLimit + OPA + Retries (ფსევდო)

yaml static_resources:
listeners:
- name: public_listener filter_chains:
- filters:
- name: envoy. filters. network. http_connection_manager typed_config:
route_config:
name: main virtual_hosts:
- name: api domains: ["api. example. com"]
routes:
- match: { prefix: "/v1/payments" }
route:
cluster: payments timeout: 350ms retry_policy:
retry_on: connect-failure,reset,5xx,gateways num_retries: 1 per_try_timeout: 200ms http_filters:
- name: envoy. filters. http. jwt_authn typed_config:
providers:
oidc:
issuer: https://auth. example. com/
remote_jwks:
http_uri: { uri: https://auth. example. com/.well-known/jwks. json, cluster: jwks, timeout: 2s }
cache_duration: 300s forward: true
- name: envoy. filters. http. ext_authz  # OPA/Cedar PDP typed_config:
http_service:
server_uri: { uri: http://opa:8181, cluster: opa, timeout: 50ms }
authorization_request: { allowed_headers: { patterns: [{ exact: "authorization" }, { exact: "x-tenant" }] } }
- name: envoy. filters. http. ratelimit typed_config:
domain: public-api rate_limit_service:
grpc_service: { envoy_grpc: { cluster_name: rl } }
- name: envoy. filters. http. router

5. 2 NGINX/OpenResty: HMAC + Lua + Redis (ფსევდო)

nginx lua_shared_dict jwks 10m;
lua_shared_dict limits 10m;

server {
listen 443 ssl http2;

Early deny by ASN/Geo if ($bad_asn) { return 403; }

HMAC signature check (webhooks/partners)
set_by_lua_block $sig_ok {
return verify_hmac_signature(ngx. var. http_x_signature, ngx. var. request_time, ngx. var. request_body)
}
if ($sig_ok = 0) { return 401; }

Token bucket in Redis access_by_lua_block {
local key = ngx. var. binary_remote_addr.. ":".. ngx. var. request_uri local allowed, retry_after = ratelimit_allow(key, 50, 100)
if not allowed then ngx. header["Retry-After"] = retry_after return ngx. exit(429)
end
}

proxy_read_timeout 300ms;
proxy_connect_timeout 100ms;
proxy_pass http://app_backend;
}

5. 3 კონგი: მარშრუტის გასწვრივ მოდულები

yaml services:
- name: payments url: http://payments:8080 routes:
- service: payments paths: ["/v1/payments"]
plugins:
- name: jwt config: { key_claim_name: kid, secret_is_base64: false, run_on_preflight: false }
- name: opa config: { server_url: "http://opa:8181/v1/data/authz/allow", timeout: 50 }
- name: rate-limiting config: { second: 50, policy: redis, redis_host: redis, fault_tolerant: true }
- name: correlation-id config: { header_name: "traceparent" }
- name: response-transformer config: { add: { headers: ["Strict-Transport-Security:max-age=31536000"] } }

5. 4 Apache APISIX: JWT + Limit + Proxy-Mirror (shadow)

yaml routes:
- uri: /v1/wallets/
plugins:
openid-connect:
client_id: wallet discovery: "https://auth. example. com/.well-known/openid-configuration"
scope: "openid"
limit-count:
count: 100 time_window: 60 key_type: "var"
key: "remote_addr"
proxy-mirror:          # shadow traffic host: "http://shadow-backend:8080"
upstream_id: 1

5. 5 Traefik: Middleware ჯაჭვი

yaml http:
middlewares:
hsts-headers:
headers:
stsSeconds: 31536000 stsIncludeSubdomains: true ratelimit:
rateLimit:
average: 50 burst: 100 routers:
api:
rule: "Host(`api. example. com`) && PathPrefix(`/v1`)"
service: app middlewares:
- hsts-headers
- ratelimit

6) პოლიტიკოსის მრავალფეროვნება და ვერსიები

მარშრუტიზაციის გასაღები: '{tenant, plan, region, route, ვერსია'.
პლაგინები კითხულობენ 'tenant- ს mTLS SAN/JWT სტიგმისგან/სათაურიდან და იყენებენ ლიმიტის/კვოტების/წესების პირველ ჩრდილს.
ვერსია პოლიტიკა ('policy _ version'), ჩაატარეთ changelog და კანარის rollout.

7) ტესტირება და rollout

გამოშვებამდე

ჯაჭვის საკონტრაქტო ტესტები (ცხრილი „ზოგჯერ“): auth-deny, auth-allow, rate-429, schema-422.
დატვირთვა: bursts × 10, გრძელი პლატო, „ბინძური“ ნიმუშები (slow-POST).
ქაოსი: PDP/JWKS/Redis დეგრადაცია - უნდა იყოს fail-closed/დეგრადაცია მინიმუმამდე უსაფრთხო.

გამოშვება

'Report-Only '/shadow-mode (გადაწყვეტილების გარეშე გამოყენების გარეშე).
Canary 1-5% ტრაფიკი + მეტრიკის შედარება (p95/p99, 4xx/5xx/429).
ავტომატური rollback SLO/ალერტებისთვის.

8) დაკვირვება და მეტრიკა

• `http_requests_total{route,tenant,plan,status}`
• `request_duration_seconds_bucket{route}` (p95/p99)
• `rate_limited_total{policy}`, `retry_total{reason}`, `circuit_state`
• `authn_fail_total{reason}`, `authz_denied_total{action}`
• `schema_validation_fail_total{route}`
• traces: spans per filter, ატრიბუტები 'policy _ version', 'tenant', 'limit _ key'.
• Logs (მოდულირებული): deny/429/5xx გადაწყვეტილებები მიზეზებით და 'trace _ id'.
• დაშბორდები: Exec country, per-route, per-tenant, „ცხელი“ პოლიტიკოსები.

9) უსაფრთხოება და ექსპლუატაცია

ყველა საიდუმლოება (HMAC, JWKS კერძო, API გასაღებები) - KMS/Vault- ში, არა კონფისკაციის ფაილებში.
მგრძნობიარე მარშრუტებისთვის deny-by-default პოლიტიკა.
მოკლე TTL JWKS/PDP ქეში, ასინქრონული განახლებები backoff- დან.
ტრანსფორმაციის სქემების მიგრაცია - versioned; „გატეხილი“ - ორმაგი ტალღის საშუალებით.
შეზღუდეთ body-size (DoS) და JSON სიღრმე.

10) ანტიპატერები

უნივერსალური „ჩართულია“ დანამატების ნაკრები თითოეულ მარშრუტზე - დამატებითი მილიწამები და ანგარიშები.
მოდულების გარე დამოკიდებულება ქეში/ტაიმაუტის გარეშე არის კასკადის ტაიმაუტები.
ფილტრების რიგის არარსებობა: ჯერ ტრანსფორმაცია/ლოგიკა, შემდეგ ლიმიტები არასწორია.
ეტიკეტების მაღალი კარდინალობა (raw 'user _ id '/' ip').
AuthN/authZ- ის შერევა ტრანსფორმაციის შაბლონებში (გამოუსწორებელი გადაწყვეტილებები ლუაში/ჯინჯაში).
საიდუმლოებების/ნიშნების ლოგიკა.
ერთი გლობალური Redis/მტევანი ყველა ლიმიტის გარეშე შარდვის/ნაკრძალის გარეშე.

11) iGaming/ფინანსების სპეციფიკა

Per tenant/per იურისდიქცია წესი: KYC/AML, სანქციები, პასუხისმგებელი გადახდების შეზღუდვები.
მკაცრი პოლიტიკოსები საგადახდო მარშრუტებისთვის: მოკლე ტაიმაუტები, ერთი გამეორება, Idempotency-Key.
პერიმეტრების დაყოფა PSP/KYC SDK- სთვის (ცალკეული დომენები/დანამატების ჯაჭვები).
უცვლელი გადაწყვეტილებების ლოგოების აუდიტი (დასკვნები, დაბლოკვა, სანქციების უარყოფა).

12) მზადყოფნის სიის სია

• განისაზღვრება ფილტრების რიგი: authN-authZ-limits-circuit/timeout (timeout) schema-transform-cache.
• დანამატების პერ-მარშრუტის ნაკრები; მძიმე - მხოლოდ იქ, სადაც საჭიროა.
• JWKS/PDP მოკლე TTL და ქეში; ტაიმაუტები და fallback სტრატეგიები.
• Rate/Quta/Concurrency - შექმნილია გასაღებები, საცავის შარდვა.
• მეტრიკის ნაკრები RED/USE, OTel ტრეკერი, tail/adaptive ნაკრები.
• Canary + shadow რეჟიმი, auto-rollback SLO.
• საიდუმლოებები KMS/Vault- ში; კონფისკაციები - ვერსირებული, მიგრაციით.
• body/headers limites; დაცვა oversize/slow-POST.
• დოკუმენტაცია მომხმარებლებისთვის: კოდი 401/403/409/422/429/5xx, 'Retry-After', სათაურების მაგალითები.

13) TL; DR

ააშენეთ ჯაჭვი „ადრეული უარი - ავთენტიფიკაცია/ავტორიზაცია - ლიმიტები/სტაბილურობა - გარდაქმნა/ქეში ტელემეტრია“. ჩართეთ მხოლოდ აუცილებელი per-route მოდულები, დააკვირდით გარე გადაწყვეტილებებს (JWKS/PDP), დააყენეთ ტაიმაუტები და რეპეტიციის პოლიტიკა, აკონტროლეთ მეტრიკის კარდინალობა. გამოუშვეთ shadow/canary, შეინარჩუნეთ საიდუმლოებები KMS/Vault- ში და გაზომეთ თითოეული დანამატის გავლენა p95/p99.