Comment pouvons-nous accéder au conteneur Kubernetes…

Il existe plusieurs méthodes principales pour accéder à un conteneur Kubernetes depuis un réseau externe :

Service de type LoadBalancer :
- Les fournisseurs de cloud (AWS, GCP, Azure) créent un équilibreur de charge externe qui dirige le trafic vers les pods de votre application.
- Une adresse IP externe est attribuée.
- La méthode la plus simple dans un environnement cloud.
Service de type NodePort :
- Ouvre un port sur chaque nœud du cluster.
- Ce port redirige le trafic vers le service de votre application.
- L'accès se fait via l'IP de n'importe quel nœud et le numéro de NodePort.
- Moins évolutif et sécurisé que LoadBalancer.
Service de type ClusterIP avec Ingress :
- ClusterIP - service accessible uniquement à l'intérieur du cluster.
- Ingress - objet API qui gère l'accès externe aux services du cluster.
- Le contrôleur Ingress (par exemple, Nginx Ingress Controller, Traefik) écoute le trafic externe et le route vers le service ClusterIP approprié.
- Permet une gestion centralisée du routage, de la terminaison SSL, du équilibrage de charge.
- Approche flexible et évolutive.
Service de type ExternalName :
- Crée un alias pour un domaine externe. Ne fournit pas d'accès direct au conteneur via ce service, mais permet d'utiliser un nom DNS interne au cluster pour accéder à une ressource externe. Non adapté pour un accès direct au conteneur depuis l'extérieur.
Accès direct à NodePort/HostPort sur un Pod :
- Il est possible de spécifier hostPort dans la spécification du pod pour ouvrir un port sur le nœud où le pod est lancé. Très déconseillé en production en raison de la faible gestion et des conflits potentiels de ports.
- De même, nodePort peut être spécifié dans un Service de type NodePort.

Exemples de configurations :

Service LoadBalancer :

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

Service NodePort :

// service-nodeport.yaml
apiVersion: v1
kind: Service
metadata:
  name: my-app-service-np
spec:
  selector:
    app: my-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
      nodePort: 30000 # optionnel, Kubernetes l'assignera si non spécifié
  type: NodePort

Ingress (pour service ClusterIP) :

// service-clusterip.yaml (supposé qu'il existe déjà)
apiVersion: v1
kind: Service
metadata:
  name: my-app-service-ci
spec:
  selector:
    app: my-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: ClusterIP

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

Le choix de la méthode dépend des exigences en matière de scalabilité, de sécurité, de l'environnement de déploiement (cloud ou on-premise) et de la nécessité d'une gestion centralisée de l'accès. Ingress est la solution privilégiée pour les systèmes en production.

Comment pouvons-nous accéder au conteneur Kubernetes dans lequel l'application est en cours d'exécution depuis le réseau externe?