Een nieuwe database hosten met Behulp van Azure Cosmos DB

  • 15 minuten

Nu we de basisconcepten van externe statussen hebben bekeken en hoe we hiermee omgaan met kubernetes, gaan we de resources maken die de toepassing van uw vrachtbedrijf ondersteunen en vervolgens de toepassing zelf maken.

Een resourcegroep maken

Belangrijk

U hebt uw eigen Azure-abonnement nodig om deze oefening uit te voeren en er kunnen kosten in rekening worden gebracht. Als u nog geen Azure-abonnement hebt, maakt u een gratis account voordat u begint.

  1. Meld u aan bij Azure Portal met uw eigen abonnement.

  2. Open Cloud Shell en selecteer Bash-.

  3. Maak een Azure-resourcegroep met behulp van de opdracht az group create en geef een regio op. In dit voorbeeld wordt een resourcegroep gemaakt met de naam rg-ship-manager in de regio eastus.

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

    Het creëren van het proces kan enkele momenten duren om te voltooien.

De staat creëren

Zoals we eerder hebben beschreven, is het mogelijk, maar niet aanbevolen, om de toestand in Kubernetes af te handelen. Het beheren van een maximaal beschikbare toepassingsstatus kan te moeilijk worden wanneer u de status zelf moet beheren.

Om dit probleem op te lossen, externaliseren we de status naar een toepassing die gespecialiseerd is in het omgaan met externe status: Azure Cosmos DB.

Notitie

Hoewel we een Azure Cosmos DB-exemplaar maken als onderdeel van de vereiste resources voor het uitvoeren van de toepassing, worden Azure Kubernetes Service (AKS) en Azure Cosmos DB niet gerelateerd aan elkaar.

  1. Maak Bash-variabelen om de azure Cosmos DB-accountnaam en de naam van de resourcegroep op te slaan voor gebruik in de rest van de module.

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

  2. Maak een nieuw Azure Cosmos DB-account met behulp van de opdracht az cosmosdb create.

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

    Het aanmaakproces kan even duren.

  3. Maak een nieuwe database met behulp van de opdracht az cosmosdb mongodb database create. In dit voorbeeld heeft de database de naam contoso-ship-manager.

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

  4. Controleer of de database is gemaakt met behulp van de opdracht az cosmosdb mongodb database list.

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

    De uitvoer moet er ongeveer uitzien als in de volgende voorbeelduitvoer:

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

Nu u een externe status hebt gemaakt om alle gegevens van de ship manager-toepassing op te slaan, gaan we de AKS-resource maken om de toepassing zelf op te slaan.

Het AKS-cluster maken

  1. Maak een Bash-variabele om de clusternaam op te slaan voor gebruik in de rest van de module.

    AKS_CLUSTER_NAME=ship-manager-cluster

  2. Maak een AKS-cluster met behulp van de opdracht 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-addons http_application_routing

    Het aanmaken kan enkele ogenblikken duren om te voltooien.

    Notitie

    Alle Azure-services stellen standaardlimieten en quota in voor resources en functies, inclusief gebruiksbeperkingen voor bepaalde VM-SKU's (virtuele machines). Als er een fout optreedt waarin wordt voorgesteld dat de gewenste VM-SKU niet beschikbaar is in de regio die u hebt geselecteerd, moet u dit quotum waarschijnlijk verhogen via een Azure-ondersteuningsaanvraag (voor type probleem selecteert u Quotum).

  3. Download de kubectl-configuratie met behulp van de opdracht az aks get-credentials.

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

    Als u berichten over bestaande clusters ontvangt, bijvoorbeeld:

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

    Voer y in om te overschrijven.

  4. Test de configuratie met behulp van de opdracht kubectl get nodes.

    kubectl get nodes

    De uitvoer moet er ongeveer uitzien als in de volgende voorbeelduitvoer:

    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

De toepassing implementeren

Als u de toepassing wilt maken, moet u de YAML-bestanden maken om te implementeren in Kubernetes.

