Verwendung von Ingress für den Zugriff auf RabbitMQ auf einem Microk8s -Cluster

Vor einiger Zeit habe ich einen Beitrag über das Verschieben eines Teils einer Anwendung mit RabbitMQ , die auf Docker Swarm läuft, nach Microk8s geschrieben. Wir verwendeten NodePort für den Zugriff auf den Kubernetes -Cluster RabbitMQ auf dem Host.

Kürzlich habe ich dies überdacht und beschlossen, den Microk8s Ingress Controller für den Zugriff auf RabbitMQ zu verwenden.
In diesem Beitrag gehen wir davon aus, dass der RabbitMQ -Pod vorhanden ist, und konzentrieren uns nur darauf, den Ingress Controller zum Laufen zu bringen.

Im Folgenden steht 'kubectl' für 'microk8s kubectl'.

Wie immer mache ich dies auf Ubuntu 22.04.

Achtung! Die Standardkonfiguration von Ingress Controller steht in Konflikt mit Anwendungen, die bereits die Ports 80 und 443 verwenden

Der Microk8s Ingress Controller basiert auf Nginx und aktiviert standardmäßig die Ports 80 und 443. Wenn Sie bereits eine andere Anwendung auf Ihrem System laufen haben, die diese Ports verwendet, wie z.B. Nginx, dann haben Sie ein Problem, wenn Sie den Ingress Controller aktivieren.
In meinem Fall funktionierte mein bestehender Nginx -Server nicht mehr ... :-(

Um dies zu vermeiden, ändern Sie die Ports des Ingress Controller auf wenig genutzte Ports, BEVOR Sie ihn aktivieren:

80  -> 9480
443 -> 9483

Wir tun dies, indem wir den Abschnitt ports in der Datei ändern:

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

So sieht es nach der Bearbeitung aus:

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

Aktivieren und Deaktivieren des Microk8s Ingress Controller

Jetzt können wir den Ingress Controller sicher aktivieren:

microk8s enable ingress

Ergebnis:

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

Um den Ingress Controller später zu deaktivieren, verwenden wir:

microk8s disable ingress

Prüfen, ob der Ingress Controller -Pod läuft:

kubectl -n ingress get pod

Ergebnis:

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

Wir können die Protokolle überprüfen:

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

Ergebnis:

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

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

Prüfen Sie, ob Ingress auf dem angegebenen Port lauscht:

wget 127.0.0.1:9480

Ergebnis:

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

Sieht gut aus, er antwortet! Wie Sie sehen können, basiert der Microk8s Ingress Contreoller auf dem Nginx Webserver.

Verbindung von Ingress mit RabbitMQ im Microk8s -Cluster

Um dies zu erreichen, müssen wir Folgendes tun:

1. Bearbeiten Sie die Ingress Controller daemonset
2. Bearbeiten Sie den Ingress Controller TCP config map
3. Erstellen Sie eine Ingress YAML Datei: 'rabbitmq-ingress.yaml'

Wichtig!

• Der Name des Dienstes RabbitMQ lautet "rabbitmq-service", der Port ist 5672.
• RabbitMQ befindet sich im Standard-Namensraum. Ändern Sie ihn, wenn Sie einen anderen Namensraum verwenden.

1. Bearbeiten Sie die Ingress Controller daemonset

Hier fügen wir eine containerPort, 5672, und hostPort, 9493, hinzu. So bearbeiten Sie die daemonset unserer Ingress Controller:

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

Der Abschnitt "Ports" vor der Bearbeitung:

        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

Bearbeiten Sie ihn so, dass er wie folgt aussieht. Die anderen Ports belassen wir so wie sie sind:

        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

Speichern und beenden.

2. Bearbeiten Sie den Ingress Controller TCP config map

Hier leiten wir externen TCP/UDP-Verkehr von Nicht-HTTP-Protokollen über TCP/UDP-Port-Zuordnungen an interne Dienste weiter.

Um alle config maps der Ingress Controller zu erhalten:

kubectl -n ingress get configmap

Ergebnis:

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

So bearbeiten Sie die TCP config map:

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

Fügen Sie die folgenden Zeilen hinzu:

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

Prüfen Sie, ob dies geschehen ist:

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

Ergebnis:

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. Erstellen einer Ingress YAML -Datei

Schließlich erstellen wir die folgende YAML -Datei '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

Bereitstellung der Ingress Controller

Nach Abschluss der oben genannten Schritte können wir die Ingress Controller bereitstellen:

kubectl apply -f rabbitmq-ingress.yaml

Ergebnis:

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

Prüfen Sie weitere Informationen:

kubectl describe ingress rabbitmq-ingress

Ergebnis:

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>

Prüfen Sie, ob der IP address mit dem RabbitMQ -Dienst übereinstimmt!

Wenn Sie später den Ingress Controller entfernen wollen:

kubectl delete ingress rabbitmq-ingress

Test auf dem Host mit Pika

In diesem Blog geht es um Python, daher verwenden wir hier das Paket Pika , um ein einfaches Testprogramm zu erstellen.

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

Mehrere Ingress Controllers

Möglicherweise möchten Sie eine weitere Route zwischen dem Host und dem Cluster hinzufügen. Es ist auch möglich, mehrere Ingress Controllers zu verwenden.

Zusammenfassung

Ich habe dies ohne große Schwierigkeiten zum Laufen gebracht. Wenn Sie sich den IP address oben ansehen, werden Sie feststellen, dass dies der IP address des RabbitMQ -Pods ist. Es sieht so aus, als würde sich der Ingress Controller mit dem RabbitMQ -Pod verbinden, nicht mit dem RabbitMQ -Dienst!
Dies scheint korrekt zu sein (?). Hmmm ... ich werde mir das später ansehen ...

Links / Impressum

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