Hosten einer neuen Datenbank mit Azure Cosmos DB

  • 15 Minuten

Nachdem wir nun die grundlegenden Konzepte externer Zustände und deren Umgang mit ihnen mithilfe von Kubernetes überprüft haben, erstellen wir die Ressourcen, die die Anwendung Ihres Frachtunternehmens unterstützen und dann die Anwendung selbst erstellen.

Erstellen einer Ressourcengruppe

Von Bedeutung

Sie benötigen Ihr eigenes Azure-Abonnement, um diese Übung abzuschließen, und möglicherweise entstehen Gebühren. Wenn Sie noch nicht über ein Azure-Abonnement verfügen, erstellen Sie ein kostenloses Konto , bevor Sie beginnen.

  1. Melden Sie sich mit Ihrem eigenen Abonnement beim Azure-Portal an.

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

  3. Erstellen Sie mithilfe des az group create Befehls 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

    Der Erstellungsprozess kann einige Augenblicke dauern.

Erstellen des Zustands

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

Um dieses Problem zu lösen, externalisieren wir den Zustand in eine Anwendung, die sich auf den Umgang mit dem externen Zustand spezialisiert hat: Azure Cosmos DB.

Hinweis

Obwohl wir eine Azure Cosmos DB-Instanz als Teil der erforderlichen Ressourcen zum Ausführen der Anwendung erstellen, sind Azure Kubernetes Service (AKS) und Azure Cosmos DB nicht miteinander verbunden.

  1. Erstellen Sie Bash-Variablen zum Speichern des Azure Cosmos DB-Kontonamens und des Ressourcengruppennamens 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 az cosmosdb create Befehls ein neues Azure Cosmos DB-Konto.

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

    Der Erstellungsprozess kann einige Augenblicke dauern.

  3. Erstellen Sie eine neue Datenbank mit dem az cosmosdb mongodb database create Befehl. 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, ob die Datenbank mithilfe des az cosmosdb mongodb database list Befehls 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

Nachdem Sie nun einen externen Zustand erstellt haben, um alle Daten aus der Ship-Manager-Anwendung zu speichern, erstellen wir die AKS-Ressource, um die Anwendung selbst zu speichern.

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

    Der Erstellungsprozess kann einige Augenblicke dauern.

    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-Supportanfrage erhöhen (für den Problemtyp , wählen Sie "Kontingent" aus).

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

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

    Wenn Sie Nachrichten zu vorhandenen Clustern erhalten, z. B.:

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

    Geben Sie y ein, um zu überschreiben.

  4. Testen Sie die Konfiguration mit dem kubectl get nodes Befehl.

    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 ihre Azure Cosmos DB-Datenbankverbindungszeichenfolge mithilfe des az cosmosdb keys list Befehls 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 {your database connection string} Platzhalter 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 darstellt.

  4. Speichern und schließen Sie die Datei.

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

    kubectl apply -f backend-deploy.yml

    Es sollte eine Meldung wie die folgende Beispielausgabe angezeigt werden:

    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 az aks show Befehls 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 mit dem Namen backend-network.yml , und fügen Sie 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 <host-name> Platzhalter 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 kubectl apply Befehls 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. Die Azure DNS-Zonenressource kann bis zu fünf Minuten dauern, bis die DNS-Erkennung abgeschlossen ist. Wenn Sie sofort nicht auf die API zugreifen können, warten Sie einige Minuten, und versuchen Sie es erneut.

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

    kubectl get ingress

    Sobald das Feld ADRESSE in der Ausgabe ausgefüllt ist, bedeutet dies, dass der Eingangsausgang 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 mit dem Namen 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 {YOUR_BACKEND_URL} Platzhalter 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 kubectl apply Befehls 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 können Sie die Netzwerkressourcen erstellen, die diese Anwendung für das Web öffnen muss.

  1. Erstellen Sie eine neue Datei mit dem Namen frontend-network.yml , und fügen Sie 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 <host-name> Platzhalter 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 kubectl apply Befehls 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. Die Azure DNS-Zonenressource kann bis zu fünf Minuten dauern, bis die DNS-Erkennung abgeschlossen ist. Wenn Sie sofort nicht auf die API zugreifen können, warten Sie einige Minuten, und versuchen Sie es erneut.

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

    kubectl get ingress

    Sobald das Feld ADRESSE in der Ausgabe ausgefüllt ist, bedeutet dies, dass der Eingangsausgang 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 jetzt über den Hostnamen der Eingangsressource auf die URL zugreifen, um die Ship-Manager-Anwendung einzugeben.