Übung: Bereitstellen eines Microservicecontainers in Kubernetes

  • 7 Minuten

Kubernetes führt Container für Sie aus. Sie beschreiben, was Kubernetes über eine YAML-Datei tun soll. Diese Übung führt Sie durch die Erstellung der Datei, damit Sie den Back-End-Dienst auf Kubernetes bereitstellen und ausführen können.

Von Bedeutung

Bevor Sie fortfahren, müssen Sie sicherstellen, dass eine Kubernetes-Implementierung installiert ist. Wir verwenden die im Codespace ausgeführte k3d-Implementierung . Wir starten das Lab, indem wir diese Implementierung installieren.

Installieren von Kubernetes-Tools und -Implementierungen

Wir müssen sowohl das Kubectl-Tool als auch die k3d Kubernetes-Implementierung installieren:

  1. Wechseln Sie im Codespace zur Registerkarte TERMINAL , und führen Sie dann die folgenden Befehle aus, um die erforderlichen Komponenten zu installieren:

    sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl

  2. Führen Sie als Nächstes die folgenden Befehle aus, um den Signaturschlüssel für die Kubernetes-Paketrepositorys herunterzuladen:

    sudo mkdir /etc/apt/keyrings
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.28/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg

    Wenn sie eine Fehlermeldung erhalten, dass das Verzeichnis bereits vorhanden ist, führen Sie den curl Befehl separat aus.

  3. Fügen Sie das Kubernetes-Repository zu Ihrer passenden Konfiguration hinzu:

    echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.28/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list

  4. Jetzt können Sie das Kubectl-Tool installieren:

    sudo apt-get update
sudo apt-get install -y kubectl

  5. Installieren Sie schließlich die k3d-Implementierung von Kubernetes, und erstellen Sie einen Cluster:

    curl -s https://raw.githubusercontent.com/k3d-io/k3d/main/install.sh | bash
k3d cluster create devcluster --config k3d.yml

Erstellen einer Bereitstellungsdatei für den Back-End-Dienst

Sie können eine Dateiverwaltungscontainerbereitstellung in Kubernetes mit einer YAML-Datei erstellen. Erstellen wir eine Datei zum Bereitstellen des Back-End-Diensts.

  1. Erstellen Sie eine neue Datei im Ordner donet-kubernetes des Codespaces mit dem Namen backend-deploy.yml.

  2. Kopieren Sie den folgenden Text in die Datei, und speichern Sie ihn.

    ---
apiVersion: apps/v1
kind: Deployment
metadata:
    name: productsbackend
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: productsbackend
    spec:
      containers:
      - name: productsbackend
        image: [YOUR DOCKER USER NAME]/productservice:latest
        ports:
        - containerPort: 80
        env:
        - name: ASPNETCORE_URLS
          value: http://*:80
  selector:
    matchLabels:
      app: productsbackend
---
apiVersion: v1
kind: Service
metadata:
  name: productsbackend
spec:
  type: NodePort
  ports:
  - port: 80
    targetPort: 80
    nodePort: 32001
  selector:
    app: productsbackend

  3. Ersetzen Sie den Platzhalter [YOUR DOCKER USER NAME] durch Ihren tatsächlichen Docker-Benutzernamen.

Diese Datei erledigt ein paar Dinge.

Der erste Teil definiert eine Bereitstellungsspezifikation für den Container, der in Kubernetes bereitgestellt werden soll. Es gibt ein Replikat an, in dem das Containerimage gefunden werden soll, welche Ports für den Container geöffnet werden sollen, und legt einige Umgebungsvariablen fest. In diesem ersten Teil werden auch Bezeichnungen und Namen definiert, die verwendet werden können, um auf den Container und die Spezifikation zu verweisen.

Der zweite Teil definiert dann, dass der Container als Kubernetes NodePort-Dienst ausgeführt wird. Für dieses Modul müssen Sie nicht alle Besonderheiten von NodePorts verstehen. Sie sollten jedoch wissen, dass dieser Diensttyp eine externe IP-Adresse verfügbar macht, damit Sie den Dienst außerhalb des Clusters testen können.

Bereitstellen und Ausführen des Back-End-Microservice

