Comment mapper les ports dans un service Kubernetes

Introduction

Ce tutoriel vous procurera une compréhension complète des Services Kubernetes, un concept fondamental dans l'écosystème Kubernetes. Vous allez découvrir les différents types de Services, comment exposer vos applications au réseau, et les concepts avancés liés aux Services Kubernetes.

Comprendre les Services Kubernetes

Les Services Kubernetes sont un concept fondamental dans l'écosystème Kubernetes, offrant un moyen d'exposer les applications exécutées dans des Pods au réseau. Les Services abstraient les Pods sous-jacents, permettant aux clients de se connecter à l'application sans avoir besoin de connaître les détails des Pods.

Types de Services Kubernetes

Kubernetes propose plusieurs types de Services pour répondre à différents besoins de réseau :

ClusterIP : C'est le type de Service par défaut, qui expose le Service sur une adresse IP interne au cluster. Ce type de Service n'est accessible que depuis l'intérieur du cluster.

graph LR
  Client --> ClusterIP
  ClusterIP --> Pods

NodePort : Ce type de Service expose l'application sur l'adresse IP de chaque nœud, en utilisant un port statique. Cela permet aux clients externes d'accéder à l'application depuis l'extérieur du cluster.

graph LR
  Client --> NodePort
  NodePort --> Nodes
  Nodes --> Pods

LoadBalancer : Ce type de Service provisionne un chargeur de balancement pour l'application, généralement dans des environnements cloud. Le chargeur de balancement distribue le trafic vers les Pods.

graph LR
  Client --> LoadBalancer
  LoadBalancer --> Nodes
  Nodes --> Pods

ExternalName : Ce type de Service map le Service à un nom DNS, sans aucun Pod ou point final. Cela est utile pour l'intégration avec des services externes.

Composants d'un Service

Un Service Kubernetes est composé de plusieurs composants clés :

Sélecteur : Le sélecteur est un ensemble d'étiquettes qui déterminent quels Pods feront partie du Service.
Port : Le port sur lequel le Service sera accessible.
TargetPort : Le port sur lequel les Pods sont en écoute.
ClusterIP : L'adresse IP interne attribuée au Service.
Type : Le type de Service, tel que décrit précédemment.

Voici une configuration de Service exemple :

apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  selector:
    app: my-app
  ports:
    - port: 80
      targetPort: 8080
  type: LoadBalancer

Dans cet exemple, le Service exposera les Pods avec l'étiquette app: my-app sur le port 80, en redirigeant le trafic vers le port 8080 des Pods.

Exposer les applications Kubernetes

Une fois que vous avez défini un Service Kubernetes, l'étape suivante consiste à exposer votre application au monde extérieur. Kubernetes propose plusieurs façons de le faire, chacune avec ses avantages et ses cas d'utilisation.

Service NodePort

Le type de Service NodePort expose l'application sur l'adresse IP de chaque nœud, en utilisant un port statique. Cela permet aux clients externes d'accéder à l'application depuis l'extérieur du cluster. Voici un exemple :

apiVersion: v1
kind: Service
metadata:
  name: my-nodeport-service
spec:
  type: NodePort
  selector:
    app: my-app
  ports:
    - port: 80
      targetPort: 8080

Dans cet exemple, le Service sera accessible sur l'adresse IP de chaque nœud, en utilisant un port attribué aléatoirement dans la plage 30000 - 32767.

Service LoadBalancer

Le type de Service LoadBalancer provisionne un chargeur de balancement pour l'application, généralement dans des environnements cloud. Le chargeur de balancement distribue le trafic vers les Pods. Voici un exemple :

apiVersion: v1
kind: Service
metadata:
  name: my-loadbalancer-service
spec:
  type: LoadBalancer
  selector:
    app: my-app
  ports:
    - port: 80
      targetPort: 8080

Dans cet exemple, le fournisseur de cloud provisionnera un chargeur de balancement et le configurera pour distribuer le trafic vers les Pods.

Ingress

Ingress est une ressource Kubernetes qui offre des fonctionnalités avancées de routage et de charge de balancement. Ingress vous permet d'exposer plusieurs Services sous une seule adresse IP et peut gérer des fonctionnalités telles que la terminaison SSL/TLS, le routage basé sur les chemins, etc. Voici une configuration Ingress exemple :

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-ingress
spec:
  rules:
    - host: example.com
      http:
        paths:
          - path: /api
            pathType: Prefix
            backend:
              service:
                name: my-api-service
                port:
                  number: 80
          - path: /web
            pathType: Prefix
            backend:
              service:
                name: my-web-service
                port:
                  number: 80

Dans cet exemple, l'Ingress expose deux Services différents, /api et /web, sous le domaine example.com.

Concepts avancés des Services Kubernetes

Alors que les types de Services Kubernetes de base couvrent de nombreux cas d'utilisation, il existe certains concepts avancés qui peuvent offrir plus de flexibilité et de contrôle sur le réseau de votre application.

Découverte de services

Kubernetes fournit des mécanismes de découverte de services intégrés, permettant aux Pods de se trouver et de communiquer les uns avec les autres. Cela est réalisé grâce à l'utilisation de variables d'environnement et du serveur DNS Kubernetes.

Lorsqu'un nouveau Service est créé, Kubernetes lui attribue automatiquement un nom DNS au format <service - name>.<namespace>.svc.cluster.local. Les Pods peuvent ensuite utiliser ce nom DNS pour se connecter au Service.

Kubernetes injecte également des variables d'environnement pour chaque Service, telles que MY_SERVICE_HOST et MY_SERVICE_PORT, que les Pods peuvent utiliser pour se connecter au Service.

Réseau de services

Kubernetes utilise le composant kube - proxy pour gérer le réseau des Services. kube - proxy est responsable de la configuration des règles iptables nécessaires et de la redirection du trafic vers les Pods appropriés.

Kubernetes prend en charge plusieurs modèles de réseau, tels que iptables et ipvs, qui peuvent être configurés selon vos besoins.

Mise à l'échelle des services

Les Services Kubernetes peuvent être mis à l'échelle automatiquement en fonction du nombre de Pods disponibles. Lorsque vous mettez à l'échelle votre application en ajoutant ou en supprimant des Pods, le Service ajustera automatiquement son équilibrage de charge pour distribuer le trafic en conséquence.

Vous pouvez également configurer des options de mise à l'échelle avancées, telles que l'autoscaling horizontal des pods, pour mettre automatiquement à l'échelle votre application en fonction de métriques telles que l'utilisation du CPU ou des métriques personnalisées.

Voici un exemple d'un Horizontal Pod Autoscaler :

apiVersion: autoscaling/v2beta1
kind: HorizontalPodAutoscaler
metadata:
  name: my - hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: my - app
  minReplicas: 2
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        targetAverageUtilization: 50

Dans cet exemple, l'Horizontal Pod Autoscaler mettra automatiquement à l'échelle le déploiement my - app entre 2 et 10 Pods, en fonction de l'utilisation moyenne du CPU des Pods.

Sommaire

Dans ce tutoriel, vous avez appris les différents types de Services Kubernetes, y compris ClusterIP, NodePort et LoadBalancer, et comment ils peuvent être utilisés pour exposer vos applications au réseau. Vous avez également exploré les composants clés d'un Service Kubernetes et la manière de les configurer. En comprenant les Services Kubernetes, vous pouvez gérer et exposer efficacement vos applications exécutées dans des Pods, permettant aux clients de vous connecter à votre application sans avoir besoin de connaître les détails des Pods sous - jacents.