Container e orchestrazione

1) Perché contenitori e k8s nel iGaming

Velocità di modifica: immagini prevedibili, una sola pipline CI/CD.
Stabilità: riavvio automatico, skale orizzontale, self-hiling.
Isolamento dati/regioni - Neimspace/cluster sotto giurisdizione.
Standard operativi: regole delle risorse, un unico login/metriche/trailer.

Quando non è necessario: team piccolo, 2-3 servizi, release rare - inizia con PaaS/monolite modulare.

2) Immagini e registri (OCI/Docker)

2. 1 Assemblaggio di immagini - Principi

Multi-stage - Bild Rant (sottili immagini di base «distroless», «alpine» con cautela).
Ripetibilità: fissa le versioni/sha256, 'COPY --chown', '--mount = type = cache'.
SBOM e firma: «cosign sign/verify», «slsa provenance», criterio «solo firmati».
Slim-down - Rimuovi il dev-tools, abilita USER nonroot, readOnlyRootFilesystem.

Esempio Dockerfile (Node. js)

dockerfile build
FROM node:22-bookworm AS build
WORKDIR /app
COPY package. json./
RUN npm ci --omit=dev
COPY..
RUN npm run build

runtime (distroless)
FROM gcr. io/distroless/nodejs22
WORKDIR /srv
COPY --from=build /app/dist./dist
COPY --from=build /app/node_modules./node_modules
USER 10001
ENV NODE_ENV=production
CMD ["dist/server. js"]

2. 2 Registri e regole

Private registry + geo repliche (EU/NA) per ridurre la latitanza e la conformità GDPR.
Restituzione/immutability - Impedisce la sovrascrizione dei tag, riscaldando la cache nel PoP.
Admision Control: solo immagini firmate/scan-pulite (cosign + Trivy/Grype).

3) Orchestrazione: Kubernets base

3. 1 Primitivi

Deployment - servizi stateless (lobby, API).
StatefulSet - portafoglio/coda/archivio (nome fix, volumi stabili).
DaemonSet - Agenti dei reparti/componenti di rete.
Job/CronJob - migrazioni, report, ETL.

3. 2 Risorse e QoS

Indicare «richiesti/limits» (CPU/Memory) le classi di e la pianificazione prevedibile.
Burstable solo dove è consapevole; critico - Guaranteed.
I POD di pagamento critici devono essere inseriti sui pool dedicati (taints/tolerations, node-affinity).

3. 3 Sostenibilità e rilascio

Propes: «startup», «liveness», «readansa» (con timeout e periodi).
Rollout: `maxSurge/maxUnavailable`, canary через вес в Ingress/Gateway/Service Mesh.
PDB (PodDisruptionBudget) + graceful shutdown (PreStop hook, `terminationGracePeriodSeconds`).
Drain/cordon nod agli upgrade.

4) Rete: CNI, servizi, traffico in entrata

4. 1 livello CNI

Calico/Cilium/Weave - Regole di rete ( ) per le prestazioni.
Regole interistituzionali: egress/ingress minimo necessario.

4. 2 Servizi e accesso

Service: `ClusterIP/NodePort/LoadBalancer`.
Ingress o Gateway API per L7: itinerari su strada/heder/host, TLS, pesi canari.
mTLS all'interno del cluster tramite servizio-mesh (Istio/Linkerd) - intercettazione TLS e criteri.

Esempio HTTPRoute (Gateway API, peso canarino)

yaml apiVersion: gateway. networking. k8s. io/v1 kind: HTTPRoute spec:
rules:
- backendRefs:
- name: lobby-v1 weight: 90 port: 8080
- name: lobby-v2 weight: 10 port: 8080

5) Memorizzazione: CSI/PV/PVC, classi di volumi

Driver CSI del provider (EBS/PD/Premium SSD) + 'storageClass' con impostazioni di prestazioni.
RWX per sharing (NFS/FSx/Filestore) - Attenta ai blocchi.
Backup/restore: Velero/Kasten, snapshot periodici, controllo di ripristino.
Crittografia a livello di disco e a livello di database (KMS).

6) Ridimensionamento automatico: HPA/VPA/KEDA

