Was ist Ingress Controller und wie wird Nginx Ingress Controller in Kubernetes Cluster auf AWS mit Helm bereitgestellt?

Bevor wir mit der Installation des Nginx Ingress Controllers fortfahren, lassen Sie uns kurz sehen, was Ingress und Ingress Controller ist. Der Schwerpunkt dieses Artikels liegt auf der Einrichtung. Es wird davon ausgegangen, dass Sie mit allen Voraussetzungen für die Einrichtung des Nginx Ingress Controllers im Kubernetes-Cluster vertraut sind.

Kubernetes-Ingress

Es handelt sich um ein Kubernetes-Objekt, das den externen Zugriff auf die Dienste im Kubernetes-Cluster verwaltet. Es stellt HTTP- und HTTPS-Routen von außerhalb des Kubernetes-Clusters zu den Diensten innerhalb des Kubernetes-Clusters zur Verfügung.

Ingress-Controller

Um Ingress zu verwenden, müssen Sie den Ingress Controller im Kubernetes-Cluster haben. Er ist nicht Teil des Kubernetes-Clusters wie andere Controller im Cluster, er startet nicht automatisch im Cluster. Wir können eine beliebige Anzahl von Ingress Controllern im Kubernetes-Cluster bereitstellen. Dazu sollten wir jeden Ingress mit der entsprechenden ingress.class annotieren. Es gibt viele verschiedene Arten von Ingress Controllern. Der Ingress Controller ist ein LoadBalancer für Kubernetes-Umgebungen. Er wird als Traffic-Management-Lösung für Kubernetes-Umgebungen eingesetzt.

In diesem Artikel sehen wir uns die Installation des Nginx Ingress Controllers mit Helm auf dem mit Kops eingerichteten Kubernetes Cluster an. Um mehr über den Nginx Ingress Controller im Detail zu erfahren, besuchen Sie die offizielle Dokumentation hier.

Vorraussetzungen

1. AWS-Konto ( Erstellen Sie es, wenn Sie noch keines haben).
2. Kops 1.18.2 auf Ihrem Rechner installiert (Klicken Sie hier, um zu erfahren, wie Sie einen Kubernetes-Cluster mit Kops erstellen und mehr darüber erfahren).
3. Helm v3.5.3 (Klicken Sie hier , um zu lernen, wie Sie Helm auf Ubuntu Server installieren)
4. S3 Bucket ( Klicken Sie hier, um zu lernen, wie man ein S3 Bucket auf AWS erstellt).
5. Domain-Name (Klicken Sie hier, um zu erfahren, wie Sie eine Domain auf AWS registrieren).
6. IAM-Rolle mit Admin-Rechten (Klicken Sie hier, um zu lernen, wie Sie eine IAM-Rolle auf AWS erstellen).

Was werden wir tun?

1. Erstellen eines Kubernetes-Clusters mithilfe von Kops
2. Nginx-Ingress-Controller mit Helm einrichten
3. Erstellen eines Recordsets in Route53, das auf den vom Nginx Ingress Controller erstellten LoadBalancer zeigt
4. Erstellen von Objektdefinitionsdateien für eine Beispielanwendung
5. Deployen einer Beispielanwendung
6. Bereitstellen eines Ingress-Objekts

Erstellen eines Kubernetes-Clusters mit Kops

Bevor Sie mit der Erstellung des Clusters fortfahren, exportieren Sie Ihre AWS IAM User-Zugangs- und Geheimschlüssel mit den folgenden Befehlen.

export AWS_ACCESS_KEY_ID=<your-aws-access-key-here> #Export AWS Access Key

export AWS_SECRET_ACCESS_KEY=<your-aws-secret-key-here> ##Export AWS Secret Key export

Now, export the KOPS_STATE_STORE variable with value as S3 bucket name on your terminal.

KOPS_STATE_STORE=s3://<s3-bucket-name>

Wenn Sie zum ersten Mal einen Cluster mit Kops erstellen und das oben angegebene S3-Bucket zum Speichern der Clusterkonfiguration verwenden, sollten Sie keine Cluster sehen, wenn Sie versuchen, Cluster mit dem folgenden Befehl abzurufen.

kops get clusters

Besuchen Sie die in den Voraussetzungen angegebene Dokumentation, um Kops im Detail zu verstehen. Um hier einen Kubernetes-Cluster zu erstellen, führen Sie den folgenden Befehl aus, indem Sie die Werte ersetzen. Ich werde hier nicht ins Detail gehen.

kops create cluster --name <subdomain.domain.com> --state s3://<s3-bucket> --cloud aws --master-size t2.small --master-count 1 --master-zones us-east-1a --node-size t2.small --node-count 2 --zones us-east-1a,us-east-1b,us-east-1c

