Kubernetes Gateway API : Le Guide Complet de Migration depuis Ingress

Kubernetes Gateway API : Le Guide Complet de Migration depuis Ingress

> kubectl convert --from=ingress --to=gateway-api --dry-run_

Dossier : Migration de Ingress vers Gateway API

Par Nicolas DELAHAYE | v.1974 | Architecte Solution STATUS: NETWORK_ARCHITECTURE_UPGRADE

Pendant des années, l'objet Ingress a été le standard de facto. Couplé à des contrôleurs comme NGINX, Traefik ou HAProxy, il a fait le travail. Mais soyons honnêtes, à l'échelle, c'est devenu un cauchemar de maintenance. Les limites sont structurelles :
  • L'enfer des Annotations : Pour faire du rate-limiting ou du rewrite, vous injectez des annotations spécifiques au contrôleur (vendor lock-in).
  • Tout ou rien : L'objet Ingress mélange la configuration de l'infrastructure (TLS, IP) et le routage applicatif (Paths). Difficile de séparer les rôles Ops et Dev.
  • HTTP Only : Pas de support natif propre pour TCP, UDP ou gRPC sans "hacks".
La Gateway API n'est pas une v2 de l'Ingress. C'est une refonte complète basée sur une architecture orientée Rôles. Elle introduit plusieurs ressources (CRDs) pour découpler les responsabilités.

👥 Qui gère quoi ?

  • GatewayClass (Infra Provider) : Définit le moteur sous-jacent (NGINX, Istio, Cilium).
  • Gateway (Ops / Platform Team) : Définit les points d'entrée, les ports, le TLS et les IP. C'est le "Load Balancer".
  • HTTPRoute / TCPRoute (Dev Team) : Définit les règles de routage vers les services. Les devs ne touchent plus à l'infra !
Regardons concrètement comment la configuration évolue d'un modèle monolithique à un modèle distribué.

L'Ancien Monde (Ingress)

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: app-legacy
  annotations:
    # Dépendance forte à l'implémentation NGINX
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
  - host: app.example.com
    http:
      paths:
      - path: /old
        backend:
          service:
            name: app-svc
            port:
              number: 80

Le Nouveau Monde (Gateway API)

Ici, l'Ops configure le Gateway une fois pour toutes :
# Géré par l'équipe PLATEFORME
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: shared-gateway
  namespace: gateway-system
spec:
  gatewayClassName: nginx-gateway
  listeners:
    - name: https
      port: 443
      protocol: HTTPS
      tls:
        mode: Terminate
        certificateRefs:
          - name: wildcard-cert
      allowedRoutes:
        namespaces:
          from: All # Autorise les apps des autres namespaces à s'attacher
Et le développeur déclare simplement sa route, sans se soucier du certificat SSL ou de l'IP :
# Géré par l'équipe APP (Namespace distinct)
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: app-route
  namespace: my-app
spec:
  parentRefs:
    - name: shared-gateway
      namespace: gateway-system
  hostnames:
    - app.example.com
  rules:
    - matches:
        - path:
            type: PathPrefix
            value: /new
      backendRefs:
        - name: app-svc
          port: 80

🚀 Traffic Splitting (Canary natif)

Plus besoin de Service Mesh lourd (Linkerd/Istio) juste pour faire du Canary. C'est natif :
  rules:
    - backendRefs:
        - name: app-v1
          port: 80
          weight: 90  # 90% du trafic
        - name: app-v2
          port: 80
          weight: 10  # 10% du trafic (Canary)

🛡️ Multi-Protocoles

L'API ne s'arrête pas au HTTP. Vous avez besoin d'exposer une base de données ou un flux vidéo ?
  • kind: TCPRoute → Pour vos bases de données.
  • kind: UDPRoute → Pour le streaming ou le gaming.
  • kind: GRPCRoute → Pour vos microservices modernes.
Ne faites pas de "Big Bang". La Gateway API permet la coexistence. Voici la stratégie que je recommande pour les clusters en production :
Phase Action Impact
1. Préparation Installer les CRDs Gateway API et configurer la GatewayClass. Aucun (Infrastructure only).
2. Double Stack Déployer les HTTPRoute en parallèle des Ingress existants. Double exposition. Permet de tester les nouvelles routes via curl --resolve.
3. Switch DNS Mise à jour du DNS pour pointer vers l'IP du Gateway LoadBalancer. Le trafic bascule. Rollback possible par simple DNS.
4. Cleanup Suppression des anciens objets Ingress. Migration terminée.
Pour industrialiser cela, modifiez vos Chartes Helm pour supporter conditionnellement les deux modes via le fichier values.yaml :
# values.yaml pattern
gateway:
  enabled: true
  className: nginx-gateway
  host: app.example.com

