So stellen Sie eine Multi-Tier-Anwendung mit Kubernetes bereit

Eine mehrschichtige Anwendung ist eine Anwendung, die auf mehr als eine Ebene verteilt ist. Es trennt die operativen Schichten logisch. Die Anzahl der Ebenen variiert je nach Geschäfts- und Anwendungsanforderungen. In diesem Artikel sehen wir eine Anwendung, die in 2 Schichten unterteilt ist, Backend- und Frontend-Schicht. Wir werden MongoDB als Backend zum Speichern von Daten und Python Flask als Frontend-Webserver verwenden. Wir werden diese beiden Anwendungen mithilfe von Bereitstellungen in Kubernetes bereitstellen und über Dienste verfügen, um Anfragen an sie weiterzuleiten.

Voraussetzungen

1. Kubernetes-Cluster mit mindestens 1 Worker-Knoten.
   Wenn Sie erfahren möchten, wie Sie einen Kubernetes-Cluster erstellen, klicken Sie hier. Dieser Leitfaden hilft Ihnen beim Erstellen eines Kubernetes-Clusters mit 1 Master und 2 Knoten auf AWS Ubuntu 18.04 EC2-Instances.
2. Grundlegendes Verständnis von Bereitstellungen und Diensten.
   Beziehen Sie sich auf Bereitstellungen und Dienste , um ein grundlegendes Verständnis zu erlangen.

Was werden wir tun?

1. Stellen Sie eine Multi-Tier-Anwendung bereit

Stellen Sie eine Multi-Tier-Anwendung bereit

Erstellen Sie eine neue Datei namens „test-db-deployment.yaml“ mit folgendem Inhalt. Dadurch wird eine Bereitstellung von MongoDB definiert, die als Datenbank, als Backend-Schicht, fungiert.

vim test-db-deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: test-db
spec:
  selector:
    matchLabels:
      appdb: testdb
  replicas: 1
  template:
    metadata:
      labels:
        appdb: testdb
    spec:
      containers:
      - name: test-db
        image: mongo:3.3
        env:
        - name: MONGODB_DATABASE
          value: testdata
        ports:
        - containerPort: 27017

Erstellen Sie jetzt einen Dienst, der Anfragen an die MongoDB von unserer Frontend-Anwendung bedient. Dieser Dienst lauscht auf Port 27017 und leitet Anfragen an MongoDB auf demselben Port weiter.

vim test-db-service.yaml

apiVersion: v1
kind: Service
metadata:
  name: mongodb
  labels:
    app: testdb
spec:
  ports:
  - port: 27017
    protocol: TCP
  selector:
    appdb: testdb

Der nächste Schritt besteht darin, eine Frontend-Anwendung zu definieren. Erstellen Sie eine neue Datei mit der folgenden Bereitstellungsdefinition.

Dies wird auf Port 5000 lauschen.

Anfragen an MongoDB werden an MONGODB_HOST weitergeleitet, d. h. Mongodb-Dienst.

vim test-web-deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: test
spec:
  selector:
    matchLabels:
      app: test
  replicas: 1
  template:
    metadata:
      labels:
        app: test
    spec:
      containers:
      - name: test-app
        image: teamcloudyuga/rsvpapp
        env:
        - name: MONGODB_HOST
          value: mongodb
        ports:
        - containerPort: 5000
          name: web-port

Um auf das Frontend zuzugreifen, erstellen wir einen Dienst vom Typ NodePort, der Port 31081 überwacht. Das bedeutet, dass auf den Python Flask-Webserver über IP=IP-Of-Any-Node zugegriffen werden kann und Port=31081. Erstellen Sie eine neue mit der folgenden Dienstdefinition.

vim test-web-service.yaml

apiVersion: v1
kind: Service
metadata:
  name: test
  labels:
    apps: test
spec:
  type: NodePort
  ports:
  - name: tcp-31081-5000
    nodePort: 31081
    port: 5000
    protocol: TCP
  selector:
    app: test

