Configurer le réseau d'un cluster Kubernetes : CNI, Services et Ingress

La configuration réseau Kubernetes CNI détermine comment vos Pods communiquent entre eux et avec l'extérieur. Sans une configuration correcte, vos applications échouent silencieusement. Selon la CNCF Survey 2024, 68% des incidents de production Kubernetes impliquent des problèmes réseau. Ce guide vous accompagne étape par étape pour configurer CNI, Services et Ingress sur votre cluster.

TL;DR : Vous allez installer Calico comme plugin CNI, créer des Services ClusterIP et LoadBalancer, puis configurer un Ingress Controller NGINX pour exposer vos applications. Temps estimé : 45 minutes.

Pour maîtriser ces compétences en profondeur, découvrez la formation LFS458 Administration Kubernetes.

Prérequis avant la configuration réseau Kubernetes CNI

Avant de commencer, vérifiez que vous disposez des éléments suivants :

Un cluster Kubernetes v1.29+ initialisé (consultez le guide d'installation avec kubeadm)
L'accès kubectl configuré avec les droits cluster-admin
Au minimum 2 nœuds pour tester la communication inter-nœuds
Une connaissance de base de l'architecture du control plane Kubernetes

Vérifiez votre accès au cluster :

kubectl cluster-info
# Sortie attendue :
# Kubernetes control plane is running at https://192.168.1.10:6443
# CoreDNS is running at https://192.168.1.10:6443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

À retenir : Sans plugin CNI installé, vos Pods restent en état Pending. Le réseau est obligatoire, pas optionnel.

Étape 1 : Installer les plugins CNI Calico Flannel Kubernetes

Pourquoi choisir Calico pour votre cluster ?

Calico est le plugin CNI le plus déployé en production selon Datadog State of Kubernetes 2024. Il offre les Network Policies natives, le support BGP, et des performances réseau supérieures à Flannel. En 2026, Calico 3.28 intègre le support eBPF par défaut.

Plugin CNI	Network Policies	Performance	Complexité
Calico	Native	Élevée (eBPF)	Moyenne
Flannel	Non	Moyenne	Faible
Cilium	Native + L7	Très élevée	Élevée
Weave	Partielle	Moyenne	Faible

Installer Calico sur votre cluster

Vous allez télécharger et appliquer le manifeste Calico. Adaptez le CIDR à votre configuration kubeadm :

# Téléchargez le manifeste Calico v3.28
kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.28.0/manifests/calico.yaml

# Vérifiez le déploiement
kubectl get pods -n kube-system -l k8s-app=calico-node
# Sortie attendue :
# NAME                READY   STATUS    RESTARTS   AGE
# calico-node-abc12   1/1     Running   0          2m
# calico-node-def34   1/1     Running   0          2m

Si vous utilisez un CIDR différent de 192.168.0.0/16, modifiez la variable CALICO_IPV4POOL_CIDR :

# Téléchargez d'abord le manifeste
curl -O https://raw.githubusercontent.com/projectcalico/calico/v3.28.0/manifests/calico.yaml

# Modifiez le CIDR (exemple : 10.244.0.0/16)
sed -i 's/192.168.0.0\/16/10.244.0.0\/16/g' calico.yaml

# Appliquez le manifeste modifié
kubectl apply -f calico.yaml

À retenir : Le CIDR de Calico doit correspondre exactement à celui spécifié lors de l'initialisation kubeadm avec --pod-network-cidr.

Pour approfondir la gestion des nœuds Kubernetes, consultez notre guide dédié.

Étape 2 : Configurer les Services Kubernetes pour exposer vos applications

Comprendre les types de Services

Un Service Kubernetes est une abstraction qui expose une application tournant sur un ensemble de Pods. Vous avez trois types principaux :

ClusterIP : accessible uniquement depuis l'intérieur du cluster
NodePort : expose le Service sur un port statique de chaque nœud
LoadBalancer : provisionne un load balancer externe (cloud providers)

Créer un Service ClusterIP

Déployez d'abord une application de test, puis exposez-la via un Service ClusterIP :

# nginx-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-test
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.25
        ports:
        - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  type: ClusterIP
  selector:
    app: nginx
  ports:
  - port: 80
    targetPort: 80

Appliquez et vérifiez :

kubectl apply -f nginx-deployment.yaml

kubectl get svc nginx-service
# Sortie attendue :
# NAME            TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)   AGE
# nginx-service   ClusterIP   10.96.142.58    <none>        80/TCP    30s

# Testez la connectivité depuis un Pod
kubectl run test-curl --rm -it --image=curlimages/curl -- curl nginx-service
# Sortie attendue : page HTML nginx

Cette compétence fait partie du programme de certification CKA. La formation Administration Kubernetes LFS458 vous prépare à ces scénarios pratiques.

Créer un Service LoadBalancer

Pour les environnements cloud (AWS, GCP, Azure), vous utilisez un Service LoadBalancer :

# nginx-lb.yaml
apiVersion: v1
kind: Service
metadata:
  name: nginx-lb
spec:
  type: LoadBalancer
  selector:
    app: nginx
  ports:
  - port: 80
    targetPort: 80

kubectl apply -f nginx-lb.yaml

kubectl get svc nginx-lb -w
# Attendez que EXTERNAL-IP passe de <pending> à une IP publique
# NAME       TYPE           CLUSTER-IP     EXTERNAL-IP      PORT(S)        AGE
# nginx-lb   LoadBalancer   10.96.58.142   203.0.113.50     80:31234/TCP   2m

À retenir : Sur un cluster on-premise, installez MetalLB pour obtenir des IPs externes sans cloud provider.

Étape 3 : Configurer l'Ingress pour le routage HTTP avancé

Installer l'Ingress Controller NGINX

L'Ingress est une ressource qui gère l'accès HTTP/HTTPS externe vers vos Services. Vous devez d'abord installer un Ingress Controller. NGINX est le plus répandu selon le rapport CNCF 2024.

# Installez NGINX Ingress Controller via Helm
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update

helm install nginx-ingress ingress-nginx/ingress-nginx \
  --namespace ingress-nginx \
  --create-namespace \
  --set controller.replicaCount=2

# Vérifiez l'installation
kubectl get pods -n ingress-nginx
# Sortie attendue :
# NAME                                        READY   STATUS    RESTARTS   AGE
# nginx-ingress-controller-5d4cf7b9b4-abc12   1/1     Running   0          1m
# nginx-ingress-controller-5d4cf7b9b4-def34   1/1     Running   0          1m

Créer une ressource Ingress

Configurez maintenant une règle Ingress pour router le trafic vers votre Service nginx-service :

# nginx-ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: nginx-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  ingressClassName: nginx
  rules:
  - host: app.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: nginx-service
            port:
              number: 80

kubectl apply -f nginx-ingress.yaml

kubectl get ingress
# Sortie attendue :
# NAME            CLASS   HOSTS             ADDRESS         PORTS   AGE
# nginx-ingress   nginx   app.example.com   203.0.113.100   80      1m

Pour tester localement, ajoutez l'entrée dans /etc/hosts :

echo "203.0.113.100 app.example.com" | sudo tee -a /etc/hosts

curl http://app.example.com
# Sortie attendue : page HTML nginx

En tant qu'administrateur système Kubernetes, vous configurez souvent plusieurs backends via un seul Ingress. Consultez le guide complet sur l'administration cluster Kubernetes pour les cas avancés.

Étape 4 : Vérifier la configuration réseau Kubernetes CNI complète

Exécutez ces commandes pour valider votre configuration :

# Vérifiez que tous les Pods ont une IP
kubectl get pods -o wide
# Chaque Pod doit avoir une IP dans le CIDR configuré

# Testez la résolution DNS interne
kubectl run dns-test --rm -it --image=busybox:1.36 -- nslookup nginx-service
# Sortie attendue :
# Name:      nginx-service
# Address 1: 10.96.142.58 nginx-service.default.svc.cluster.local

# Vérifiez les endpoints du Service
kubectl get endpoints nginx-service
# Sortie attendue :
# NAME            ENDPOINTS                                      AGE
# nginx-service   10.244.1.5:80,10.244.2.3:80,10.244.2.4:80     10m

Dépannage des problèmes réseau courants

Les Pods ne peuvent pas communiquer entre nœuds

Vérifiez que le plugin CNI fonctionne correctement :

# Vérifiez les logs Calico
kubectl logs -n kube-system -l k8s-app=calico-node --tail=50

# Vérifiez les interfaces réseau sur un nœud
kubectl debug node/worker-1 -it --image=busybox -- ip addr show

Consultez notre guide détaillé pour diagnostiquer et résoudre les problèmes réseau.

Le Service ne route pas vers les Pods

Vérifiez que les labels correspondent :

# Vérifiez les labels des Pods
kubectl get pods --show-labels

# Vérifiez le selector du Service
kubectl describe svc nginx-service | grep Selector

À retenir : Un Service sans endpoints indique une erreur de selector. Les labels doivent correspondre exactement.

L'Ingress renvoie une erreur 502

Ce problème survient quand l'Ingress Controller ne peut pas atteindre le backend :

# Vérifiez que le Service existe et a des endpoints
kubectl get endpoints nginx-service

# Vérifiez les logs de l'Ingress Controller
kubectl logs -n ingress-nginx -l app.kubernetes.io/name=ingress-nginx --tail=100

Un ingénieur infrastructure Kubernetes doit maîtriser ces diagnostics. La certification CKA couvre ces scénarios de dépannage.

Configurer les Network Policies pour sécuriser votre réseau

En 2026, les Network Policies sont obligatoires pour tout cluster de production. Vous définissez des règles de trafic entrant et sortant :

# network-policy.yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-nginx-ingress
spec:
  podSelector:
    matchLabels:
      app: nginx
  policyTypes:
  - Ingress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          name: ingress-nginx
    ports:
    - protocol: TCP
      port: 80

kubectl apply -f network-policy.yaml

# Vérifiez que la policy est active
kubectl get networkpolicies

Pour approfondir la sécurité réseau, découvrez les fondamentaux Kubernetes et la formation complète Kubernetes.

Passez à l'action : maîtrisez l'administration réseau Kubernetes

Vous savez maintenant configurer un réseau Kubernetes complet avec CNI, Services et Ingress. En tant qu'ingénieur infrastructure Kubernetes, ces compétences sont essentielles pour la certification CKA et les environnements de production.

Pour aller plus loin dans la maîtrise du réseau Kubernetes :

LFS458 Administration Kubernetes : formation officielle Linux Foundation de 4 jours couvrant la configuration réseau avancée
LFS460 Sécurité Kubernetes : approfondissez les Network Policies et la sécurité réseau
Kubernetes les fondamentaux : si vous débutez avec Kubernetes

Contactez nos conseillers pour définir votre parcours de formation et consulter les prochaines sessions disponibles.

Points clés