Conteneurisation et orchestration

1) Pourquoi les conteneurs et k8s dans iGaming

Taux de changement : images prévisibles, une seule pipline CI/CD.
Durabilité : auto-redémarrage, skale horizontal, self-heling.
Isolation des données/régions : neimspace/clusters relevant de la juridiction.
Normes opérationnelles : politiques de ressources, journal unique/métriques/tracés.

Quand vous n'avez pas besoin : petite équipe, 2-3 services, des sorties rares - démarrez avec PaaS/monolite modulaire.

2) Images et registres (OCI/Docker)

2. 1 Assemblage d'images - principes

Multi-stage : billd → rantime (minces images de base de 'distroless', 'alpine' avec soin).
Répétabilité : fixez les versions/sha256, 'COPY --chown', '--mount = type = cache' dans BuildKit.
SBOM et signature : 'cosign ign/verify', 'slsa provenance', la politique 'seulement signée'.
Slim-down : supprimer les dev-tools, inclure 'USER nonroot', 'readOnlyRootFilesystem'.

Exemple 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 Registres et politiques

Enregistrement privé + répliques géo (EU/NA) pour réduire la latence et la conformité au RGPD.
Retraite/immutabilité : interdiction de réécrire les tags en chauffant le cache dans le PoP.
Contrôle d'admission : uniquement les images signées/scan-clean (cosign + Trivy/Grype).

3) Orchestration : modèles de base de Kubernetes

3. 1 Primitifs

Deployment - Steless-services (lobby, API).
StatefulSet : Portefeuille/file d'attente/stockage (nom fixe, volumes stables).
DaemonSet - Agents logs/composants réseau.
Job/CronJob - migrations, rapports, ETL.

3. 2 Ressources et QoS

Spécifiez les « demandes/limites » (CPU/Mémoire) → les classes QoS et la planification prévisible.
Burstable seulement là où c'est conscient ; le critique est Guaranteed.
Placer les POD de paiement critiques sur des pools dédiés (taints/tolerations, node-affinity).

3. 3 Durabilité et releases

Probes : 'startup', 'liveness', 'read....' (avec des temps et des périodes).
Rollout: `maxSurge/maxUnavailable`, canary через вес в Ingress/Gateway/Service Mesh.
PDB (PodDisruptionBudget) + graceful shutdown (PreStop hook, `terminationGracePeriodSeconds`).
Drain/cordon nod dans les mises à niveau.

4) Réseau : CNI, services, trafic d'entrée

4. 1 couche CNI

Calico/Cilium/Weave est une politique de réseau (NetworkPolicy), eBPF pour la performance.
Règles inter-espace : minimum nécessaire egress/ingress.

4. 2 Services et connexion

Service: `ClusterIP/NodePort/LoadBalancer`.
API Ingress ou Gateway pour L7 : itinéraires en route/tête d'affiche/hôte, TLS, poids canaris.
mTLS à l'intérieur du cluster : via service-mesh (Istio/Linkerd) - interception TLS et politiques.

Exemple HTTPRoute (Gateway API, poids canarien)

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) Stockage : CSI/PV/PVC, classes de volumes

Pilotes CSI du fournisseur (EBS/PD/Premium SSD) + 'storageClass' avec paramètres de performance.
RWX pour la bille (NFS/FSx/Filestore) - attention avec les verrous.
Backup/restore : Velero/Kasten, snapshots périodiques, vérification de la récupération.
Cryptage : au niveau du disque et au niveau de la base de données (KMS).

6) Auto-scaling : HPA/VPA/KEDA

HPA (par CPU/RAM/mesure sur mesure - RPS, p95) : pour API/lobby.
VPA (recommandations/auto) - pour les workers stables.
KEDA (event-driven) est l'échelle des files d'attente Kafka/SQS/Redis, Cron-sheduls.
Cluster Autoscaler - nœuds de charge ; pools de warm pour les pics (tournois/strim).

7) Service-mesh (si nécessaire)

mTLS/politiques de servis↔servis, autorisation d'identité (SPIFFE).
Circuit-breaker/timeout/retry, outlier-ejection, miroir (shadow).
Télémétrie de la boîte : métriques et pistes uniques.
Utilisez là où vous avez besoin d'une gestion fine du trafic (paiements, fournisseurs de jeux).

8) Sécurité : Secrets, politique, conformité

Secrets : Gestionnaire externe (AWS/GCP/Azure KMS, Secrets externes), rotation.
Policy-as-code : OPA/Gatekeeper/Kyverno est une interdiction de ': latest', root-USER, hostPath, privilèges.
Escalade des droits : Namespaces + RBAC, division Dev/Stage/Prod, audit.
Image Security : scan dans CI/CD, signature (cosign), admission par signature.
mTLS et JWT à l'intérieur (mesh), WAF/Rate-limit à l'entrée (Ingress/Gateway).

9) Observabilité et SLO

