angle-uparrow-clockwisearrow-counterclockwisearrow-down-uparrow-leftatcalendarcard-listchatcheckenvelopefolderhouseinfo-circlepencilpeoplepersonperson-fillperson-plusphoneplusquestion-circlesearchtagtrashx

Utilisation de Ingress pour accéder à RabbitMQ sur un cluster Microk8s

Par rapport à un Nodeport, un Ingress Controller ajoute plus de complexité mais offre aussi plus de flexibilité.

20 novembre 2024
Dans Kubernetes
post main image
https://www.pexels.com/@cup-of-couple

Il y a quelque temps, j'ai publié un billet sur le déplacement d'une partie d'une application contenant RabbitMQ fonctionnant sur Docker Swarm vers Microk8s. Nous avons utilisé NodePort pour accéder au cluster Kubernetes RabbitMQ sur l'hôte.

Récemment, j'ai décidé d'utiliser le pod Microk8s Ingress Controller pour accéder à RabbitMQ.
Dans ce billet, nous supposons que le pod RabbitMQ est présent et nous nous concentrons uniquement sur la mise en route du pod Ingress Controller .

Ci-dessous, 'kubectl' correspond à 'microk8s kubectl'.

Comme toujours, je le fais sur Ubuntu 22.04.

Attention : La configuration par défaut de Ingress Controller entre en conflit avec les applications qui utilisent déjà les ports 80 et 443.

Le Microk8s Ingress Controller est basé sur le Nginx et active les ports 80 et 443 par défaut. Si vous avez déjà une autre application fonctionnant sur votre système qui utilise ces ports, comme Nginx, alors vous avez un problème lorsque vous activez Ingress Controller.
Dans mon cas, mon serveur Nginx existant n'a plus fonctionné ... :-(

Pour éviter cela, changez les ports du Ingress Controller pour des ports peu utilisés AVANT de l'activer :

80  -> 9480
443 -> 9483

Nous faisons cela en modifiant la section des ports dans le fichier :

/var/snap/microk8s/common/addons/core/addons/ingress/ingress.yaml

Voici à quoi elle ressemble après modification :

        ports:
        - name: http
          containerPort: 80
          #hostPort: 80
          hostPort: 9480
        - name: https
          containerPort: 443
          #hostPort: 443
          hostPort: 9483
        - name: health
          containerPort: 10254
          hostPort: 10254

Activation et désactivation du port Microk8s Ingress Controller

Nous pouvons maintenant activer le Ingress Controller en toute sécurité :

microk8s enable ingress

Résultat :

Infer repository core for addon ingress
Enabling Ingress
ingressclass.networking.k8s.io/public created
ingressclass.networking.k8s.io/nginx created
namespace/ingress created
serviceaccount/nginx-ingress-microk8s-serviceaccount created
clusterrole.rbac.authorization.k8s.io/nginx-ingress-microk8s-clusterrole created
role.rbac.authorization.k8s.io/nginx-ingress-microk8s-role created
clusterrolebinding.rbac.authorization.k8s.io/nginx-ingress-microk8s created
rolebinding.rbac.authorization.k8s.io/nginx-ingress-microk8s created
configmap/nginx-load-balancer-microk8s-conf created
configmap/nginx-ingress-tcp-microk8s-conf created
configmap/nginx-ingress-udp-microk8s-conf created
daemonset.apps/nginx-ingress-microk8s-controller created
Ingress is enabled

Pour désactiver le Ingress Controller ultérieurement, nous utilisons :

microk8s disable ingress

Pour vérifier si le pod Ingress Controller est en cours d'exécution :

kubectl -n ingress get pod

Résultat :

NAME                                      READY   STATUS    RESTARTS   AGE
nginx-ingress-microk8s-controller-fmqc7   1/1     Running   0          177m

Nous pouvons consulter les journaux :

kubectl -n ingress logs nginx-ingress-microk8s-controller-74pns

Résultat : Nous pouvons consulter les journaux : Résultat :

-------------------------------------------------------------------------------
NGINX Ingress controller
  Release:       v1.8.0
  Build:         35f5082ee7f211555aaff431d7c4423c17f8ce9e
  Repository:    https://github.com/kubernetes/ingress-nginx
  nginx version: nginx/1.21.6

-------------------------------------------------------------------------------
....

Vérifier que Ingress écoute sur le port que nous avons spécifié :

wget 127.0.0.1:9480

Résultat :

