Kuma

Kuma est un service mesh universel développé par Kong Inc. et projet CNCF Sandbox depuis 2020. Contrairement à Istio ou Linkerd qui ne supportent que Kubernetes, Kuma fonctionne également sur des machines virtuelles et des environnements bare-metal via son mode Universal. Il utilise Envoy comme proxy de données et propose une interface de configuration unifiée - CRDs Kubernetes en mode K8s, API REST en mode Universal.

Le plan de contrôle kuma-cp peut être déployé en mode Single-zone (cluster unique) ou Multi-zone (un Global Control Plane + plusieurs Zone Control Planes pour des déploiements distribués). Kong propose une version enterprise, Kong Mesh, qui ajoute RBAC, OPA, multi-tenancy et support.

Informations essentielles

Origine : Kong Inc. (États-Unis) → CNCF  ·  Licence : Apache 2.0  ·  Architectures : x86_64, ARM64

Liens : Site officiel  ·  Documentation  ·  GitHub  ·  Releases

Support : Les 2 dernières versions majeures sont maintenues. Kong Mesh ajoute un support entreprise avec SLA.

Stack par défaut

Concepts clés

Architecture

Mesh et politiques

Kuma organise les services en Meshes (un cluster peut avoir plusieurs meshes isolés). Les politiques s'appliquent à un mesh.

Politiques disponibles (exemples)

Prérequis

Installation sur Kubernetes

Via Helm (recommandé)

helm repo add kuma https://kumahq.github.io/charts
helm repo update

helm install kuma kuma/kuma \
  --namespace kuma-system \
  --create-namespace

# Vérifier
kubectl get pods -n kuma-system

Options courantes

# kuma-values.yaml
controlPlane:
  mode: Standalone             # Standalone ou Zone (multi-zone)
  resources:
    requests:
      cpu: 100m
      memory: 256Mi

cni:
  enabled: false               # Activer pour redirection transparente du trafic

egress:
  enabled: false               # Activer pour traffic multi-zone

prometheus:
  enabled: false               # Intégration Prometheus optionnelle

helm install kuma kuma/kuma -n kuma-system --create-namespace -f kuma-values.yaml

Installer kumactl

curl -L https://kuma.io/installer.sh | VERSION=2.8.0 sh -
export PATH=$PWD/kuma-2.8.0/bin:$PATH

# Connexion au control plane
kumactl config control-planes add \
  --name=default \
  --address=http://localhost:5681

kumactl get meshes

Activer l'injection par namespace

# Annotation sur le namespace
kubectl annotate namespace production kuma.io/sidecar-injection=enabled

# Vérifier
kubectl get namespace production -o yaml | grep kuma.io/sidecar-injection

# Relancer les pods
kubectl rollout restart deployment -n production

Configuration du mesh

Créer un mesh avec mTLS

# mesh.yaml
apiVersion: kuma.io/v1alpha1
kind: Mesh
metadata:
  name: production
spec:
  mtls:
    enabledBackend: ca-1
    backends:
    - name: ca-1
      type: builtin
      dpCert:
        rotation:
          expiration: 24h
      conf:
        caCert:
          RSAbits: 4096
          expiration: 10y
  logging:
    backends:
    - name: file
      type: file
      conf:
        path: /tmp/access.log
  metrics:
    enabledBackend: prometheus-1
    backends:
    - name: prometheus-1
      type: prometheus

kubectl apply -f mesh.yaml
# Ou via kumactl
kumactl apply -f mesh.yaml

Politiques de trafic

Contrôle d'accès (MeshTrafficPermission)

# Refuser tout, puis autoriser explicitement
apiVersion: kuma.io/v1alpha1
kind: MeshTrafficPermission
metadata:
  name: deny-all
  namespace: kuma-system
  labels:
    kuma.io/mesh: production
spec:
  targetRef:
    kind: Mesh
  from:
  - targetRef:
      kind: Mesh
    default:
      action: Deny
---
apiVersion: kuma.io/v1alpha1
kind: MeshTrafficPermission
metadata:
  name: frontend-to-backend
  namespace: production
  labels:
    kuma.io/mesh: production