Metrics: Prometheus/OpenTelemetry, p50/95/99, 4xx/5xx, saturations.
Logs : JSON structural → Loki/Elastic, masque PII/PAN/IBAN.
Traces : OTLP → Tempo/Jaeger ; 'trace _ id' vient de la passerelle.
SLO : par exemple, 'Deposit p95 ≤ 300 ms, success ≥ 98. 5 % ', alert burn-rate.
Proactivité : dashboards per-service/per-route, watchdog par DLQ et lagunes de file d'attente.

10) CI/CD, Helm, GitOps

CI : linters, tests (unit/contract/integration), SAST/DAST, SBOM.
Helm/Jsonnet/Kustomize : charts déclaratifs avec 'values.' sur l'environnement.
GitOps (ArgoCD/Flux) : single-source-of-truth, manifeste PR-rhubarbe, bouton rollback.
Stratégies : bleu-vert, canary, shadow ; migration des schémas - expand-and-contract.

Fragment de valeur. yaml (ressources/échantillons)

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) Planification et isolation

NodePools : séparez les paiements/portefeuille en nœuds « à faible bruit » avec un disque rapide.
Taints/Tolerations : pools protégés pour les charges critiques.
(Anti-) Affinity : Étaler les répliques par zone/nœud (HA).
ResourceQuota/LimitRange sur Niemspace - protection contre les « voisins bruyants ».

12) Multiplaster, multi-région, DR

Division par pays : clusters EU/LatAm/ROW ; les données des résidents sont locales.
GSLB/Anycast à l'entrée, per-clast-observabilité et alertes.

• Warm standby (recommandé) : réplique sinx d'OBD critiques, vérifications périodiques de l'échec.
• Active-active pour la lecture/routage régional.
• Redondance : backups (Velero), récupération rehearsal.

13) iGaming-spécificité

Paiements/portefeuille : p95 ≤ 300-500 ms, pools séparés et APB stricts ; canary 1→5→10%.
Lobby/contenu : HPA agressif par RPS/INP, images chauffées/cache vectoriel.
Live games/strim : LC/minimum de retraits, longs temps de socket, sticky par connexion.
Conformité : Neumspace avec une politique rigide, secrets via KMS, audit des modifications des versions Helm.
Jeu responsable : service de limitation/blocage - trafic prioritaire (fail-open/close par politique).

14) Chèques-feuilles

Avant de mettre en place le service

• Image multi-scène, USER nonroot, signature cosign, scan passé.
• Demandes/limites, probes, bou/secret d'un gestionnaire externe.
• PDB, `maxUnavailable ≤ 1`, graceful shutdown.
• SLO/alerte, trace de la passerelle à l'OBD.
• Plan canarien et plan de retrait.
• Les politiques OPA/Kyverno passent (no root, no hostPath, no : latest).

Cluster/plateforme

• CNI et NetworkPolicy inclus ; mTLS (mesh) où vous voulez.
• StorageClass/Retensh, backap/restore vérifié.
• Les HPA/VPA/KEDA sont personnalisés ; Cluster Autoscaler и warm-pool.
• RBAC est minime, l'audit est inclus, les secrets sont de KMS.
• GitOps : charts/manifestes dans le référentiel, l'examen des relations publiques est obligatoire.

15) Anti-modèles

Images 'latest', utilisateur root, couches de base « épaisses ».
Non « requests/limits » → euphorie/trottling.
Read....= liveness (restarts fluorescents).
Mélange Statful/Stateless sur un pool sans taints.
Migration des schémas de front sans expand-and-contract.
Le seul groupe « sur tous les marchés » sans isolement régional.
Logs avec PII/PAN, secrets dans BouMap.
L'absence d'APB/drainage → les falaises dans les pics et les mises à niveau.

16) Métriques de plateforme (minimum)

Кластер: CPU/mem requests vs allocatable, pod-churn, node-pressure.
Réseau : p95 per-route, 4xx/5xx, reset/timeout, retry-rate, erreurs mTLS.
Stockages : IOPS/latency, queue-depth, erreurs CSI.
Auto Skale : HPA decisions, CA events, temps de réchauffage.
Affaires : TTP, TtW, FTD-success, refus de paiement par fournisseur.
Sécurité : incohérences OPA, images non signées, secrets périmés.

17) Exemples de manifestes

Deployment (API, label canarien)

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 (portefeuille)

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

HPA (par RPS via 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) Processus de mise en œuvre (par sprint)

1. Assemblage et sécurité des images : multi-stage, SBOM, signatures, politique d'admission.
2. Plate-forme de base k8s : CNI, Ingress/Gateway, surveillance/logs/trajets, StorageClass.
3. CI/CD et GitOps : Cartes Helm, environnements, canary/rollback, migration de circuits.
4. Skale et durabilité : HPA/VPA/KEDA, PDB, node-pools, taints/affinity, DR-plan.

La trappe finale

Images fines et signées + politique d'admission = base de sécurité.
Échantillons, ressources, APB, drain = durabilité des rejets.
HPA/VPA/KEDA + tuning pools = échelle sans « dépannage ».
Gateway/Ingress + mTLS/OPA = périmètre sécurisé et communication interne.
Observability + SLO + GitOps = modifications gérables.
Isolation régionale et DR = conformité et tolérance aux pannes.