# template/httproute.yaml
{{- if .Values.gateway.enabled }}
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: {{ include "app.fullname" . }}
spec:
  parentRefs:
    - name: {{ .Values.gateway.className }}
  hostnames:
    - {{ .Values.gateway.host }}
  rules:
    ...
{{- end }}
Cette approche permet de migrer application par application dans ArgoCD en changeant simplement un flag booléen.

Sujet Source Lien
Spec & Concepts Kubernetes.io Docs Docs Officielles
Migration Guide Gateway API SIG Guide Migration
GKE Implementation Google Cloud GKE Guide
Conclusion : Passer à Gateway API demande un effort d'apprentissage, mais le retour sur investissement est immédiat pour la stabilité et la sécurité de la plateforme.

[ EOF - Routing Table Updated ]

Lab Kubernetes VirtualBox : Configurer le NAT Network et Host-Only sur Fedora

Lab Kubernetes VirtualBox : Configurer le NAT Network et Host-Only sur Fedora

> ip route add default via kubernetes_knowledge_

Lab Kubernetes VirtualBox : L'Architecture Réseau Ultime

Par Nicolas DELAHAYE | v.1974 | Architecte Solution

STATUS: NETWORK_RECOVERY_MODE


Monter un Lab Kubernetes VirtualBox avec Fedora Server est un excellent choix technique, mais c'est aussi un redoutable test pour vos compétences réseau. Le symptôme est classique : vos VMs ne sortent pas sur Internet et votre Mac refuse de s'y connecter en SSH.

Le problème ne vient pas de Fedora, mais d'une confusion courante sur le rôle du NAT Network. Contrairement à une idée reçue, la VM ne doit pas "router" via votre host pour sortir. Elle doit utiliser l'abstraction fournie par VirtualBox.

En configurant vos IP manuellement sans activer de serveur DHCP sur le NAT Network, vous avez créé des nœuds isolés. Sans DHCP, Fedora ne reçoit pas de Default Gateway (passerelle par défaut). Sans passerelle, la VM ne sait pas par où envoyer ses paquets pour atteindre 8.8.8.8.

De plus, le NAT Network est un réseau privé. Par défaut, il n'autorise pas votre MacBook à "entrer" pour initier une session SSH sans une règle de Port Forwarding complexe.

[Image of the OSI model networking layers]