Sie können einige Befehle in dem Vorschlag sehen.

Wenn Sie jetzt versuchen, die Clusterkonfiguration zu erhalten, sehen Sie in der Ausgabe den Clusternamen zusammen mit Cloud und Zones.

Bis zu diesem Zeitpunkt wurde der Cluster noch nicht erstellt, führen Sie den folgenden Befehl aus, um die Cluster-Konfiguration zu aktualisieren.

kops update cluster --name kops.devopslee.com

Sie müssen den obigen Befehl noch mit der Option –yes ausführen, damit die Cluster-Ressourcen erstellt werden.

kops update cluster --name kops.devopslee.com --yes

Überprüfen Sie, ob der Cluster bereit ist oder nicht.

kops validate cluster --wait 10m

Sie müssen einige Zeit warten, bis der Cluster gesund ist.

kops validate cluster --wait 10m

Sobald der Cluster betriebsbereit ist, können Sie die Standard-Pods in allen Namespaces mit dem folgenden Befehl überprüfen.

kubectl get pods -A

Einrichten des Nginx-Ingress-Controllers mit Helm

Sobald der Kubernetes-Cluster bereit und gesund ist, können Sie loslegen und den Nginx Ingress Controller mithilfe von Helm installieren.

Bevor Sie fortfahren, stellen Sie sicher, dass Sie Helm v3.5.3 haben.

Hinweis: Ich habe das Helm-Binary verwendet, das an meinem aktuellen Standort vorhanden ist, daher sehen Sie ./helm in den Screenshots.

helm version

Fügen Sie das Repo hinzu und installieren Sie das Nginx Ingress Controller Helm-Diagramm mit den folgenden Befehlen. Um Helm zu verstehen, lesen Sie die im Abschnitt „Voraussetzungen“ erwähnte Dokumentation.

helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx

helm repo update

helm install nginx-ingress ingress-nginx/ingress-nginx --set controller.publishService.enabled=true

Im obigen Screenshot können Sie sehen, dass das Helm-Diagramm installiert wurde.

Sie können die Ressourcen überprüfen, die als Teil des Ingress Controllers erstellt wurden.

kubectl get pods

kubectl get deployment

kubectl get service

Im obigen Screenshot können Sie sehen, dass der Service „nginx-ingress-ingress-nginx-controller“ vom Typ LoadBalancer ebenfalls erstellt wurde. Das bedeutet, dass ein LoadBalancer im AWS-Konto erstellt wurde.

Erstellen Sie ein Recordset in Route53, das auf den vom Nginx-Ingress-Controller erstellten LoadBalancer zeigt

Gehen Sie zu Ihrem AWS-Konto in der Region, in der Sie Ihren Kubernetes-Cluster erstellt haben. Prüfen Sie den LoadBalancer und kopieren Sie seinen DNS-Namen.

Gehen Sie nun zu Route53 und erstellen Sie einen einzelnen A Record in der HostedZone.

Sobald wir einen gültigen Datensatz erstellt haben, wird dieser Datensatz verwendet, um den Datenverkehr über den von uns erstellten Nginx-Ingress-Controller an den Kubernetes-Cluster zu leiten. In diesem Fallwird kops.devopslee.com den Verkehr über den Nginx-Ingress-Controller an die Dienste im Kubernetes-Cluster weiterleiten.

Erstellen von Objektdefinitionsdateien für eine Beispielanwendung

Lassen Sie uns nun Objektdefinitionsdateien erstellen, um eine Beispielanwendung zu deployen. Wir werden 3 Anwendungen mit 3 Deployments und 3 entsprechenden Services für die Deployments bereitstellen. Anschließend erstellen wir eine Ingress-Ressource mit pfadbasiertem Routing, um den Datenverkehr anhand des Pfades über kops.devopslee.com zu unseren Anwendungen zu leiten.

Erstellen Sie 1-nginx-main-app.yaml für Anwendung 1.

Github-Link: Klicken Sie hier, um die Datei aus meinem Github Repo zu kopieren.

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: nginx
  name: nginx-deploy-main
spec:
  replicas: 1
  selector:
    matchLabels:
      run: nginx-main
  template:
    metadata:
      labels:
        run: nginx-main
    spec:
      containers:
      - image: nginx
        name: nginx


---
apiVersion: v1
kind: Service
metadata:
  name: nginx-deploy-main
spec:
  type: ClusterIP
  ports:
  - port: 80
    targetPort: 80
  selector:
    run: nginx-main

Erstellen Sie 2-nginx-green-app.yaml für die Anwendung 2.

Github-Link: Klicken Sie hier, um die Datei aus meinem Github Repo zu kopieren.

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: nginx
  name: nginx-deploy-green
