Övning – Värdhantera en ny databas med Hjälp av Azure Cosmos DB

  • 15 minuter

Nu när vi har granskat de grundläggande begreppen för externa tillstånd och hur du hanterar dem med Kubernetes ska vi skapa de resurser som stöder fraktföretagets program och sedan skapa själva programmet.

Skapa en resursgrupp

Viktig

Du behöver en egen Azure-prenumeration för att slutföra den här övningen och du kan debiteras. Om du inte redan har en Azure-prenumeration skapar du ett kostnadsfritt konto innan du börjar.

  1. Logga in på Azure-portalen med din egen prenumeration.

  2. Öppna Cloud Shell och välj Bash.

  3. Skapa en Azure-resursgrupp med hjälp av kommandot az group create och ange en region. I det här exemplet skapas en resursgrupp med namnet rg-ship-manager i regionen eastus :

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

    Skapandeprocessen kan ta en stund att slutföra.

Skapa staten

Som vi beskrev tidigare är det möjligt men rekommenderas inte att hantera tillstånd i Kubernetes. Det kan bli för svårt att hantera ett programtillstånd med hög tillgänglighet när du behöver hantera tillståndet själv.

För att lösa det problemet externaliserar vi tillståndet till ett program som är specialiserat på att hantera externt tillstånd: Azure Cosmos DB.

Not

Även om vi skapar en Azure Cosmos DB-instans som en del av de resurser som krävs för att köra programmet är Azure Kubernetes Service (AKS) och Azure Cosmos DB inte relaterade till varandra.

  1. För Azure Cosmos DB kontrollerar du att resursprovidern Microsoft.DocumentDB är registrerad i din prenumeration.

    az provider show --namespace Microsoft.DocumentDB --query "registrationState"

    Om utdata är NotRegisteredregistrerar du resursprovidern.

    az provider register --namespace Microsoft.DocumentDB

  2. Skapa Bash-variabler för att lagra Azure Cosmos DB-kontonamnet och resursgruppens namn för användning i resten av modulen.

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

  3. Skapa ett nytt Azure Cosmos DB-konto med hjälp av kommandot az cosmosdb create.

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

    Skapandeprocessen kan ta en stund att slutföra.

  4. Skapa en ny databas med hjälp av kommandot az cosmosdb mongodb database create. I det här exemplet heter databasen contoso-ship-manager.

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

  5. Kontrollera att databasen har skapats med hjälp av kommandot az cosmosdb mongodb database list.

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

    Dina utdata bör se ut ungefär som följande exempelutdata:

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

Nu när du har skapat ett externt tillstånd för att lagra alla data från ship manager-programmet ska vi skapa AKS-resursen för att lagra själva programmet.

Skapa AKS-klustret

  1. För AKS kontrollerar du att resursprovidern Microsoft.ContainerService är registrerad i din prenumeration.

    az provider show --namespace Microsoft.ContainerService --query "registrationState"

    Om utdata är NotRegisteredregistrerar du resursprovidern.

    az provider register --namespace Microsoft.ContainerService

  2. Skapa en Bash-variabel för att lagra klusternamnet för användning i resten av modulen.

    AKS_CLUSTER_NAME=ship-manager-cluster

  3. Skapa ett AKS-kluster med hjälp av kommandot az aks create.

    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

    Skapandeprocessen kan ta en stund att slutföra.

    Not

    Alla Azure-tjänster anger standardgränser och kvoter för resurser och funktioner, inklusive användningsbegränsningar för vissa SKU:er för virtuella datorer. Om du stöter på ett fel som tyder på att den önskade virtuella dator-SKU:n inte är tillgänglig i den region som du har valt måste du förmodligen öka den här kvoten via en Azure-supportbegäran (för Typ av problem väljer du Kvot).

  4. Ladda ned kubectl-konfigurationen med hjälp av kommandot az aks get-credentials.

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

    Om du får några meddelanden om befintliga kluster, till exempel:

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

    Skriv in y för att skriva över.

  5. Testa konfigurationen med hjälp av kommandot kubectl get nodes.

    kubectl get nodes

    Dina utdata bör se ut ungefär som följande exempelutdata:

    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

Distribuera programmet

För att skapa programmet måste du skapa YAML-filerna som ska distribueras till Kubernetes. Du kan skapa filerna på datorn och sedan ladda upp dem till bash-sessionen i Cloud Shell. I Cloud Shell-sessionen väljer du Hantera uppladdning av filer>.