De back-end-API implementeren

  1. Haal uw Azure Cosmos DB-databaseverbindingsreeks op met behulp van de opdracht az cosmosdb keys list.

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

    De uitvoer moet er ongeveer uitzien als in de volgende voorbeelduitvoer:

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

  2. Maak een nieuw bestand met de naam backend-deploy.yml en plak de volgende implementatiespecificatie:

    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. Vervang de tijdelijke aanduiding {your database connection string} door de databaseverbindingsreeks die u in de vorige stap hebt opgehaald.

    Notitie

    Vergeet niet om aanhalingstekens " toe te voegen aan de omgevingsvariabelen, omdat de verbindingsreeks soms ongeldige YAML-tekens bevat. U kunt overwegen om secrets te gebruiken als een veilige manier om de connection string op te slaan en op te halen in AKS.

  4. Sla het bestand op en sluit het.

  5. Pas de implementatie van de back-end-API toe met behulp van de opdracht kubectl apply.

    kubectl apply -f backend-deploy.yml

    Er wordt een bericht weergegeven dat lijkt op de volgende voorbeelduitvoer:

    deployment.apps/ship-manager-backend created

Als u deze toepassing beschikbaar wilt maken voor iedereen, moet u een service en een ingress-resource maken om het inkomende verkeer te beheren.

  1. Haal het adres van uw cluster-API-server op met behulp van de opdracht az aks show.

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

    De uitvoer moet er ongeveer uitzien als in de volgende voorbeelduitvoer:

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

  2. Maak een nieuw bestand met de naam backend-network.yml en plak de volgende netwerkspecificatie:

    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. Vervang de tijdelijke aanduiding <host-name> door de verbindingsreeks die u in de vorige stap hebt opgehaald.

  4. Sla het bestand op en sluit het.

  5. Pas de back-endnetwerkimplementatie toe met behulp van de opdracht kubectl apply.

    kubectl apply -f backend-network.yml

    De uitvoer moet er ongeveer uitzien als in de volgende voorbeelduitvoer:

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

    U hebt toegang tot de API via de hostnaam die u in uw toegangsbeheerresource hebt geplakt. Het kan tot vijf minuten duren voordat de Azure DNS-zonebron het DNS-detectieproces heeft voltooid. Als u de API niet meteen kunt openen, wacht u enkele minuten en probeert u het opnieuw.

  6. Controleer de status van inkomend verkeer door een query uit te voeren op Kubernetes voor de beschikbare ingresses met behulp van de opdracht kubectl get ingress.

    kubectl get ingress

    Zodra het veld ADDRESS in de uitvoer is ingevuld, betekent dit dat het ingress-object is geïmplementeerd en dat het klaar is voor toegang, zoals weergegeven in het volgende uitvoervoorbeeld.

    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

De front-endinterface implementeren

  1. Maak een nieuw bestand met de naam frontend-deploy.yml en plak de volgende implementatiespecificatie:

    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. Vervang de tijdelijke aanduiding {YOUR_BACKEND_URL} door de hostnaam-URL van de back-end-API die u in de vorige sectie hebt opgehaald.

  3. Sla het bestand op en sluit het.

  4. Pas de front-endimplementatie toe met behulp van de opdracht kubectl apply.

    kubectl apply -f frontend-deploy.yml

    De uitvoer moet er ongeveer uitzien als in de volgende voorbeelduitvoer:

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

Vervolgens kunt u de netwerkresources maken die deze toepassing moet openen voor het web.

  1. Maak een nieuw bestand met de naam frontend-network.yml en plak de volgende netwerkspecificatie:

    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. Vervang de tijdelijke aanduiding <host-name> door de verbindingsreeks die u in de vorige sectie hebt opgehaald.

  3. Sla het bestand op en sluit het.

  4. Pas de front-endnetwerkimplementatie toe met behulp van de opdracht kubectl apply.

    kubectl apply -f frontend-network.yml

    De uitvoer moet er ongeveer uitzien als in de volgende voorbeelduitvoer:

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

    U hebt toegang tot de API via de hostnaam die u in uw toegangsbeheerresource hebt geplakt. Het kan vijf minuten duren voordat de Azure DNS-zoneresource de DNS-detectie heeft voltooid. Als u de API niet meteen kunt openen, wacht u enkele minuten en probeert u het opnieuw.

  5. Controleer de status van inkomend verkeer door een query uit te voeren op Kubernetes voor de beschikbare ingresses met behulp van de opdracht kubectl get ingress.

    kubectl get ingress

    Zodra het veld ADDRESS in de uitvoer is ingevuld, betekent dit dat de ingress is geïmplementeerd en dat het klaar is voor toegang, zoals wordt weergegeven in de volgende voorbeelduitvoer.

    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

U hebt nu toegang tot de URL via de hostnaam van de toegangsresource om de applicatie voor scheepsbeheer te openen.