Übung: Bereitstellen eines Microservicecontainers in Kubernetes

7 Minuten

Kubernetes führt Container für Sie aus. Sie beschreiben in einer YAML-Datei, was Kubernetes erledigen soll. In dieser Übung werden Sie durch die Erstellung der Datei geführt, damit Sie den Back-End-Dienst in Kubernetes bereitstellen und ausführen können.

Wichtig

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 der Implementierung

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

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
```
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 einfach den curl-Befehl separat aus.

Fügen Sie das Kubernetes-Repository zu Ihrer apt-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

Jetzt können Sie das Tool kubectl installieren:

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

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 Datei erstellen, um die Containerbereitstellung in Kubernetes mit einer YAML-Datei zu verwalten. Erstellen wir eine Datei zum Bereitstellen des Back-End-Diensts.

Erstellen Sie eine neue Datei im Ordner donet-kubernetes des Codespace mit dem Namen back-end-deploy.yml.

Kopieren Sie den folgenden Text in die Datei, und speichern Sie sie dann.

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

Ersetzen Sie den Platzhalter [YOUR DOCKER USER NAME] durch Ihren realen Docker-Benutzernamen.

Diese Datei führt eine Reihe von Aktionen aus.

Der erste Teil definiert eine Bereitstellungsspezifikation für den Container, der in Kubernetes bereitgestellt werden soll. Hiermit wird angegeben, dass es ein Replikat gibt, wo sich das Containerimage befindet und welche Ports im Container geöffnet werden sollen. Außerdem werden einige Umgebungsvariablen festgelegt. In diesem ersten Teil sind außerdem Bezeichnungen und Namen definiert, die zum Verweisen auf den Container und die Spezifikation verwendet werden können.

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

Lassen Sie uns als Nächstes den Microservice bereitstellen und ausführen.

Führen Sie auf der Registerkarte TERMINAL den folgenden Befehl aus:
```
kubectl apply -f backend-deploy.yml
```
Mit diesem Befehl wird Kubernetes aufgefordert, die erstellte Datei auszuführen. Er lädt das Image von Docker Hub herunter und erstellt den Container.
Der Befehl kubectl apply gibt schnell eine Ausgabe zurück. Die Containererstellung kann jedoch eine Weile dauern. Verwenden Sie den folgenden Code, um den Fortschritt anzuzeigen.
```
kubectl get pods
```
In der resultierenden Ausgabe erhalten Sie eine Zeile mit productsbackend, gefolgt von einer Zeichenfolge aus zufälligen Zeichen in der Spalte NAME. Wenn alles bereit ist, wird unter der Spalte READY die Zeichenfolge 1/1 und unter der Spalte STATUSRunning angezeigt.
Wechseln Sie zum Testen des Diensts zur Registerkarte PORTS. Wählen Sie dann rechts neben der lokalen Adresse für den Back-End-Port das Globussymbol aus. Der Browser öffnet eine neue Registerkarte mit dieser Adresse.

Fügen Sie zum Abfragen einiger Produkte an die Adresse /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 Front-End-Diensts

Ähnlich wie beim Back-End-Dienst benötigen Sie auch eine Bereitstellungsdatei für das Front-End.

Erstellen Sie eine neue Datei im Ordner donet-kubernetes mit dem Namen frontend-deploy.yml

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

Ersetzen Sie den Platzhalter [YOUR DOCKER USERNAME] durch Ihren realen Docker-Benutzernamen.

Beachten Sie, dass diese Datei der Datei ähnelt, die wir für den Back-End-Microservice erstellt haben. 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.
- Es gibt eine neue Umgebungsvariable im Abschnitt spec.template.spec.containers.env. 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 und die IP-Adresse des Back-End-Microservice nicht kennen, verwenden wir den Namen, den wir unter dem Knoten metadata.name von Deployment angegeben haben. Kubernetes kümmert sich um den Rest.
Stellen Sie den Container mit dem folgenden Befehl in Kubernetes bereit:
```
kubectl apply -f frontend-deploy.yml
```
Sie können auch hier kubectl get pods verwenden, um den Status der Bereitstellung anzuzeigen. Sobald in der Zeile für storefrontend in der Spalte STATUS der Status Running angezeigt wird, ist alles einsatzbereit.
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.
Wählen Sie Produkte aus. Im Katalog werden die Waren von Contoso angezeigt.

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

Weiter

Installieren von Kubernetes-Tools und der Implementierung

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

Bereitstellen und Ausführen des Back-End-Microservice

Erstellen einer Bereitstellungsdatei und Ausführen des Front-End-Diensts

Feedback