Hosten einer neuen Datenbank mit Azure Cosmos DB

  • 15 Minuten

Nachdem Sie die grundlegenden Konzepte externer Zustände und den Umgang damit in Kubernetes kennengelernt haben, werden Sie nun die Ressourcen, die die Anwendung Ihres Logistikunternehmens unterstützen, und anschließend die Anwendung selbst erstellen.

Erstellen einer Ressourcengruppe

Wichtig

Sie benötigen für diese Übung ein eigenes Azure-Abonnement. Außerdem fallen möglicherweise Gebühren für Sie an. Wenn Sie noch kein Azure-Abonnement besitzen, können Sie ein kostenloses Konto erstellen, bevor Sie beginnen.

  1. Melden Sie sich unter Verwendung Ihres eigenen Abonnements beim Azure-Portal an.

  2. Öffnen Sie die Cloud Shell, und wählen Sie Bash aus.

  3. Erstellen Sie mithilfe des Befehls az group create eine Azure-Ressourcengruppe, und geben Sie eine Region an. In diesem Beispiel wird eine Ressourcengruppe namens rg-ship-manager in der Region eastus erstellt:

    az group create --name rg-ship-manager --location eastus

    Die Erstellung kann einige Minuten in Anspruch nehmen.

Erstellen des Zustands

Wie zuvor beschrieben, ist es möglich, aber nicht empfohlen, den Zustand in Kubernetes zu behandeln. Das Verwalten eines hochverfügbaren Anwendungszustands kann zu schwierig werden, wenn Sie den Zustand selbst verwalten müssen.

Als Problemumgehung können Sie den Zustand in eine Anwendung externalisieren, die auf die externe Verwaltung von Zuständen spezialisiert ist: Azure Cosmos DB.

Hinweis

Obwohl eine Azure Cosmos DB-Instanz als Teil der erforderlichen Ressourcen erstellt wird, um die Anwendung auszuführen, sind Azure Kubernetes Service (AKS) und Azure Cosmos DB nicht miteinander verknüpft.

  1. Erstellen Sie Bash-Variablen zum Speichern des Namens des Azure Cosmos DB-Kontos und der Ressourcengruppe für die Verwendung im restlichen Modul.

    export RESOURCE_GROUP=rg-ship-manager
export COSMOSDB_ACCOUNT_NAME=contoso-ship-manager-$RANDOM

  2. Erstellen Sie mithilfe des Befehls az cosmosdb create ein neues Azure Cosmos DB-Konto.

    az cosmosdb create --name $COSMOSDB_ACCOUNT_NAME --resource-group $RESOURCE_GROUP --kind MongoDB

    Die Erstellung kann einige Minuten in Anspruch nehmen.

  3. Erstellen Sie mithilfe des Befehls az cosmosdb mongodb database create eine neue Datenbank. In diesem Beispiel heißt die Datenbank contoso-ship-manager.

    az cosmosdb mongodb database create --account-name $COSMOSDB_ACCOUNT_NAME --resource-group $RESOURCE_GROUP --name contoso-ship-manager

  4. Überprüfen Sie mithilfe des Befehls az cosmosdb mongodb database list, ob die Datenbank erfolgreich erstellt wurde.

    az cosmosdb mongodb database list --account-name $COSMOSDB_ACCOUNT_NAME --resource-group $RESOURCE_GROUP -o table

    Ihre Ausgabe sollte in etwa dem folgendem Beispiel entsprechen:

    Name                  ResourceGroup
--------------------  ---------------
contoso-ship-manager  rg-ship-manager

Sie haben einen externen Zustand erstellt, in dem alle Daten aus der Anwendung für die Schiffsverwaltung gespeichert werden. Nun erstellen Sie die AKS-Ressource, in der die Anwendung selbst gespeichert wird.

