Ingress gebruiken voor toegang tot RabbitMQ op een Microk8s cluster

Enige tijd geleden heb ik een bericht gemaakt over het verplaatsen van een deel van een applicatie die RabbitMQ bevatte die draaide op Docker Swarm naar Microk8s. We gebruikten NodePort om toegang te krijgen tot het Kubernetes cluster RabbitMQ op de host.

Onlangs heb ik dit heroverwogen en besloten om de Microk8s Ingress Controller te gebruiken om toegang te krijgen tot RabbitMQ.
In deze post gaan we ervan uit dat de RabbitMQ pod aanwezig is en richten we ons alleen op het up-and-running krijgen van de Ingress Controller .

Hieronder staat 'kubectl' voor 'microk8s kubectl'.

Zoals altijd doe ik dit op Ubuntu 22.04.

Waarschuwing: De standaardconfiguratie van Ingress Controller conflicteert met toepassingen die al poorten 80 en 443 gebruiken.

De Microk8s Ingress Controller is gebaseerd op Nginx en schakelt standaard poorten 80 en 443 in. Als je al een andere applicatie op je systeem hebt draaien die deze poorten gebruikt, zoals Nginx, dan heb je een probleem als je de Ingress Controller inschakelt.
In mijn geval werkte mijn bestaande Nginx server niet meer ... :-(

Om dit te voorkomen moet je de poorten van de Ingress Controller veranderen in niet veel gebruikte poorten VOORDAT je hem inschakelt:

80  -> 9480
443 -> 9483

We doen dit door de ports sectie in het bestand aan te passen:

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

Hier is hoe het eruit ziet na het bewerken:

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

In- en uitschakelen van de Microk8s Ingress Controller

Nu kunnen we veilig de Ingress Controller inschakelen:

microk8s enable ingress

Resultaat:

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

Om de Ingress Controller later uit te schakelen, gebruiken we:

microk8s disable ingress

Om te controleren of de pod Ingress Controller draait:

kubectl -n ingress get pod

Resultaat:

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

We kunnen de logs controleren:

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

Resultaat:

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

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

Controleer of Ingress luistert op de poort die we hebben opgegeven:

wget 127.0.0.1:9480

Resultaat:

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

Ziet er goed uit, het reageert! Zoals je kunt zien is de Microk8s Ingress Contreoller gebaseerd op de Nginx webserver.

Ingress verbinden met RabbitMQ in het Microk8s cluster

Om dit te bereiken moeten we het volgende doen:

1. Bewerk de Ingress Controller daemonset
2. Bewerk de Ingress Controller TCP config map
3. Een Ingress YAML bestand maken: 'rabbitmq-ingress.yaml'

Belangrijk:

• De naam van de RabbitMQ service is 'rabbitmq-service', de poort is 5672.
• RabbitMQ staat in de standaard namespace. Wijzig deze als u een andere naamruimte gebruikt.

1. Bewerk de Ingress Controller daemonset

Hier voegen we een containerPort, 5672, en een hostPort, 9493, toe. Om de daemonset van onze Ingress Controller te bewerken:

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

De 'ports' sectie voor de bewerking:

        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

Bewerken zodat het er zo uitziet. We laten de andere poorten zoals ze zijn:

        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

Opslaan en afsluiten.

2. Bewerk de Ingress Controller TCP config map

Hier routeren we extern TCP/UDP-verkeer van niet-HTTP-protocollen naar interne services met behulp van TCP/UDP-poorttoewijzingen.

Om alle config maps van de Ingress Controller te krijgen:

kubectl -n ingress get configmap

Resultaat:

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

Om de TCP config map te bewerken:

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

Voeg de volgende regels toe:

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

Controleer of dit is gedaan:

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

Resultaat:

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. Een Ingress YAML bestand maken

Tot slot maken we het volgende YAML bestand '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

De Ingress Controller implementeren

Na het voltooien van de bovenstaande stappen kunnen we de Ingress Controller implementeren:

kubectl apply -f rabbitmq-ingress.yaml

Resultaat:

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

Controleer meer informatie:

kubectl describe ingress rabbitmq-ingress

Resultaat:

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>

Controleer of de IP address overeenkomt met de RabbitMQ service!

Als je later de Ingress Controller wilt verwijderen:

kubectl delete ingress rabbitmq-ingress

Test op de host met Pika

Deze blog gaat over Python, dus hier gebruiken we het Pika pakket om een eenvoudig testprogramma te maken.

# 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()

Meervoudige Ingress Controllers

Het kan zijn dat je nog een route wilt toevoegen tussen de host en het cluster. Het is ook mogelijk om meerdere Ingress Controllers te gebruiken.

Samenvatting

Ik heb dit zonder veel problemen aan de praat gekregen. Als je de IP address hierboven bekijkt, zul je zien dat dit de IP address van de RabbitMQ pod is. Het lijkt erop dat de Ingress Controller verbinding maakt met de RabbitMQ pod, niet met de RabbitMQ service!
Dit lijkt correct te zijn (?). Hmmm ... zal hier later naar kijken ...

Links / credits

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