Übung – Hosten einer neuen Datenbank mit Azure Cosmos DB

15 Minuten

Nachdem wir nun die grundlegenden Konzepte externer Zustände und deren Behandlung 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.

Melden Sie sich mit Ihrem eigenen Abonnement beim Azure-Portal an.
Öffnen Sie die Cloud Shell, und wählen Sie Bash aus.
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.

Überprüfen Sie bei Azure Cosmos DB, ob der Ressourcenanbieter Microsoft.DocumentDB in Ihrem Abonnement registriert ist.
```
az provider show --namespace Microsoft.DocumentDB --query "registrationState"
```
Wenn die Ausgabe lautet NotRegistered, registrieren Sie den Ressourcenanbieter.
```
az provider register --namespace Microsoft.DocumentDB
```
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
```
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.

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

Ü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 \
  --output 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

Überprüfen Sie bei AKS, ob der Ressourcenanbieter Microsoft.ContainerService in Ihrem Abonnement registriert ist.
```
az provider show --namespace Microsoft.ContainerService --query "registrationState"
```
Wenn die Ausgabe lautet NotRegistered, registrieren Sie den Ressourcenanbieter.
```
az provider register --namespace Microsoft.ContainerService
```
Erstellen Sie eine Bash-Variable, um den Clusternamen für die Verwendung im restlichen Modul zu speichern.
```
AKS_CLUSTER_NAME=ship-manager-cluster
```
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-app-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).

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.

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    <none>   107s   v1.33.7
aks-nodepool1-12345678-vmss000001   Ready    <none>   104s   v1.33.7
aks-nodepool1-12345678-vmss000002   Ready    <none>   107s   v1.33.7

Bereitstellen der Anwendung

Um die Anwendung zu erstellen, müssen Sie die YAML-Dateien zum Bereitstellen in Kubernetes erstellen. Sie können die Dateien auf Ihrem Computer erstellen und dann in Ihre Bash-Sitzung in Cloud Shell hochladen. Wählen Sie in der Cloud Shell-Sitzung "Dateien verwalten"> und "hochladen" aus.

Bereitstellen der Back-End-API

Exportieren Sie ihre Azure Cosmos DB-Datenbankverbindungszeichenfolge mithilfe des az cosmosdb keys list Befehls in eine Variable.
```
export COSMOS_CONNECTION_STRING=$(az cosmosdb keys list \
  --type connection-strings \
  --resource-group $RESOURCE_GROUP \
  --name $COSMOSDB_ACCOUNT_NAME \
  --query "connectionStrings[0].connectionString" --output tsv)
```
Von Bedeutung

Verwenden Sie keine Verbindungszeichenfolgen für eine Produktionsumgebung, da die Verbindungszeichenfolge vertrauliche Informationen enthält. Weitere Informationen finden Sie in der Sicherheitsübersicht für Azure Cosmos DB.

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: "${COSMOS_CONNECTION_STRING}"
            - name: DATABASE_MONGODB_DBNAME
              value: contoso-ship-manager

Speichern Sie die Datei, und laden Sie sie in die Cloud Shell-Sitzung hoch, indem Sie " Dateien>hochladen" auswählen.
Wenden Sie die Back-End-API-Bereitstellung mithilfe des kubectl apply Befehls an.
```
envsubst '${COSMOS_CONNECTION_STRING}' < backend-deploy.yml | kubectl apply -f -
```
Der Befehl ersetzt den ${COSMOS_CONNECTION_STRING} Platzhalter in der YAML-Datei durch den Wert der COSMOS_CONNECTION_STRING Umgebungsvariable mit envsubst. Der Gedankenstrich (-) am Ende des Befehls weist kubectl an, die Eingabe aus dem Standardeingabedatenstrom zu lesen. Der Wert der COSMOS_CONNECTION_STRING Variablen wird nicht in der Datei gespeichert, die Sie in Cloud Shell hochgeladen haben.

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.

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:
    http:
      paths:
      - backend:
          service:
            name: ship-manager-backend
            port:
              number: 80
        path: /api
        pathType: Prefix

Speichern Sie die Datei, und laden Sie sie in die Cloud Shell-Sitzung hoch, indem Sie " Dateien>hochladen" auswählen.
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
```
Dieser Ingress leitet Anforderungen an die Back-End-API auf dem /api Pfad weiter.
Überprüfen Sie den Eingangsstatus, indem Sie Kubernetes anhand des kubectl get ingress Befehls nach den verfügbaren Eingangseingängen abfragen.
```
kubectl get ingress
```
Nachdem das Feld ADRESSE in der Ausgabe ausgefüllt wurde, bedeutet dies, dass der Eingangseingang 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   *       xx.xx.xx.xx    80      2m40s
```
Der HOSTS Wert ist *, weil dieser Ingress keine host: Regel festlegt. Ingress-Hostnamen sind optional. Wenn Sie host: weglassen, gleicht der Ingress Anforderungen für jeden beliebigen Hostnamen ab, und Sie greifen über die Ingress-ADDRESS auf die App zu.

Speichern Sie die Eingangsadresse in einer Variablen. Sie verwenden es für die Front-End-Konfiguration.

export HOST_NAME=$(kubectl get ingress ship-manager-backend -o jsonpath='{.status.loadBalancer.ingress[0].ip}{.status.loadBalancer.ingress[0].hostname}')

Bereitstellen der Front-End-Schnittstelle

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://${HOST_NAME}',
      }
    })()

Speichern Sie die Datei, und laden Sie sie in die Cloud Shell-Sitzung hoch, indem Sie " Dateien>hochladen" auswählen.

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

envsubst '${HOST_NAME}' < frontend-deploy.yml | kubectl apply -f -

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.

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:
    http:
      paths:
      - backend:
          service:
            name: ship-manager-frontend
            port:
              number: 80
        path: /
        pathType: Prefix

Speichern Sie die Datei, und laden Sie sie in die Cloud Shell-Sitzung hoch, indem Sie " Dateien>hochladen" auswählen.
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 auf die Anwendung in Ihrem Browser zugreifen, indem Sie http://$HOST_NAME verwenden. Führen Sie die Ausführung echo $HOST_NAME aus, um den Wert der HOST_NAME Variablen anzuzeigen.
Überprüfen Sie den Eingangsstatus, indem Sie Kubernetes anhand des kubectl get ingress Befehls nach den verfügbaren Eingangseingängen abfragen.
```
kubectl get ingress
```
Wenn das Feld ADRESSE in der Ausgabe gefüllt ist, bedeutet dies, dass der Eingangsschritt 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   *       xx.xx.xx.xx    80      2m40s
ship-manager-frontend  webapprouting.kubernetes.azure.com   *       xx.xx.xx.xx    80      100s
```
Sie können jetzt auf die Anwendung zugreifen unter http://$HOST_NAME.

Löschen der Variablen

Es empfiehlt sich, Variablenwerte zu löschen, insbesondere, wenn sie vertrauliche Daten wie die Datenbankverbindungszeichenfolge enthalten.

unset COSMOS_CONNECTION_STRING

Feedback

War diese Seite hilfreich?