Pour un lab Kubernetes stable et conforme aux bonnes pratiques DevSecOps, nous allons utiliser deux cartes réseau par VM. Cette séparation des flux est la clé :

  • NIC 1 (NAT Network) : Dédié à la sortie vers Internet (mises à jour dnf, téléchargement d'images Docker).
  • NIC 2 (Host-Only) : Dédié à l'administration SSH depuis votre Mac et aux communications internes du cluster.
Schéma de flux :
VM (enp0s3) ----> VirtualBox NAT Engine ----> Internet
Mac (vboxnet0) <----> VM (enp0s8) [SSH & Kube API]

┌──────────────────────────┐ │ MacBook Pro │ │ │ │ 192.168.56.1 (vboxnet0) │ └────────────┬─────────────┘ │ Host-only ┌────────────────────┼────────────────────┐ │ │ │ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ ControlPlane │ │ Worker 1 │ │ Worker 2 │ │ │ │ │ │ │ │ enp0s8 │ │ enp0s8 │ │ enp0s8 │ │ 192.168.56.11│ │ 192.168.56.21│ │ 192.168.56.22│ │ (SSH/Admin) │ │ │ │ │ │ │ │ │ │ │ │ enp0s3 │ │ enp0s3 │ │ enp0s3 │ │ DHCP │ │ DHCP │ │ DHCP │ │ NAT Network │ │ NAT Network │ │ NAT Network │ └──────┬───────┘ └───────┬──────┘ └────────┬─────┘ │ │ │ └─────────────── VirtualBox NAT Network ────┘ (Internet, DNS, MAJ)

A. Paramétrer le NAT Network

Allez dans VirtualBox > Preferences > Network. Vérifiez votre NAT Network :

  • CIDR : 10.0.2.0/24
  • DHCP : DOIT être activé (C'est lui qui donnera la route par défaut).

B. Paramétrer le Host-Only

Vérifiez que vous avez une interface vboxnet0 (souvent en 192.168.56.1) créée dans le gestionnaire de réseau hôte.

Fedora Server utilise NetworkManager. Oubliez la modification manuelle des fichiers ifcfg, utilisez nmcli pour une configuration persistante et propre.

# 1. Configurer l'interface Internet (NAT Network)
nmcli con add type ethernet ifname enp0s3 con-name internet ipv4.method auto
nmcli con up internet

# 2. Configurer l'interface SSH/Admin (Host-only)
nmcli con add type ethernet ifname enp0s8 con-name admin \
  ipv4.method manual \
  ipv4.addresses 192.168.56.11/24
nmcli con up admin

Crucial : En laissant la première interface en auto (DHCP), Fedora va automatiquement définir la passerelle 10.0.2.1 comme route par défaut. Votre VM peut maintenant sortir !

Pour éviter de refaire cette configuration manuellement sur vos trois nœuds (Control-Plane, Worker1, Worker2), voici le Vagrantfile optimisé pour votre Lab Kubernetes VirtualBox.

Vagrant.configure("2") do |config|
  config.vm.box = "fedora/40-cloud-base"

  nodes = {
    "cp-master" => "192.168.56.11",
    "worker-1"  => "192.168.56.21",
    "worker-2"  => "192.168.56.22"
  }

  nodes.each do |name, ip|
    config.vm.define name do |node|
      node.vm.hostname = name
      # Interface 1 : NAT Network (Auto DHCP via Vagrant)
      node.vm.network "private_network", type: "dhcp", virtualbox__intnet: "nat-k8s"
      
      # Interface 2 : Host-only (IP Statique pour SSH)
      node.vm.network "private_network", ip: ip
      
      node.vm.provider "virtualbox" do |vb|
        vb.memory = 2048
        vb.cpus = 2
      end
    end
  end
end

Une fois cette architecture réseau en place, vous verrez que l'installation de Kubernetes avec kubeadm devient fluide. Pourquoi ? Parce que les composants comme Etcd ou l'API Server pourront s'écouter sur l'interface Host-Only stable, tandis que les pods pourront sortir chercher leurs images via le NAT Network.

Rappelez-vous : dans un environnement virtualisé, la simplicité est une vertu. En séparant l'administration (Host-Only) de la sortie (NAT), vous imitez les architectures Cloud réelles.

Hébergement Helm Charts : Harbor, ArgoCD ou ChartMuseum pour votre Lab ?

Hébergement Helm Charts : Harbor, ArgoCD ou ChartMuseum pour votre Lab ?

> helm repo add chartmuseum http://localhost:8080_

Helm Charts : Pourquoi j'ai choisi ChartMuseum pour mon Lab local

Par Nicolas DELAHAYE | v.1974 | Architecte Solution STRATÉGIE: Simplicité vs Robustesse de production

Je construis actuellement un environnement de développement pour une solution déployée sur Kubernetes. Pour l'infra, j'utilise Helm Charts (simple, efficace, facile à injecter via Ansible ou Terraform). Mon problème ? Je voulais un dépôt de Charts qui ne soit pas juste un dossier local (trop éloigné de la prod), mais sans pour autant lancer une "Death Star" comme ArgoCD ou Harbor sur mon MacBook. Je veux déclencher la mise à jour seulement quand mon Chart est "OK", et non à chaque micro-modification locale.
Avantages Inconvénients
Ultra complet, sécu (Trivy), signatures. Très lourd à déployer en local.
Le roi du GitOps en production. Surdimensionné pour un simple test de Chart.
Simplicité absolue (Nginx/Apache). Pas d'API, pas de gestion de versions.
Léger, API de dépôt, stockage cloud. Moins de fonctions de sécurité avancées.
J'ai choisi ChartMuseum car c'est un projet officiel de l'univers Kubernetes (CNCF). C'est écrit en Go, c'est ultra-léger et cela fournit exactement ce dont j'ai besoin : un vrai dépôt de Helm Charts accessible via une API. Cela me permet de tester le cycle de vie réel de mes déploiements sans l'overhead d'un registre d'artefacts d'entreprise.
Une fois votre instance lancée (via Docker ou en binaire), voici le workflow minimaliste : Étape 1 : Packager votre Chart
$ helm package ./mon-beau-chart

// Cela génère un fichier .tgz prêt pour le dépôt.

Étape 2 : Envoyer au Chartmuseum
$ curl --data-binary "@mon-beau-chart-0.1.0.tgz" http://localhost:8080/api/charts
Étape 3 : Déployer votre chart
$ helm install mon-beau-chart chartmuseum/mon-beau-chart
// RÉFLEXION DE NICO : En tant qu'architecte, on est souvent tenté par les solutions "Rolls-Royce" (Harbor, ArgoCD). Mais le vrai Craftsmanship, c'est de savoir choisir l'outil proportionné au besoin. ChartMuseum me permet de simuler un flux de production tout en restant sur un environnement local fluide. C'est propre, c'est net, c'est efficace.