Kubernetes | Services Nodeport & namespace

LinkedIn | GitLab | GitHub | Credly

Contexte

Ce laboratoire vise à présenter les étapes de mise en place d'un service de type NodePort sur Kubernetes.

Objectifs

Dans ce lab, nous allons créer un environnement isolé sur Kubernetes et déployer une application accessible depuis l'extérieur du cluster. Voici les étapes à suivre pour ce processus :

Création d'un Namespace : Rédigez un manifeste namespace.yml pour créer un namespace appelé production.
Déploiement d'un Pod : Créez un manifeste pod-red.yml pour déployer un pod utilisant l'image mmumshad/simple-webapp-color, avec la couleur rouge spécifiée et un label app:web.
Exposition du Pod via NodePort : Élaborez un manifeste service-nodeport-web.yml qui expose le pod sur le réseau extérieur via un service de type NodePort. Configurez ce service pour utiliser le port 30008 comme NodePort et rediriger les requêtes vers le port 8080 des pods.
Lancement et Vérification : Déployez le service et utilisez kubectl describe pour vérifier que le service a correctement identifié les deux pods sous le label app:web.
Test d'Accessibilité : Testez l'accès à l'application en ouvrant le port 30008 du nœud pour s'assurer que l'application est accessible.

1. Définition des concepts

1.1. C'est quoi namespace ?

Un namespace dans Kubernetes est une sorte de partition virtuelle au sein d'un cluster, qui permet d'isoler les groupes de ressources. Chaque namespace peut contenir des ressources (comme des pods, services, volumes, etc.) indépendamment des autres namespaces. Utiliser des namespaces permet de gérer efficacement les droits d'accès, de simplifier l'allocation des ressources, de segmenter le cluster pour différents utilisateurs ou projets, et d'organiser les ressources de manière plus structurée, facilitant ainsi la gestion et la maintenance du cluster.

1.2. Concept de Nodeport

Le service de type NodePort dans Kubernetes permet d'exposer des services sur des ports fixes des nœuds du cluster. Chaque nœud redirige automatiquement ce port fixe (NodePort) vers le port du service. Ce mécanisme rend le service accessible de l'extérieur du cluster en utilisant <IP du Nœud>:. NodePort est généralement utilisé pour des applications de test ou des environnements de développement, car il offre un moyen simple et direct d'accéder aux services à travers les adresses IP des nœuds.

2. Prérequis : Liste des exigences matérielles et logicielles.

Dans notre cas, nous allons provisionner une instances EC2 s'exécutant sous Ubuntu 20.04 Focal Fossa LTS, grace au provider AWS, à partir delaquelle nous effectuerons toutes nos opérations.

Provisionner une instance EC2 sur AWS à l'aide de Terraform (recommandé)

Provisionner une instance EC2 sur AWS à l'aide d'Ansible

2. Création d'un cluster

Consultez le document Istaller kubeadm

3. Configuration initiale

3.1. Création du fichier namespace.yml pour le namespace production.

nano namespace.yml

apiVersion: v1
kind: Namespace
metadata:
  name: production

3.2. Création du namespace.

kubectl apply -f namespace.yml

Création du namespace effectuée

kubectl get namespace

Name space "production" crée

4. Déploiement des Pods

4.1. Description du fichier pod-red.yml

nano pod-red.yml

apiVersion: v1
kind: Pod
metadata:
  name: simple-webapp-color-red
  labels:
    app: web
spec:
  containers:
    - name: web
      image: mmumshad/simple-webapp-color
      ports:
        - containerPort: 8080
      env:
        - name: APP_COLOR
          value: red #définition de la couleur

4.2. Procédure pour déployer le pod dans le namespace production.

kubectl apply -f pod-red.yml -n production

Vérification de la création du pod dans le namespace définit

kubectl get pod --namespace production

ou 

kubectl get pod -n production

4.3. Description du fichier pod-blue.yml

nano pod-blue.yml

apiVersion: v1
kind: Pod
metadata:
  name: simple-webapp-color-blue
  labels:
    app: web
spec:
  containers:
    - name: web
      image: mmumshad/simple-webapp-color
      ports:
        - containerPort: 8080
      env:
        - name: APP_COLOR
          value: blue #définition de la couleur

4.4. Création du pod blue

kubectl apply -f pod-blue.yml -n production

Pod blue en cours d'exécution

5. Création du Service NodePort

5.1. Description du fichier service-nodeport-web.yml

nano service-nodeport-web.yml

apiVersion: v1
kind: Service
metadata:
  name: service-nodeport-web
spec:
  type: NodePort
  selector:
    app: web
  ports:
  - protocol: TCP
    port: 8080
    targetPort: 8080
    nodePort: 30000

Dans ce manifest, nous définissons un service de type NodePort ici désigné par service-nodeport-web. Il est configuré pour router le trafic TCP sur le port 8080 vers le targetPort 8080 des pods étiquetés avec app: web. De plus, ce service est exposé sur chaque nœud du cluster via le nodePort 30000. Cette configuration permet au trafic externe d'accéder aux pods spécifiés via l'adresse IP de n'importe quel nœud du cluster, suivi du port 30000.

5.2. Création du service Nodeport et exposition des pods

kubectl apply -f service-nodeport-web.yml -n production

Service nodePort est bien crée

On peut vérifier les détails de notre service pour obtenir les IPs sur lesquelles il pointe

kubectl describe service -n production

6. Vérification et Tests

En entrant l'adresse IP de l'un des node du cluster, dans notre cas, celui du "node control" dans un navigateur suivi du port 3000, l'on obtiens une page du navigateur qui s'alterne.

webapp bleu

webapp red

on peut constater que l'exposition des deux applications/pods (red & blue) vers l'extérieur et le loadbalancing marchent bien, car il permet d'alterner entre les deux pages.

Kubernetes | Services Nodeport & namespace : créer un environnement isolé et exposer des pods vers l'extérieur