Distribuera backend-API:t

  1. Exportera din Azure Cosmos DB-databasanslutningssträng till en variabel med hjälp av az cosmosdb keys list kommandot .

    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)

    Viktig

    Använd inte anslutningssträngar för en produktionsmiljö eftersom anslutningssträngen innehåller känslig information. Mer information finns i säkerhetsöversikten för Azure Cosmos DB.

  2. Skapa en ny fil med namnet backend-deploy.yml och klistra in följande distributionsspecifikation:

    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

  3. Spara filen och ladda upp den till Cloud Shell-sessionen genom att välja Hantera filer>Ladda upp.

  4. Använd serverdels-API-distributionen med hjälp av kommandot kubectl apply.

    envsubst '${COSMOS_CONNECTION_STRING}' < backend-deploy.yml | kubectl apply -f -

    Kommandot använder envsubst för att ersätta ${COSMOS_CONNECTION_STRING} platshållaren i YAML-filen med värdet för COSMOS_CONNECTION_STRING miljövariabeln. Strecket (-) i slutet av kommandot instruerar kubectl att läsa indata från standardindataströmmen. Värdet för variabeln COSMOS_CONNECTION_STRING sparas inte i filen som du laddade upp till Cloud Shell.

    Du bör se ett meddelande som liknar följande exempelutdata:

    deployment.apps/ship-manager-backend created

För att göra det här programmet tillgängligt för alla måste du skapa en tjänst och en ingress för att ta hand om trafiken.

  1. Skapa en ny fil med namnet backend-network.yml och klistra in följande nätverksspecifikation:

    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

  2. Spara filen och ladda upp den till Cloud Shell-sessionen genom att välja Hantera filer>Ladda upp.

  3. Använd backend-nätdistributionen med hjälp av kommandot kubectl apply.

    kubectl apply -f backend-network.yml

    Dina utdata bör se ut ungefär som följande exempelutdata:

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

    Den här ingressen dirigerar begäranden till serverdels-API:et på /api sökvägen.

  4. Kontrollera ingressstatusen genom att fråga Kubernetes om tillgängliga ingresser med hjälp av kommandot kubectl get ingress.

    kubectl get ingress

    När fältet ADRESS i utdata har fyllts innebär det att ingressen har distribuerats och att den är redo att nås, vilket visas i följande exempelutdata:

    NAME                   CLASS                                HOSTS   ADDRESS        PORTS   AGE
ship-manager-backend   webapprouting.kubernetes.azure.com   *       xx.xx.xx.xx    80      2m40s

    Värdet HOSTS är * eftersom den här ingressen inte anger någon host: regel. Värdnamn för Ingress är valfria. När du utelämnar host:matchar ingressen begäranden för ett värdnamn och du kommer åt appen med hjälp av ingressadressen.

  5. Lagra ingressadressen i en variabel. Du använder den för front-end-konfigurationen.

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

Distribuera front-end-gränssnittet

  1. Skapa en ny fil med namnet frontend-deploy.yml och klistra in följande distributionsspecifikation:

    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}',
      }
    })()

  2. Spara filen och ladda upp den till Cloud Shell-sessionen genom att välja Hantera filer>Ladda upp.

  3. Använd frontend-distributionen med kommandot kubectl apply.

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

    Dina utdata bör se ut ungefär som följande exempelutdata:

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

Sedan kan du skapa de nätverksresurser som programmet måste vara öppet för webben.

  1. Skapa en ny fil med namnet frontend-network.yml och klistra in följande nätverksspecifikation:

    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

  2. Spara filen och ladda upp den till Cloud Shell-sessionen genom att välja Hantera filer>Ladda upp.

  3. Använd frontend-nätverksimplementeringen med hjälp av kommandot kubectl apply.

    kubectl apply -f frontend-network.yml

    Dina utdata bör se ut ungefär som följande exempelutdata:

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

    Du kan komma åt programmet i webbläsaren med hjälp av http://$HOST_NAME. Kör echo $HOST_NAME för att visa värdet för variabeln HOST_NAME .

  4. Kontrollera ingressstatusen genom att fråga Kubernetes om tillgängliga ingresser med hjälp av kommandot kubectl get ingress.

    kubectl get ingress

    När fältet ADRESS i utdata fylls innebär det att ingressen har distribuerats och är redo att nås, som du ser i följande exempelutdata:

    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

    Nu kan du komma åt programmet på http://$HOST_NAME.

Rensa dina variabler

Det är en bra idé att rensa variabelvärden, särskilt när de innehåller känsliga data som databasanslutningssträngen.

unset COSMOS_CONNECTION_STRING