Nun sind wir bereit, eine zweistufige Beispielanwendung zu erstellen. Bevor wir fortfahren, prüfen wir, ob der Cluster Objekte enthält.

Führen Sie die folgenden Befehle aus, um Pods, Bereitstellungen und Dienste zu überprüfen, die im Cluster ausgeführt werden.

kubectl erhält Pods

kubectl Bereitstellungen abrufen

kubectl-Get-Service

Im obigen Screenshot ist zu sehen, dass es nur 1 Kubernetes-Standarddienst im Cluster gibt.

Führen Sie nun nacheinander den folgenden Befehl aus dem Verzeichnis aus, in dem Sie 4 Dateien erstellt haben, um die MongoDB-Bereitstellung, den MongoDB-Dienst, die Python-Flask-Webserver-Bereitstellung und den  Python-Flask-Webserver-Dienst zu erstellen.

kubectl create -f test-db-deployment.yaml

kubectl create -f test-db-service.yaml

kubectl create -f test-web-deployment.yaml

kubectl create -f test-web-service.yaml

Im obigen Screenshot können Sie sehen, dass die MongoDB-Bereitstellung, der MongoDB-Dienst, die Bereitstellung des Python Flask-Webservers und der  Python Flask-Webserver-Dienst erfolgreich erstellt wurden.

Um dasselbe zu überprüfen, führen Sie die folgenden Befehle aus.

kubectl erhält Pods

kubectl Bereitstellungen abrufen

kubectl-Get-Service

Im folgenden Screenshot sehen Sie, dass 2 Pods und 2 Dienste erstellt wurden. Die erstellten Pods werden von der von uns erstellten Bereitstellung gesteuert.

Nun sind wir bereit, auf die Anwendung über IP-of-any-Node:NodePort zuzugreifen, d. h. IP-of-any-Node:31081.

Sobald Sie im Browser auf die URL klicken, sehen Sie die Anwendung wie folgt. Dies ist eine Beispielanwendung, die das öffentlich verfügbare Docker-Image verwendet und zu CloudYuga gehört. Hier können Sie sehen, dass die RSVP-Zählung 0 ist, was bedeutet, dass MongoDB keine Daten enthält.

Jetzt können wir ein paar Demo-Einträge hinzufügen.

Nachdem wir einige Einträge hinzugefügt haben, können wir sehen, dass sich die Anzahl geändert hat. Das bedeutet, dass die Daten in MongoDB gespeichert wurden.

Wenn Sie diese Anwendungen jetzt nicht mehr benötigen, können Sie alle Objekte löschen, indem Sie den folgenden Befehl aus dem Verzeichnis ausführen, in dem sich alle Ihre Kubernetes-Objektdateien befinden.

kubectl delete -f .

Der obige Befehl löscht die MongoDB-Bereitstellung, den MongoDB-Dienst, die Python Flask-Webserver-Bereitstellung und den von uns erstellten  Python Flask-Webserver-Dienst.

Um zu überprüfen, ob alle von uns erstellten Objekte erfolgreich gelöscht wurden, führen Sie den folgenden Befehl aus.

kubectl alles abrufen

Im folgenden Screenshot können Sie sehen, dass es nur einen Standard-Kubernetes-Dienst gibt und die von uns erstellten Objekte nicht mehr existieren.

Schlussfolgerung

In diesem Artikel haben wir eine Bereitstellung der MongoDB-Back-End-Datenbank und des Dienstes erstellt, um auf die Datenbank zuzugreifen, und für das Front-End haben wir eine Python Flask-basierte Anwendungsbereitstellung und einen Dienst erstellt, um darauf zuzugreifen Vorderes Ende. Wir haben auch gesehen, dass die Daten in der Back-End-Datenbank gespeichert wurden. Dies ist eine zweischichtige Beispielanwendung, die öffentlich verfügbare Docker-Images verwendet.