Installation du LoadBalancer MetalLB pour Kubernetes

Présentation

Dans cet article nous allons installer MetalLB qui est un loadbalancer pour Kubernetes. Il permet ainsi d’utiliser des services de type LoadBalancer (traditionnellement utilisés par les clusters hebergés chez des cloud providers) tout en faisant tourner son propre cluster Kubernetes baremetal.
Ainsi, contrairement à un service de type ExternalIP, l’adresse IP attribuée au service LoadBalancer ne dépend pas d’un nœud en particulier.
MetalLB fonctionne soit en mode BGP soit en mode Layer 2. Dans cet article, nous allons le configurer pour le faire fonctionner dans le mode Layer 2. Nous partirons du cluster installé dans cet article.

Le fonctionnement dans ce mode à quelques ressemblances avec celui de keepalived. Une adresse IP sera fournie au service et tout le traffic à destination de ce service sera redirigé vers un noeud worker. Kube-proxy redirigera ensuite les requêtes vers les pods du service.
En cas de dysfonctionnement du nœud, un nouveau nœud fonctionnel répondra alors aux requêtes à destination de l’adresse IP attribuée. A la différence keepalived, les noeuds ne communiquent pas entre eux. En effet, MetalLB utilise memberlist pour connaître la disponibilité des nœuds du cluster k8s. Il ne s’agira donc pas d’un vrai équilibrage de charge mais plutôt d’une mise en place de haute disponibilité.

Installation

Tout d’abord, nous allons configurer firewalld sur l’ensemble des noeuds (supprimer la ligne correspondant au noeud courant) :

firewall-cmd --permanent --zone=public --add-rich-rule="rule family="ipv4" source address="192.168.11.101/32" port protocol="tcp" port="7946" accept"
firewall-cmd --permanent --zone=public --add-rich-rule="rule family="ipv4" source address="192.168.11.102/32" port protocol="tcp" port="7946" accept"
firewall-cmd --permanent --zone=public --add-rich-rule="rule family="ipv4" source address="192.168.11.103/32" port protocol="tcp" port="7946" accept"
firewall-cmd --permanent --zone=public --add-rich-rule="rule family="ipv4" source address="192.168.11.121/32" port protocol="tcp" port="7946" accept"
firewall-cmd --permanent --zone=public --add-rich-rule="rule family="ipv4" source address="192.168.11.122/32" port protocol="tcp" port="7946" accept"
firewall-cmd --permanent --zone=public --add-rich-rule="rule family="ipv4" source address="192.168.11.101/32" port protocol="udp" port="7946" accept"
firewall-cmd --permanent --zone=public --add-rich-rule="rule family="ipv4" source address="192.168.11.102/32" port protocol="udp" port="7946" accept"
firewall-cmd --permanent --zone=public --add-rich-rule="rule family="ipv4" source address="192.168.11.103/32" port protocol="udp" port="7946" accept"
firewall-cmd --permanent --zone=public --add-rich-rule="rule family="ipv4" source address="192.168.11.121/32" port protocol="udp" port="7946" accept"
firewall-cmd --permanent --zone=public --add-rich-rule="rule family="ipv4" source address="192.168.11.122/32" port protocol="udp" port="7946" accept"
firewall-cmd --reload

Ensuite nous allons positionner le paramètre StrictARP à True de la section ipvs grace à la commande :

kubectl edit configmap -n kube-system kube-proxy

L’installation se fait ensuite en lançant ces deux commandes :

kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.12.1/manifests/namespace.yaml
kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.12.1/manifests/metallb.yaml

Configuration

La configuration de MetalLB se fait à l’aide d’un fichier au format yaml.
Nous allons définir le pool d’adresse 192.168.11.170 à 192.168.11.199 que MetalLB va pouvoir assigner aux services.
Editons un fichier nommé config.yaml :

apiVersion: v1
kind: ConfigMap
metadata:
  namespace: metallb-system
  name: config
data:
  config: |
    address-pools:
    - name: default
      protocol: layer2
      addresses:
      - 192.168.11.170-192.168.11.199

Nous pouvons ensuite appliquer ce fichier :

kubectl apply -f config.yaml

Fonctionnement

Pour tester le fonctionnement, nous allons créer le fichier nginx-lb.yaml suivant :

apiVersion: v1
kind: Service
metadata:
  name: test-nginx
  labels:
    run: test-nginx
  annotations:
    metallb.universe.tf/address-pool: default
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 80
    protocol: TCP
    name: http
  - port: 443
    protocol: TCP
    name: https
  selector:
    run: test-nginx
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: test-nginx
spec:
  selector:
    matchLabels:
      run: test-nginx
  replicas: 3
  template:
    metadata:
      labels:
        run: test-nginx
    spec:
      containers:
      - name: nginx
        image: nginx
        ports:
        - containerPort: 80

Puis nous l’intégrons grâce à la commande :

kubectl create -f nginx-lb.yaml

La commande kubectl describe svc/test-nginx permet de connaitre l’adresse IP attribué (ici 192.168.11.170) ainsi que le noeud répondant aux requêtes (ici worker-1) :

En faisant pointer un navigateur web à cette adresse, nous avons donc bien la page d’accueil de nginx :

Si nous arrêtons le worker-1, nous pouvons voir que c’est le worker-2 qui prend le relais :