--2024-11-17 19:41:48--  http://127.0.0.1:9480/
Connecting to 127.0.0.1:9480... connected.
HTTP request sent, awaiting response... 404 Not Found
2024-11-17 19:41:48 ERROR 404: Not Found.

C'est bon, il répond ! Comme vous pouvez le voir, le Contreoller Microk8s Ingress est basé sur le serveur web Nginx .

Connexion de Ingress à RabbitMQ dans le cluster Microk8s

Pour ce faire, nous devons procéder comme suit :

  1. Modifier le fichier Ingress Controller daemonset
  2. Modifier le TCP Ingress Controller config map
  3. Créer un fichier Ingress YAML : 'rabbitmq-ingress.yaml'

Important :

  • Le nom du service RabbitMQ est 'rabbitmq-service', le port est 5672.
  • RabbitMQ se trouve dans l'espace de noms par défaut. Modifiez-le si vous utilisez un autre espace de noms.

1. Modifier le fichier Ingress Controller daemonset

Ici, nous ajoutons un containerPort, 5672, et un hostPort, 9493. Pour éditer le daemonset de notre Ingress Controller :

kubectl -n ingress edit daemonset nginx-ingress-microk8s-controller

La section "ports" avant la modification :

        ports:
        - containerPort: 80
          hostPort: 9480
          name: http
          protocol: TCP
        - containerPort: 443
          hostPort: 9483
          name: https
          protocol: TCP
        - containerPort: 10254
          hostPort: 10254
          name: health
          protocol: TCP

Modifiez-la de façon à ce qu'elle ressemble à ceci. Nous laisserons les autres ports tels quels :

        ports:
        - containerPort: 80
          hostPort: 9480
          name: http
          protocol: TCP
        - containerPort: 443
          hostPort: 9483
          name: https
          protocol: TCP
        - containerPort: 5672
          hostPort: 9493
          name: rabbitmq5672
          protocol: TCP
        - containerPort: 10254
          hostPort: 10254
          name: health
          protocol: TCP

Sauvegardez et quittez.

2. Modifier le port TCP Ingress Controller config map

Ici, nous acheminons le trafic TCP/UDP externe des protocoles non-HTTP vers les services internes en utilisant les mappages de ports TCP/UDP.

Pour obtenir tous les config maps du Ingress Controller :

kubectl -n ingress get configmap

Résultat :

NAME                                DATA   AGE
kube-root-ca.crt                    1      3h56m
nginx-ingress-tcp-microk8s-conf     0      3h56m
nginx-ingress-udp-microk8s-conf     0      3h56m
nginx-load-balancer-microk8s-conf   0      3h56m

Pour éditer le TCP config map :

kubectl -n ingress edit configmaps nginx-ingress-tcp-microk8s-conf

Ajouter les lignes suivantes :

data:
  5672: "default/rabbitmq-service:5672"

Vérifier que cela a été fait :

kubectl -n ingress get configmap nginx-ingress-tcp-microk8s-conf -o yaml

Résultat :

apiVersion: v1
data:
  "5672": default/rabbitmq-service:5672
kind: ConfigMap
metadata:
  annotations:
    kubectl.kubernetes.io/last-applied-configuration: |
      {"apiVersion":"v1","kind":"ConfigMap","metadata":{"annotations":{},"name":"nginx-ingress-tcp-microk8s-conf","namespace":"ingress"}}
  creationTimestamp: "2024-11-17T18:26:14Z"
  name: nginx-ingress-tcp-microk8s-conf
  namespace: ingress
  resourceVersion: "9071777"
  uid: c8495fca-7753-4b60-9542-dcb9879ab4d0

3. Créer un fichier Ingress YAML

Enfin, nous créons le fichier YAML suivant 'rabbitmq-ingress.yaml' :

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: rabbitmq-ingress
spec:
  rules:
  - http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: rabbitmq-service
            port:
              number: 5672

Déployer le fichier Ingress Controller

Après avoir effectué les étapes ci-dessus, nous pouvons déployer le fichier Ingress Controller :

kubectl apply -f rabbitmq-ingress.yaml

Résultat :

ingress.networking.k8s.io/rabbitmq-ingress created

Vérifier plus d'informations :

kubectl describe ingress rabbitmq-ingress

Résultat : Vérifier plus d'informations : Résultat :

Name:             rabbitmq-ingress
Labels:           <none>
Namespace:        default
Address:          127.0.0.1
Ingress Class:    public
Default backend:  <default>
Rules:
  Host        Path  Backends
  ----        ----  --------
  *           
              /   rabbitmq-service:5672 (10.1.105.102:5672)