Erstellen des AKS-Clusters

  1. Erstellen Sie eine Bash-Variable, um den Clusternamen für die Verwendung im restlichen Modul zu speichern.

    AKS_CLUSTER_NAME=ship-manager-cluster

  2. Erstellen Sie mit dem Befehl az aks create einen AKS-Cluster.

    az aks create --resource-group $RESOURCE_GROUP \
    --name $AKS_CLUSTER_NAME  \
    --node-count 3 \
    --generate-ssh-keys \
    --node-vm-size Standard_B2s \
    --enable-addons http_application_routing

    Die Erstellung kann einige Minuten in Anspruch nehmen.

    Hinweis

    Alle Azure-Dienste legen Standardgrenzwerte und Kontingente für Ressourcen und Features fest, einschließlich Nutzungseinschränkungen für bestimmte VM-SKUs. Wenn ein Fehler auftritt, der darauf hindeutet, dass Ihre gewünschte VM-SKU in der von Ihnen ausgewählten Region nicht verfügbar ist, müssen Sie dieses Kontingent wahrscheinlich über eine Azure-Supportanforderung erhöhen (für den Problemtyp wählen Sie Kontingent aus).

  3. Laden Sie die kubectl-Konfiguration mit dem Befehl az aks get-credentials herunter.

    az aks get-credentials --name $AKS_CLUSTER_NAME --resource-group $RESOURCE_GROUP

    Sie erhalten Meldungen zu vorhandenen Clustern, z. B.:

    A different object named ship-manager-cluster already exists in your kubeconfig file.
Overwrite? (y/n):

    Geben Sie y zum Überschreiben ein.

  4. Testen Sie die Konfiguration mithilfe des Befehls kubectl get nodes.

    kubectl get nodes

    Ihre Ausgabe sollte in etwa dem folgendem Beispiel entsprechen:

    NAME                                STATUS   ROLES   AGE     VERSION
aks-nodepool1-12345678-vmss000000   Ready    agent   3m19s   v1.27.7
aks-nodepool1-12345678-vmss000001   Ready    agent   3m25s   v1.27.7
aks-nodepool1-12345678-vmss000002   Ready    agent   3m20s   v1.27.7

Bereitstellen der Anwendung

Um die Anwendung zu erstellen, müssen Sie die YAML-Dateien zum Bereitstellen in Kubernetes erstellen.

