Services Kubernetes : exposer vos applications

Les services kubernetes constituent le mécanisme natif pour exposer application kubernetes à d'autres Pods, au cluster ou au monde extérieur. Un Service fournit une adresse IP stable et un nom DNS permanent, indépendamment du cycle de vie éphémère des Pods. Avec 82% des utilisateurs de conteneurs en production, comprendre les Services devient indispensable.

TL;DR : Un Service sélectionne des Pods via des labels et leur attribue une IP virtuelle stable. Quatre types existent : ClusterIP (interne), NodePort (port sur chaque node), LoadBalancer (cloud provider) et ExternalName (alias DNS). Ce guide couvre la création, la configuration et les cas d'usage de chaque type de services kubernetes.

Ce sujet est couvert dans la formation Kubernetes, les fondamentaux.

Pourquoi utiliser les services kubernetes ?

Les Pods sont éphémères. Ils reçoivent des adresses IP dynamiques qui changent à chaque recréation. Un Service résout ce problème en fournissant :

1. IP stable : adresse virtuelle fixe (ClusterIP)
2. DNS : nom résolvable service-name.namespace.svc.cluster.local
3. Load balancing : distribution automatique du trafic entre Pods
4. Découverte : les Pods trouvent les Services via DNS ou variables d'environnement

À retenir : ne codez jamais en dur l'IP d'un Pod. Utilisez toujours un Service comme point d'entrée stable.

Consultez notre Formation Kubernetes : Guide Complet pour comprendre l'écosystème complet.

Quels sont les types de services kubernetes ?

Kubernetes propose quatre types de Services, chacun adapté à un cas d'usage spécifique.

ClusterIP : communication interne

Type par défaut. Crée une IP virtuelle accessible uniquement depuis l'intérieur du cluster.

apiVersion: v1
kind: Service
metadata:
  name: api-service
spec:
  type: ClusterIP
  selector:
    app: api-backend
  ports:
  - port: 80
    targetPort: 8080

Utilisation : bases de données, caches Redis, services internes.

NodePort : accès externe direct

Expose le Service sur un port statique de chaque Node du cluster.

apiVersion: v1
kind: Service
metadata:
  name: web-nodeport
spec:
  type: NodePort
  selector:
    app: web-frontend
  ports:
  - port: 80
    targetPort: 8080
    nodePort: 30080

Accès : http://:30080

À retenir : NodePort convient pour le développement et les tests. Évitez-le en production où un LoadBalancer ou Ingress est préférable.

LoadBalancer : production cloud

Provisionne automatiquement un load balancer cloud (AWS ELB, GCP LB, Azure LB).

apiVersion: v1
kind: Service
metadata:
  name: web-loadbalancer
spec:
  type: LoadBalancer
  selector:
    app: web-frontend
  ports:
  - port: 443
    targetPort: 8080

Avec 80% des organisations utilisant Kubernetes en production, LoadBalancer reste le choix standard pour exposer application kubernetes publiquement.

ExternalName : alias DNS externe

Crée un alias CNAME vers un service externe.

apiVersion: v1
kind: Service
metadata:
  name: external-db
spec:
  type: ExternalName
  externalName: database.example.com

Utilisation : intégrer des services SaaS ou bases de données managées.

Pour créer ces Services via CLI, maîtrisez d'abord les commandes kubectl essentielles.

Comment créer un Service avec des sélecteurs ?

Un Service utilise des sélecteurs pour cibler les Pods à exposer. Les labels du sélecteur doivent correspondre aux labels des Pods.

Créez un Deployment et son Service associé :

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: api-backend
spec:
  replicas: 3
  selector:
    matchLabels:
      app: api-backend
      tier: backend
  template:
    metadata:
      labels:
        app: api-backend
        tier: backend
    spec:
      containers:
      - name: api
        image: mon-registry/api:v1.0.0
        ports:
        - containerPort: 8080
---
# service.yaml
apiVersion: v1
kind: Service
metadata:
  name: api-service
spec:
  selector:
    app: api-backend
    tier: backend
  ports:
  - name: http
    port: 80
    targetPort: 8080
    protocol: TCP

Vérifiez la connexion Service-Pods :

# Voir les endpoints (Pods sélectionnés)
kubectl get endpoints api-service

# Détails du Service
kubectl describe service api-service

À retenir : si Endpoints est vide, vérifiez que les labels du Service correspondent à ceux des Pods et que les Pods sont en état Running.

Les équipes IT passent 34 jours ouvrés par an sur les problèmes Kubernetes. Une bonne compréhension des sélecteurs évite des heures de debugging.

Comment configurer les ports des services kubernetes ?

La configuration des ports détermine comment le trafic atteint vos conteneurs.

Service multi-ports

Exposez plusieurs ports sur un même Service :

apiVersion: v1
kind: Service
metadata:
  name: app-service
spec:
  selector:
    app: mon-app
  ports:
  - name: http
    port: 80
    targetPort: 8080
  - name: https
    port: 443
    targetPort: 8443
  - name: metrics
    port: 9090
    targetPort: 9090

À retenir : nommez toujours vos ports quand vous en définissez plusieurs. Le nom permet de référencer le port dans d'autres ressources (Ingress, NetworkPolicy).

Pour gérer les applications exposées, apprenez les Deployments et ReplicaSets Kubernetes.

Comment utiliser le DNS interne du cluster ?

Kubernetes inclut un serveur DNS (CoreDNS) qui résout automatiquement les noms de Services.

Formats DNS

Testez la résolution DNS depuis un Pod :

# Créer un pod de debug
kubectl run debug --image=busybox --rm -it -- sh

# Dans le pod
nslookup api-service
nslookup api-service.production.svc.cluster.local
wget -qO- http://api-service/health

Variables d'environnement

Kubernetes injecte automatiquement des variables pour chaque Service actif :

# Dans un Pod
echo $API_SERVICE_SERVICE_HOST
echo $API_SERVICE_SERVICE_PORT

Comment exposer application kubernetes avec un Ingress ?

Un Ingress gère l'accès HTTP/HTTPS externe vers les Services du cluster. Il fournit :

• Routage basé sur l'URL/host
• Terminaison TLS
• Load balancing L7

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

À retenir : l'Ingress nécessite un Ingress Controller (nginx, traefik, etc.) installé dans le cluster.

Avec 71 % des entreprises Fortune 100 sur Kubernetes, l'Ingress est devenu le standard pour l'exposition web.

Debugging des services kubernetes

Diagnostiquez les problèmes de connectivité Service :

# Vérifier que le Service existe
kubectl get svc api-service

# Vérifier les endpoints
kubectl get endpoints api-service

# Si endpoints vide, vérifier les Pods
kubectl get pods -l app=api-backend

# Tester depuis un pod
kubectl run debug --image=curlimages/curl --rm -it -- \
  curl -v http://api-service/health

Pour le debugging avancé, consultez Kubernetes les fondamentaux et pour débutants.

Tableau récapitulatif : commandes Service

Passez à l'action : formations Kubernetes SFEIR

Les Services Kubernetes sont essentiels pour toute architecture cloud-native. Pour progresser :

• Découvrez Kubernetes en 1 jour avec Kubernetes, les fondamentaux : Pods, Services, Deployments, architecture
• Développez des applications avec LFD459 Kubernetes pour les développeurs : 3 jours de pratique intensive pour le CKAD
• Administrez des clusters avec LFS458 Administration Kubernetes : 4 jours pour maîtriser le réseau, le stockage et la sécurité

Contactez nos conseillers pour définir votre parcours de formation.