spec:
  targetRef:
    kind: MeshService
    name: backend
  from:
  - targetRef:
      kind: MeshService
      name: frontend
    default:
      action: Allow

Retries

apiVersion: kuma.io/v1alpha1
kind: MeshRetry
metadata:
  name: backend-retry
  namespace: production
  labels:
    kuma.io/mesh: production
spec:
  targetRef:
    kind: MeshService
    name: backend
  to:
  - targetRef:
      kind: Mesh
    default:
      http:
        numRetries: 5
        perTryTimeout: 2s
        retryOn:
        - 5xx
        - reset
        - connect-failure

Circuit breaker

apiVersion: kuma.io/v1alpha1
kind: MeshCircuitBreaker
metadata:
  name: backend-cb
  namespace: production
  labels:
    kuma.io/mesh: production
spec:
  targetRef:
    kind: MeshService
    name: backend
  to:
  - targetRef:
      kind: Mesh
    default:
      connectionLimits:
        maxConnections: 1024
        maxPendingRequests: 1024
      outlierDetection:
        consecutive5xxErrors: 5
        interval: 10s
        baseEjectionTime: 30s

Mode Multi-zone

Pour déployer Kuma sur plusieurs clusters ou environnements :

# 1. Installer le Global Control Plane (un seul cluster central)
helm install kuma kuma/kuma -n kuma-system \
  --set controlPlane.mode=Global

# 2. Sur chaque cluster de zone
helm install kuma kuma/kuma -n kuma-system \
  --set controlPlane.mode=Zone \
  --set controlPlane.zone=zone-eu-west \
  --set ingress.enabled=true \
  --set egress.enabled=true \
  --set controlPlane.kdsGlobalAddress=grpcs://<global-cp-address>:5685

Observabilité

# Installer le bundle observabilité (Prometheus + Grafana + Jaeger - non production)
kumactl install observability | kubectl apply -f -

# Accéder aux dashboards
kubectl port-forward svc/grafana -n mesh-observability 3000:80
kubectl port-forward svc/jaeger-query -n mesh-observability 16686:80

Mise à jour

# Vérifier la version courante
kumactl version

# Mettre à jour via Helm
helm repo update
helm upgrade kuma kuma/kuma -n kuma-system -f kuma-values.yaml

# Vérifier
kubectl rollout status deployment/kuma-control-plane -n kuma-system
kubectl rollout restart deployment -n production

Troubleshooting

# État général du mesh
kumactl get meshes
kumactl get dataplanes -m production

# Inspecter un dataplane
kumactl inspect dataplane <nom> -m production --type POLICIES

# Logs du control plane
kubectl logs -n kuma-system -l app=kuma-control-plane --tail=100

# Logs du proxy Envoy dans un pod
kubectl logs <pod> -c kuma-sidecar -n production

# Vérifier l'injection
kubectl get pod <pod> -n production -o yaml | grep sidecar-injected

Pod non injecté

# Vérifier le label du namespace
kubectl get namespace production -o yaml | grep kuma.io/sidecar-injection

# Vérifier le webhook
kubectl get mutatingwebhookconfigurations | grep kuma

Commandes utiles

# Lister toutes les ressources Kuma
kumactl get meshes
kumactl get dataplanes -m production
kumactl get traffic-permissions -m production
kumactl get policies -m production

# Inspecter la config Envoy d'un dataplane
kumactl inspect dataplane <nom> -m production --type XDSCONFIG

# Voir les métriques d'un dataplane
kumactl inspect dataplane <nom> -m production --type STATS

# GUI Kuma (port-forward)
kubectl port-forward svc/kuma-control-plane -n kuma-system 5681:5681
# Ouvrir http://localhost:5681/gui

Ressources

• Documentation officielle : https://kuma.io/docs/
• Politiques Kuma (MeshPolicy) : https://kuma.io/docs/latest/policies/
• Mode multi-zone : https://kuma.io/docs/latest/production/deployment/multi-zone/
• GitHub : https://github.com/kumahq/kuma
• Releases : https://github.com/kumahq/kuma/releases
• Kong Mesh (enterprise) : https://konghq.com/products/kong-mesh