Bereitstellen der Back-End-API

  1. Rufen Sie mithilfe des Befehls az cosmosdb keys list die Verbindungszeichenfolge für Ihre Azure Cosmos DB-Datenbank ab.

    az cosmosdb keys list --type connection-strings -g $RESOURCE_GROUP -n $COSMOSDB_ACCOUNT_NAME --query "connectionStrings[0].connectionString" -o tsv

    Ihre Ausgabe sollte in etwa dem folgendem Beispiel entsprechen:

    mongodb://contoso-ship-manager-12345678.documents.azure.com:10255/?ssl=true&replicaSet=globaldb

  2. Erstellen Sie eine neue Datei namens backend-deploy.yml, und fügen Sie die folgende Bereitstellungsspezifikation ein:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: ship-manager-backend
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ship-manager-backend
  template:
    metadata:
      labels:
        app: ship-manager-backend
    spec:
      containers:
        - image: mcr.microsoft.com/mslearn/samples/contoso-ship-manager:backend
          name: ship-manager-backend
          resources:
            requests:
              cpu: 100m
              memory: 128Mi
            limits:
              cpu: 250m
              memory: 256Mi
          ports:
            - containerPort: 3000
              name: http
          env:
            - name: DATABASE_MONGODB_URI
              value: "{your database connection string}"
            - name: DATABASE_MONGODB_DBNAME
              value: contoso-ship-manager

  3. Ersetzen Sie den Platzhalter {your database connection string} durch die Datenbankverbindungszeichenfolge, die Sie im vorherigen Schritt abgerufen haben.

    Hinweis

    Vergessen Sie nicht, den Umgebungsvariablen Anführungszeichen hinzuzufügen ("), da die Verbindungszeichenfolge manchmal ungültige YAML-Zeichen angibt. Sie können die Verwendung von Geheimnissen als sichere Möglichkeit zum Speichern und Abrufen von Verbindungszeichenfolgen in AKS in Betracht ziehen.

  4. Speichern und schließen Sie die Datei.

  5. Wenden Sie die Back-End-API-Bereitstellung mithilfe des Befehls kubectl apply an.

    kubectl apply -f backend-deploy.yml

    Es wird eine Meldung ähnlich der Beispielausgabe angezeigt:

    deployment.apps/ship-manager-backend created

Um diese Anwendung für alle verfügbar zu machen, müssen Sie einen Dienst und einen Eingang für den Datenverkehr erstellen.

  1. Rufen Sie Ihre Cluster-API-Serveradresse mithilfe des Befehls az aks show ab.

    az aks show -g $RESOURCE_GROUP -n $AKS_CLUSTER_NAME -o tsv --query fqdn

    Ihre Ausgabe sollte in etwa dem folgendem Beispiel entsprechen:

    ship-manag-rg-ship-manager-a1bcd2-efghij56.hcp.eastus.azmk8s.io

  2. Erstellen Sie eine neue Datei namens backend-network.yml, und fügen Sie darin die folgende Netzwerkspezifikation ein:

    apiVersion: v1
kind: Service
metadata:
  name: ship-manager-backend
spec:
  type: ClusterIP
  ports:
  - port: 80
    targetPort: 3000
  selector:
    app: ship-manager-backend
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: ship-manager-backend
spec:
  ingressClassName: webapprouting.kubernetes.azure.com
  rules:
  - host: <host-name>
    http:
      paths:
      - backend:
          service:
            name: ship-manager-backend
            port:
              number: 80
        path: /
        pathType: Prefix

  3. Ersetzen Sie den Platzhalter <host-name> durch die Verbindungszeichenfolge, die Sie im vorherigen Schritt abgerufen haben.

  4. Speichern und schließen Sie die Datei.

  5. Wenden Sie die Back-End-Netzwerkbereitstellung mithilfe des Befehls kubectl apply an.

    kubectl apply -f backend-network.yml

    Ihre Ausgabe sollte in etwa dem folgendem Beispiel entsprechen:

    service/ship-manager-backend created
ingress.networking.k8s.io/ship-manager-backend created

    Sie können über den Hostnamen, den Sie in Ihre Eingangsressource eingefügt haben, auf die API zugreifen. Es kann bis zu fünf Minuten dauern, bis die Azure DNS-Zonenressource die DNS-Ermittlung abgeschlossen hat. Wenn Sie nicht sofort auf die API zugreifen können, warten Sie einige Minuten, und versuchen Sie es noch mal.

  6. Überprüfen Sie den Eingangsstatus, indem Sie Kubernetes anhand des Befehls kubectl get ingress nach den verfügbaren Eingängen abfragen.

    kubectl get ingress

    Wenn das Feld ADDRESS in der Ausgabe ausgefüllt ist, bedeutet dies, dass der Eingang bereitgestellt wurde und darauf zugegriffen werden kann, wie in der folgenden Beispielausgabe gezeigt:

    NAME                   CLASS                                HOSTS                                                               ADDRESS        PORTS   AGE
ship-manager-backend   webapprouting.kubernetes.azure.com   ship-manag-rg-ship-manager-a1bcd2-efghij56.hcp.eastus.azmk8s.io     xx.xx.xx.xx    80      2m40s

Bereitstellen der Front-End-Schnittstelle

  1. Erstellen Sie eine neue Datei namens frontend-deploy.yml, und fügen Sie die folgende Bereitstellungsspezifikation ein:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: ship-manager-frontend
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ship-manager-frontend
  template:
    metadata:
      labels:
        app: ship-manager-frontend
    spec:
      containers:
        - image: mcr.microsoft.com/mslearn/samples/contoso-ship-manager:frontend
          name: ship-manager-frontend
          imagePullPolicy: Always
          resources:
            requests:
              cpu: 100m
              memory: 128Mi
            limits:
              cpu: 250m
              memory: 256Mi
          ports:
            - containerPort: 80
          volumeMounts:
            - name: config
              mountPath: /usr/src/app/dist/config.js
              subPath: config.js
      volumes:
        - name: config
          configMap:
            name: frontend-config
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: frontend-config
data:
  config.js: |
    const config = (() => {
      return {
        'VUE_APP_BACKEND_BASE_URL': 'http://{YOUR_BACKEND_URL}',
      }
    })()

  2. Ersetzen Sie den Platzhalter {YOUR_BACKEND_URL} durch die Hostnamen-URL der Back-End-API, die Sie im vorherigen Abschnitt abgerufen haben.

  3. Speichern und schließen Sie die Datei.

  4. Wenden Sie die Front-End-Bereitstellung mithilfe des Befehls kubectl apply an.

    kubectl apply -f frontend-deploy.yml

    Ihre Ausgabe sollte in etwa dem folgendem Beispiel entsprechen:

    deployment.apps/ship-manager-frontend created
configmap/frontend-config created

Als Nächstes erstellen Sie die Netzwerkressourcen, die diese Anwendung benötigt, um mit dem Web kommunizieren zu können.

  1. Erstellen Sie eine neue Datei namens frontend-network.yml, und fügen Sie darin die folgende Netzwerkspezifikation ein:

    apiVersion: v1
kind: Service
metadata:
  name: ship-manager-frontend
spec:
  type: ClusterIP
  ports:
  - port: 80
    targetPort: 80
  selector:
    app: ship-manager-frontend
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: ship-manager-frontend
spec:
  ingressClassName: webapprouting.kubernetes.azure.com
  rules:
  - host: <host-name>
    http:
      paths:
      - backend:
          service:
            name: ship-manager-frontend
            port:
              number: 80
        path: /
        pathType: Prefix

  2. Ersetzen Sie den Platzhalter <host-name> durch die Verbindungszeichenfolge, die Sie im vorherigen Abschnitt abgerufen haben.

  3. Speichern und schließen Sie die Datei.

  4. Wenden Sie die Front-End-Netzwerkbereitstellung mithilfe des Befehls kubectl apply an.

    kubectl apply -f frontend-network.yml

    Ihre Ausgabe sollte in etwa dem folgendem Beispiel entsprechen:

    service/ship-manager-frontend created
ingress.networking.k8s.io/ship-manager-frontend created

    Sie können über den Hostnamen, den Sie in Ihre Eingangsressource eingefügt haben, auf die API zugreifen. Es kann bis zu fünf Minuten dauern, bis die Azure DNS-Zonenressource die DNS-Ermittlung abgeschlossen hat. Wenn Sie nicht sofort auf die API zugreifen können, warten Sie einige Minuten, und versuchen Sie es noch mal.

  5. Überprüfen Sie den Eingangsstatus, indem Sie Kubernetes anhand des Befehls kubectl get ingress nach den verfügbaren Eingängen abfragen.

    kubectl get ingress

    Wenn das Feld ADDRESS in der Ausgabe ausgefüllt ist, bedeutet dies, dass der Eingang bereitgestellt wurde und darauf zugegriffen werden kann, wie in der folgenden Beispielausgabe gezeigt:

    NAME                   CLASS                                HOSTS                                                               ADDRESS        PORTS   AGE
ship-manager-backend   webapprouting.kubernetes.azure.com   ship-manag-rg-ship-manager-a1bcd2-efghij56.hcp.eastus.azmk8s.io     xx.xx.xx.xx    80      2m40s
ship-manager-frontend  webapprouting.kubernetes.azure.com   ship-manag-rg-ship-manager-a1bcd2-efghij56.hcp.eastus.azmk8s.io     xx.xx.xx.xx    80      100s

Sie können nun über den Hostnamen der Eingangsressourcen auf die URL zugreifen, um die Anwendung für die Schiffsverwaltung zu öffnen.