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é.

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 :
- Modifier le fichier Ingress Controller daemonset
- Modifier le TCP Ingress Controller config map
- 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
Récent
- Graphique de séries temporelles avec Flask, Bootstrap et Chart.js
- Utiliser IPv6 avec Microk8s
- Utilisation de Ingress pour accéder à RabbitMQ sur un cluster Microk8s
- Galerie vidéo simple avec Flask, Jinja, Bootstrap et JQuery
- Planification de base des tâches avec APScheduler
- Un commutateur de base de données avec HAProxy et HAProxy Runtime API
Les plus consultés
- Utiliser PyInstaller et Cython pour créer un exécutable Python
- Réduire les temps de réponse d'un Flask SQLAlchemy site web
- Utilisation des Python's pyOpenSSL pour vérifier les certificats SSL téléchargés d'un hôte
- Connexion à un service sur un hôte Docker à partir d'un conteneur Docker
- Utiliser UUIDs au lieu de Integer Autoincrement Primary Keys avec SQLAlchemy et MariaDb
- SQLAlchemy : Utilisation de Cascade Deletes pour supprimer des objets connexes