HPA (CPU/RAM/Kastom Metric - RPS, p95): per API/lobby.
VPA (raccomandazioni/auto) - per worker stabili.
KEDA (event-driven) - Scala sulle code Kafka/SQS/Redis, Cron-Shedula.
Cluster Autocaler - nodi di carico i pool warm per picchi (tornei/striam).

7) Servizio-mesh (per necessità)

mTLS/criteri di servis↔servis, autorizzazione per identità (SPIFFE).
Circuito-breaker/timeout/retry, outler-ejection, mirroring (shadow).
Corpo-metria della scatola: metriche e piste unificate.
Utilizzare dove è necessario un gestione del traffico sottile (pagamenti, provider di giochi).

8) Sicurezza: segreti, politiche, conformità

Secret: manager esterno (AWS/GCP/Azure KMS, Esternal Secret), rotazione.
Policy-as-code: OPA/Gatekeeper/Kyverno - Proibizione: latest, root-USER, hostPath, privilegi.
Escalation dei diritti: Namespades + RBAC, Divisione dei Diritti/Stage/Prod, Controllo.
Immagine Sicurezza: scan in CI/CD, firma (cosign), admissione per firma.
mTLS e JWT all'interno (mesh), WAF/Rate-limit all'ingresso (Ingress/Gateway).

9) Osservabilità e SLO

Metrics: Prometheus/OpenTelemetry, p50/95/99, 4xx/5xx, saturations.
Logs: struttura JSON → Loki/Elastic, occultamento PII/PAN/BAN.
Traces: OTLP → Tempo/Jaeger; 'trace _ id' viene dal gateway.
Ad esempio, "Deposit p95" 300 ms, success "98. 5% ', alert burn-rate.
Proattività: dashboard per-service/per-route, watchdog per DLQ e code.

10) CI/CD, Helm, GitOps

CI: Linter, test (unit/contract/integration), SAST/DAST, SBOM.
Helm/Jsonnet/Kustomize: elenchi dichiarativi con'values'sull'ambiente.
GitOps (ArgoCD/Flux) - single-source-of-truth, rivisitazione di manifesti, rollback.
Strategie: blue-green, canary, shadow; migrazione di diagrammi - expand-and-contract.

Sezione values. yaml (risorse/campioni)

yaml resources:
requests: { cpu: "200m", memory: "256Mi" }
limits:  { cpu: "500m", memory: "512Mi" }
livenessProbe: { httpGet: { path: /healthz, port: 8080 }, initialDelaySeconds: 20, periodSeconds: 10 }
readinessProbe: { httpGet: { path: /readyz, port: 8080 }, initialDelaySeconds: 5, periodSeconds: 5 }

11) Pianificazione e isolamento

NodePools Separare i pagamenti/portafogli per i nodi «a basso volume» con il disco veloce.
Thants/Tolerations - pool protetti per carichi critici.
(Anti-) Affinity - Smussare le repliche per zona/nodo (HA).
La difesa contro i Neimspace è contro i vicini rumorosi.

12) Multiclaster, regione multi, DR

Divisioni giurisdizionali: cluster EU/LatAm/ROW; I dati dei residenti sono locali.
GSLB/Anycast in entrata, per-osservabilità e alert.

• Warm standby (raccomandato) - Replica sinh di database critici, controlli periodici failover.
• Active per la lettura/routing regionale.
• Backup: backap (Velero), rehearsal recovery.

13) iGaming-specificità

Pagamenti/portafogli: p95, 300-500 ms, pool separati e PDB rigorosi; canary 1→5→10%.
Lobby/contenuti: HPA aggressivo RPS/INP, immagini riscaldate/kash vettoriale.
Giochi Live/striam: LC/minimo retraes, lunghi timeout socket, sticky di connessione.
Compilation: Neimspace con Policy rigido, segreti tramite KMS, controllo delle modifiche ai comunicati Helm.
Gioco responsabile: Servizio limiti/blocchi - Traffico prioritario (fail-open/close per criteri).

14) Assegno fogli

Prima di inviare il servizio

