GNU/Linux >> LINUX-Kenntnisse >  >> Linux

Was ist Ingress Controller und wie stellt man Nginx Ingress Controller in Kubernetes Cluster on AWS mit Helm bereit

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

Kubernetes-Ingress

Es ist 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 für die Dienste innerhalb des Kubernetes-Clusters bereit.

Ingress-Controller

Um Ingress verwenden zu können, muss der Ingress-Controller im Kubernetes-Cluster vorhanden sein. Er ist nicht Teil des Kubernetes-Clusters wie andere Controller im Cluster und 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. Ingress Controller ist ein LoadBalancer für Kubernetes-Umgebungen. Es wird als Traffic-Management-Lösung für Kubernetes-Umgebungen verwendet.

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

Voraussetzungen

  1. AWS-Konto (erstellen, falls Sie noch keins haben).
  2. Kops 1.18.2 auf Ihrem Computer installiert (Klicken Sie hier, um zu erfahren, wie Sie mit Kops einen Kubernetes-Cluster erstellen und mehr darüber erfahren.)
  3. Helm v3.5.3  (Klicken Sie hier, um zu erfahren, wie Sie Helm auf Ubuntu Server installieren)
  4. S3-Bucket (Klicken Sie hier, um zu erfahren, wie Sie einen S3-Bucket auf AWS erstellen).
  5. Domänenname (Klicken Sie hier, um zu erfahren, wie Sie eine Domäne bei AWS registrieren).
  6. IAM-Rolle mit Administratorberechtigungen (Klicken Sie hier, um zu erfahren, wie Sie eine IAM-Rolle auf AWS erstellen).

Was werden wir tun?

  1. Erstellen Sie einen Kubernetes-Cluster mit Kops
  2. Nginx Ingress Controller mit Helm einrichten
  3. Erstellen Sie ein Recordset in Route53, das auf den LoadBalancer verweist, der vom Nginx Ingress Controller erstellt wurde
  4. Objektdefinitionsdateien für eine Beispielanwendung erstellen
  5. Stellen Sie eine Beispielanwendung bereit
  6. Stellen Sie ein Ingress-Objekt bereit

Erstellen Sie einen Kubernetes-Cluster mit Kops

Bevor Sie mit der Erstellung des Clusters fortfahren, exportieren Sie Ihren AWS IAM-Benutzerzugriff und Ihre geheimen Schlü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 den oben angegebenen S3-Bucket zum Speichern der Clusterkonfiguration verwenden, sollten Sie keine Cluster sehen, wenn Sie versuchen, Cluster mit dem folgenden Befehl abzurufen.

kops get clusters

Rufen Sie die unter Voraussetzungen angegebene Dokumentation auf, um Kops im Detail zu verstehen. Um hier einen Kubernetes-Cluster zu erstellen, führen Sie den folgenden Befehl aus, indem Sie 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 im Vorschlag sehen.

Wenn Sie jetzt versuchen, die Clusterkonfiguration abzurufen, sehen Sie in der Ausgabe den Clusternamen zusammen mit Cloud und Zonen.

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 trotzdem mit --yes als Option ausführen, damit 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, während der Cluster fehlerfrei wird.

kops validate cluster --wait 10m

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

kubectl get pods -A

Nginx Ingress Controller mit Helm einrichten

Sobald der Kubernetes-Cluster bereit und fehlerfrei ist, können Sie loslegen und Nginx Ingress Controller mit Helm installieren.

Bevor Sie fortfahren, vergewissern Sie sich, dass Sie Helm v3.5.3 haben.

Hinweis:Ich habe die an meinem aktuellen Standort vorhandene Helm-Binärdatei verwendet, daher können Sie ./helm in Screenshots sehen.

helm version

Fügen Sie das Repo hinzu und installieren Sie das Nginx Ingress Controller Helm-Diagramm mit den folgenden Befehlen. Informationen zum Verständnis von Helm finden Sie in der Dokumentation, die im Abschnitt „Voraussetzungen“ erwähnt wird.

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 sehen Sie, dass das Helm-Chart 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 sehen Sie, dass auch der Dienst „nginx-ingress-ingress-nginx-controller“ vom Typ LoadBalancer erstellt wurde. Dies bedeutet, dass im AWS-Konto ein LoadBalancer erstellt wurde.

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

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

Gehen Sie jetzt zu Route53 und erstellen Sie einen einzelnen A-Eintrag in der HostedZone.

Sobald wir einen gültigen Datensatz erstellt haben, wird der von uns erstellte Datensatz verwendet, um den Datenverkehr über den von uns erstellten Nginx Ingress Controller an den Kubernetes-Cluster weiterzuleiten. In diesem Fall leitet kops.devopslee.com den Datenverkehr über den Nginx Ingress Controller an Dienste im Kubernetes-Cluster weiter.

Objektdefinitionsdateien für eine Beispielanwendung erstellen

Lassen Sie uns nun Objektdefinitionsdateien erstellen, um eine Beispielanwendung bereitzustellen. Wir werden 3 Anwendungen mit 3 Bereitstellungen und 3 entsprechenden Diensten für die Bereitstellungen bereitstellen. Anschließend erstellen wir eine Ingress-Ressource mit pfadbasiertem Routing, um den Datenverkehr basierend auf dem Pfad mithilfe von kops.devopslee.com an unsere Anwendungen weiterzuleiten.

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 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, um pfadbasierte Ingress-Regeln zu erstellen.

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

Alle diese Dateien finden Sie hier in meinem Github-Repo.

Beispielanwendungen bereitstellen

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

Stellen Sie ein Ingress-Objekt bereit

Jetzt 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 Nginx seine Konfiguration geladen hat.

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

URLs für die Anwendungen, der Hostname hier Name wird für Sie anders sein.

Auf nginx-deploy-main kann unter kops.devopslee.com

zugegriffen werden

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

zugegriffen werden

Auf nginx-deploy-blue kann unter kops.devopslee.com/blue

zugegriffen werden

Sie können sehen, dass basierend auf dem Pfad auf 3 verschiedene Anwendungen mit demselben Hostnamen zugegriffen werden kann.

Schlussfolgerung

In diesem Artikel haben wir die Schritte zum Erstellen eines Kubernetes-Clusters mit Kops gesehen. Dieser Artikel konzentrierte sich hauptsächlich auf das Einrichten von Nginx Ingress Controller mit Helm und das Erstellen eines pfadbasierten Routings mit Ingress-Ressourcen. Wir haben 3 verschiedene Beispielanwendungen bereitgestellt und versucht, mit demselben Hostnamen und unterschiedlichen Pfaden darauf zuzugreifen.


Linux

  1. Was ist Helm? Helm und Helmkarten erklärt

  2. So stellen Sie eine WordPress-Instanz auf Kubernetes bereit

  3. Was ist NGINX? Wie funktioniert es?

  4. So stellen Sie Nginx Load Balancing auf einem Kubernetes-Cluster unter Ubuntu 18.04 LTS bereit

  5. So stellen Sie Ihren ersten Pod in einem Kubernetes-Cluster bereit

Was ist EFS (Elastic File System) in AWS und wie wird es verwendet?

Was ist Terraform und wie wird es auf AWS EC2 installiert und verwendet?

So erstellen Sie einen Kubernetes-Cluster mit AWS CLI

So stellen Sie Anwendungen auf Kubernetes mit Helm bereit

So stellen Sie Kubernetes-Cluster auf AWS mit Amazon EKS bereit

So stellen Sie eine PHP-Anwendung mit Nginx und MySQL mit Docker und Docker Compose bereit