Annotations:  <none>
Events:       <none>

Vérifiez si le service IP address correspond au service RabbitMQ !

Si vous souhaitez ultérieurement supprimer le service Ingress Controller :

kubectl delete ingress rabbitmq-ingress

Testez sur l'hôte avec Pika

Ce blog traite de Python, nous utilisons donc ici le paquetage Pika pour créer un programme de test simple.

# rabbitmq_test.py
import logging
import sys

import pika

logging.basicConfig(
    format='%(asctime)s %(levelname)8s [%(filename)-10s%(funcName)20s():%(lineno)04s] %(message)s',
    #level=logging.DEBUG,
    level=logging.INFO,
)
logger = logging.getLogger(__name__)

RABBITMQ_HOST = '127.0.0.1'
RABBITMQ_PORT = 9493
RABBITMQ_USER = '<your-user>'
RABBITMQ_PASSWORD = '<your-password>'

def main():
    
    url_items = [
        'amqp://',
        f'{RABBITMQ_USER}:{RABBITMQ_PASSWORD}',
        '@',
        f'{RABBITMQ_HOST}:{str(RABBITMQ_PORT)}',
        '/%2F',
    ]
    url = ''.join(url_items)
    logger.info(f'url = {url}')

    parameters = pika.URLParameters(url)
    logger.info(f'url = {url}')

    logger.info(f'parameters = {parameters}')
    try:
        connection = pika.BlockingConnection(parameters)
        logger.info(f'connection = {connection}')
    except Exception as e:
        logger.exception(f'connection error')
        raise
    logger.info(f'connected')

    channel = connection.channel()
    queue = 'test_queue'
    channel.queue_declare(queue=queue)

    logger.info(f'publishing ...')
    try:
        channel.basic_publish(
			exchange='test_exchange',
			routing_key=queue,
			body='test_message',
			properties=pika.BasicProperties(
                content_type='text/plain',
                delivery_mode=pika.DeliveryMode.Transient
            ),
        )
    except Exception as e:
        logger.exception(f'publish error')
        raise
    logger.info(f'publish ready')

if __name__ == '__main__':
    main()

Plusieurs Ingress Controllers

Il se peut que vous souhaitiez ajouter une autre route entre l'hôte et le cluster. Il est également possible d'utiliser plusieurs Ingress Controllers.

Résumé

J'ai réussi à faire fonctionner ce système sans trop de difficultés. Si vous vérifiez le IP address ci-dessus, vous noterez qu'il s'agit du IP address du pod RabbitMQ . Il semble que le Ingress Controller se connecte au pod RabbitMQ , et non au service RabbitMQ !
Cela semble être correct ( ?). Hmmm ... je regarderai cela plus tard ...

Liens / crédits

Does an ingress talk to pods directly or its through a service?
https://stackoverflow.com/questions/71955811/does-an-ingress-talk-to-pods-directly-or-its-through-a-service

Exposing Redis with Ingress Nginx Controller
https://stackoverflow.com/questions/62939846/exposing-redis-with-ingress-nginx-controller

How to expose Kubernetes-hosted RabbitMQ to the outside?
https://stackoverflow.com/questions/63334992/how-to-expose-kubernetes-hosted-rabbitmq-to-the-outside

How to Set up Kubernetes Ingress with MicroK8s
https://phoenixnap.com/kb/microk8s-ingress

Issue with exposing rabbitmq port 5671
https://discuss.kubernetes.io/t/issue-with-exposing-rabbitmq-port-5671/15883

Kubernetes - Ingress-Nginx Controller
https://kubernetes.github.io/ingress-nginx

Kubernetes: microk8s with multiple metalLB endpoints and nginx ingress controllers
https://fabianlee.org/2021/07/29/kubernetes-microk8s-with-multiple-metallb-endpoints-and-nginx-ingress-controllers

Microk8s - Addon: Ingress
https://microk8s.io/docs/ingress

Minikube - Ingress nginx for TCP and UDP services
https://minikube.sigs.k8s.io/docs/tutorials/nginx_tcp_udp_ingress

En savoir plus...

Kubernetes Microk8s

Laissez un commentaire

Commentez anonymement ou connectez-vous pour commenter.

Commentaires

Laissez une réponse

Répondez de manière anonyme ou connectez-vous pour répondre.