Als Nächstes stellen wir den Microservice bereit und führen es aus.

  1. Führen Sie auf der Registerkarte TERMINAL den folgenden Befehl aus:

    kubectl apply -f backend-deploy.yml

    Dieser Befehl teilt Kubernetes mit, die von uns erstellte Datei auszuführen. Es lädt das Image von Docker Hub herunter und erstellt den Container.

  2. Der kubectl apply Befehl wird schnell zurückgegeben. Die Containererstellung kann jedoch eine Weile dauern. Verwenden Sie den folgenden Code, um den Fortschritt anzuzeigen.

    kubectl get pods

    In der resultierenden Ausgabe haben Sie eine Zeile mit productsbackend gefolgt von einer Zeichenfolge von zufälligen Zeichen unter der Spalte NAME . Wenn alles bereit ist, wird unter der Spalte BEREIT die Zeichenfolge 1/1 und unter der Spalte STATUS der Text Wird ausgeführt angezeigt.

  3. Um den Dienst zu testen, wechseln Sie zur Registerkarte "PORTS ", und wählen Sie in der Nähe der lokalen Adresse für den Back-End-Port das Globussymbol aus. Der Browser öffnet an dieser Adresse eine neue Registerkarte.

  4. Um einige Produkte abzufragen, fügen Sie die Adresse mit "/api/product " an, und drücken Sie dann die EINGABETASTE. Einige Produktinformationen sollten im JSON-Format aufgeführt sein.

    [
    {
        "id": 1,
        "name": "Solar Powered Flashlight",
        "description": "A fantastic product for outdoor enthusiasts",
        "price": 19.99,
        "imageUrl": "product1.png"
    },
    {
        "id": 2,
        "name": "Hiking Poles",
        "description": "Ideal for camping and hiking trips",
        "price": 24.99,
        "imageUrl": "product2.png"
    },
    {
        "id": 3,
        "name": "Outdoor Rain Jacket",
        "description": "This product will keep you warm and dry in all weathers",
        "price": 49.99,
        "imageUrl": "product3.png"
    },
    ...

Erstellen einer Bereitstellungsdatei und Ausführen des Frontend-Diensts

Ähnlich wie der Back-End-Dienst benötigen wir auch eine Bereitstellungsdatei für das Frontend.

  1. Erstellen einer neuen Datei im Ordner "donet-kubernetes " mit dem Namen frontend-deploy.yml

  2. Fügen Sie den folgenden Code in die Datei ein:

    ---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: storefrontend
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: storefrontend
    spec:
      containers:
      - name: storefrontend
        image: [YOUR DOCKER USER NAME]/storeimage:latest
        ports:
        - containerPort: 80
        env:
        - name: ASPNETCORE_URLS
          value: http://*:80
        - name: ProductEndpoint
          value: http://productsbackend
  selector:
    matchLabels:
      app: storefrontend
---
apiVersion: v1
kind: Service
metadata:
  name: storefrontend
spec:
  type: NodePort
  ports:
  - port: 80
    targetPort: 80
    nodePort: 32000
  selector:
    app: storefrontend

  3. Ersetzen Sie den Platzhalter [YOUR DOCKER USERNAME] durch Ihren tatsächlichen Docker-Benutzernamen.

    Beachten Sie, dass diese Datei dem für den Back-End-Microservice erstellten ähnelt. Es gibt zwei Unterschiede:

    • Wir geben unter dem Wert spec.template.spec.containers.image der Bereitstellung einen anderen Container für die Ausführung an.
    • Unter dem spec.template.spec.containers.env Abschnitt gibt es eine neue Umgebungsvariable. Der Code in der storefrontend-Anwendung ruft das Back-End auf, aber da wir keinen vollqualifizierten Domänennamen (Fully Qualified Domain Name, FQDN) angegeben haben, wissen wir nicht die IP-Adresse des Back-End-Microservice, wir verwenden den Namen, den wir unter dem metadata.name Knoten des Deployment. Kubernetes kümmert sich um den Rest.

  4. Stellen Sie den Container mit dem folgenden Befehl in Kubernetes bereit:

    kubectl apply -f frontend-deploy.yml

    Sie können erneut kubectl get pods verwenden, um den Status der Bereitstellung anzuzeigen. Sobald in der Zeile für storefrontend in der Spalte STATUS der Status Wird ausgeführt angezeigt wird, ist alles einsatzbereit.

  5. Wechseln Sie zum Testen des Front-End-Diensts zur Registerkarte PORTS, und wählen Sie dann rechts neben der lokalen Adresse für den Front-End-Port das Globussymbol aus. Im Browser wird die Homepage angezeigt.

  6. Wählen Sie "Produkte" aus. Im Katalog werden die Waren von Contoso angezeigt.

    Screenshot der Seite

In dieser Übung haben Sie eine Bereitstellungsdatei erstellt, die genau beschrieben hat, wie die Container in Kubernetes ausgeführt werden sollen. Anschließend ließ man Kubernetes das Image von Docker Hub herunterladen und die Container starten.