spec:
  replicas: 1
  selector:
    matchLabels:
      run: nginx-green
  template:
    metadata:
      labels:
        run: nginx-green
    spec:
      volumes:
      - name: webdata
        emptyDir: {}
      initContainers:
      - name: web-content
        image: busybox
        volumeMounts:
        - name: webdata
          mountPath: "/webdata"
        command: ["/bin/sh", "-c", 'echo "<h1>I am <font color=green>GREEN</font></h1>" > /webdata/index.html']
      containers:
      - image: nginx
        name: nginx
        volumeMounts:
        - name: webdata
          mountPath: "/usr/share/nginx/html"


---
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-deploy-green
spec:
  type: ClusterIP
  ports:
  - port: 80
    targetPort: 80
  selector:
    run: nginx-green

Erstellen Sie 3-nginx-blue-app.yaml für Anwendung 3

Github-Link: Klicken Sie hier, um die Datei aus meinem Github-Repo zu kopieren.

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: nginx
  name: nginx-deploy-blue
spec:
  replicas: 1
  selector:
    matchLabels:
      run: nginx-blue
  template:
    metadata:
      labels:
        run: nginx-blue
    spec:
      volumes:
      - name: webdata
        emptyDir: {}
      initContainers:
      - name: web-content
        image: busybox
        volumeMounts:
        - name: webdata
          mountPath: "/webdata"
        command: ["/bin/sh", "-c", 'echo "<h1>I am <font color=blue>BLUE</font></h1>" > /webdata/index.html']
      containers:
      - image: nginx
        name: nginx
        volumeMounts:
        - name: webdata
          mountPath: "/usr/share/nginx/html"


---
apiVersion: v1
kind: Service
metadata:
  name: nginx-deploy-blue
spec:
  type: ClusterIP
  ports:
  - port: 80
    targetPort: 80
  selector:
    run: nginx-blue

Erstellen Sie 4-ingress.yaml für die Erstellung pfadbasierter Ingress-Regeln.

Github-Link: Klicken Sie hier, um die Datei aus meinem Github-Repo zu kopieren.

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
  name: ingress-resource
spec:
  rules:
  - host: kops.devopslee.com
    http:
      paths:
      - path: /
        backend:
          serviceName: nginx-deploy-main
          servicePort: 80
      - path: /blue
        backend:
          serviceName: nginx-deploy-blue
          servicePort: 80
      - path: /green
        backend:
          serviceName: nginx-deploy-green
          servicePort: 80

Sie finden alle diese Dateien in meinem Github Repo hier.

Bereitstellen von Beispielanwendungen

Lassen Sie uns eine Beispielanwendung nach der anderen bereitstellen und ihren Status überprüfen.

kubectl apply -f 1-nginx-main-app.yaml

kubectl apply -f 2-nginx-green-app.yaml

kubectl apply -f 3-nginx-blue-app.yaml

kubectl get deployments

kubectl get pods

kubectl get service

Bereitstellen eines Ingress-Objekts

Nun ist es an der Zeit, eine pfadbasierte Routing-Ingress-Ressource zu erstellen. Überprüfen Sie gleichzeitig die Protokolle des Nginx-Pods.

kubectl logs nginx-ingress-ingress-nginx-controller-5c97c6b4d5-btvpl -f

kubectl apply -f 4-ingress.yaml

Sobald die Ingress-Ressource erstellt ist, können Sie sehen, dass der Nginx seine Konfiguration geladen hat.

Und nun sind 3 verschiedene Anwendungen bereit, auf die über denselben Hostnamen, d. h. kops.devopslee.com, auf verschiedenen Pfaden zugegriffen werden kann.

Die URLs für die Anwendungen, hier der Hostname, werden für Sie unterschiedlich lauten.

nginx-deploy-main kann unter kops.devopslee.com aufgerufen werden

nginx-deploy-green kann unter kops.devopslee.com/green aufgerufen werden und

nginx-deploy-blue kann unter kops.devopslee.com/blueaufgerufen werden

Sie können sehen, dass 3 verschiedene Anwendungen über denselben Hostnamen auf Basis des Pfads aufgerufen werden können.

Fazit

In diesem Artikel haben wir die Schritte zum Erstellen eines Kubernetes-Clusters mit Kops gesehen. Dieser Artikel konzentrierte sich hauptsächlich auf das Einrichten des Nginx-Ingress-Controllers mit Helm und das Erstellen eines pfadbasierten Routings mit der Ingress-Ressource. Wir haben 3 verschiedene Beispielanwendungen implementiert und versucht, mit demselben Hostnamen und unterschiedlichen Pfaden auf sie zuzugreifen.