• Immagine multi-stage, USER nonroot, firma cosign, scansione completata.
• Richiesti/limits, propes, uv/secret dal gestore esterno.
• PDB, `maxUnavailable ≤ 1`, graceful shutdown.
• SLO/alert, traccia dal gateway al database.
• Schema canario e piano di ripristino.
• I criteri OPA/Kyverno passano (no root, no hostPath, no: latest).

Cluster/piattaforma

• CNI e NetworkPolicy sono inclusi; mTLS dove vuoi.
• Le classi/righe, il backap/restore sono stati convalidati.
• HPA/VPA/KEDA configurati; Cluster Autoscaler и warm-pool.
• RBAC minimo, controllo abilitato, segreti KMS.
• GitOps: elenchi/manifesti nel repository, la panoramica PR è obbligatoria.

15) Anti-pattern

Immagini latest, utente root, livelli di base «spessi».
No: «richiesti/limits».
Readava= liveness (restart floppy).
Miscelare statful/stateless su un unico proiettile senza taints.
Migrazione di diagrammi in testa senza expand-and-contract.
L'unico cluster per tutti i mercati senza isolamento regionale.
Loghi PII/PAN, segreti nel ConfigMap.
La mancanza di PDB/Drenage è una scarica nei picchi e negli upgrade.

16) Metriche di piattaforma (minimo)

Кластер: CPU/mem requests vs allocatable, pod-churn, node-pressure.
Rete: p95 per-route, 4xx/5xx, reset/timeout, retry-rate, mTLS errori.
IOPS/latency, queue-depth, errori CSI.
Scale automatico: HPA decisioni, CA events, tempo di riscaldamento.
Business: TTP, TtW, FTD-success, rifiutato pagamento del provider.
Sicurezza: non conformità OPA, immagini non firmate, segreti scaduti.

17) Esempi di manifesti

Deployment (API, label canario)

yaml apiVersion: apps/v1 kind: Deployment metadata: { name: wallet-api, labels: { app: wallet, track: stable } }
spec:
replicas: 4 strategy: { type: RollingUpdate, rollingUpdate: { maxSurge: 1, maxUnavailable: 1 } }
selector: { matchLabels: { app: wallet, track: stable } }
template:
metadata: { labels: { app: wallet, track: stable } }
spec:
serviceAccountName: wallet-sa containers:
- name: api image: registry. local/wallet/api@sha256:...
ports: [{ containerPort: 8080 }]
resources:
requests: { cpu: "250m", memory: "256Mi" }
limits:  { cpu: "500m", memory: "512Mi" }
readinessProbe: { httpGet: { path: /readyz, port: 8080 }, periodSeconds: 5 }
livenessProbe: { httpGet: { path: /healthz, port: 8080 }, initialDelaySeconds: 20 }
securityContext:
runAsNonRoot: true readOnlyRootFilesystem: true

PDB (portafoglio)

yaml apiVersion: policy/v1 kind: PodDisruptionBudget spec:
minAvailable: 3 selector: { matchLabels: { app: wallet } }

HPA (RPS tramite custom-metrics)

yaml apiVersion: autoscaling/v2 kind: HorizontalPodAutoscaler spec:
minReplicas: 4 maxReplicas: 40 metrics:
- type: Pods pods:
metric:
name: http_requests_per_second target:
type: AverageValue averageValue: "50"

18) Processo di implementazione (spring)

1. Assemblaggio e protezione degli aspetti: multi-stage, SBOM, firme, criterio di admissione.
2. Piattaforma base k8s: CNI, Ingress/Gateway, monitoraggio/logi/roulotte, StorageClass.
3. CI/CD e GitOps: elenchi, ambienti, canary/rollback, migrazioni di diagrammi.
4. Scale e stabilità: HPA/VPA/KEDA, PDB, node pool, taints/affinity, DR-piano.

Scorciatoia finale

Immagini sottili, firmate + criteri di tolleranza = base di sicurezza.
Campioni, risorse, PDB, drain = resilienza dei rilasci.
HPA/VPA/KEDA + sintonizzatore di pool = zoom senza «errori».
Gateway/Ingress + mTLS/OPA = perimetro sicuro e collegamento interno.
Osservabilità + SLO + GitOps = Modifiche gestite.
Isolamento regionale e DR = completamento e tolleranza.