Oefening - Host een nieuwe database met behulp van Azure Cosmos DB

15 minuten

Nu we de basisconcepten van externe statussen hebben bekeken en hoe we hiermee omgaan met behulp van Kubernetes, gaan we de resources maken die ondersteuning bieden voor de toepassing van uw vrachtbedrijf en vervolgens de toepassing zelf maken.

Een resourcegroep maken

Belangrijk

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

Meld u aan bij Azure Portal met uw eigen abonnement.
Open Cloud Shell en selecteer Bash.
Maak een Azure-resourcegroep met behulp van de opdracht az group create en geef een regio op. In dit voorbeeld wordt een resourcegroep met de naam rg-ship-manager gemaakt 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 om de toepassing uit te voeren, zijn Azure Kubernetes Service (AKS) en Azure Cosmos DB niet gerelateerd aan elkaar.

Controleer voor Azure Cosmos DB of de resourceprovider Microsoft.DocumentDB is geregistreerd in uw abonnement.
```
az provider show --namespace Microsoft.DocumentDB --query "registrationState"
```
Als de uitvoer NotRegistered is, registreer de resourceprovider.
```
az provider register --namespace Microsoft.DocumentDB
```
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
```
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 creëren van het proces kan enkele momenten duren om te voltooien.
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
```

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 \
  --output 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 voor het opslaan van alle gegevens uit de ship manager-toepassing, gaan we de AKS-resource maken om de toepassing zelf op te slaan.

Het AKS-cluster maken

Controleer voor AKS of de resourceprovider Microsoft.ContainerService is geregistreerd in uw abonnement.
```
az provider show --namespace Microsoft.ContainerService --query "registrationState"
```
Als de uitvoer NotRegistered is, registreer de resourceprovider.
```
az provider register --namespace Microsoft.ContainerService
```
Maak een Bash-variabele om de clusternaam op te slaan voor gebruik in de rest van de module.
```
AKS_CLUSTER_NAME=ship-manager-cluster
```
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-app-routing
```
Het creëren van het proces kan enkele momenten 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 probleemtype selecteert u Quotum).

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.

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    <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

De toepassing implementeren

Als u de toepassing wilt maken, moet u de YAML-bestanden maken om te implementeren in Kubernetes. U kunt de bestanden op uw computer maken en deze vervolgens uploaden naar uw Bash-sessie in Cloud Shell. Selecteer in de Cloud Shell-sessie Bestanden beheren>Uploaden.

De back-end-API implementeren

Exporteer uw Azure Cosmos DB-databaseverbindingsreeks naar een variabele met behulp van de az cosmosdb keys list opdracht.
```
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)
```
Belangrijk

Gebruik geen verbindingsreeksen voor een productieomgeving omdat de verbindingsreeks gevoelige informatie bevat. Zie het beveiligingsoverzicht voor Azure Cosmos DB voor meer informatie.

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

Sla het bestand op en upload het naar de Cloud Shell-sessie door Bestanden>uploaden beheren te selecteren.
Pas de implementatie van de back-end-API toe met behulp van de opdracht kubectl apply.
```
envsubst '${COSMOS_CONNECTION_STRING}' < backend-deploy.yml | kubectl apply -f -
```
De opdracht gebruikt envsubst om de ${COSMOS_CONNECTION_STRING} tijdelijke aanduiding in het YAML-bestand te vervangen door de waarde van de COSMOS_CONNECTION_STRING omgevingsvariabele. Het streepje (-) aan het einde van de opdracht geeft kubectl aan dat de invoer uit de standaardinvoerstroom moet worden gelezen. De waarde van de COSMOS_CONNECTION_STRING variabele wordt niet opgeslagen in het bestand dat u naar Cloud Shell hebt geüpload.

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.

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

Sla het bestand op en upload het naar de Cloud Shell-sessie door Bestanden>uploaden beheren te selecteren.
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
```
Met deze ingress worden verzoeken gerouteerd naar de back-end-API op het /api pad.
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 om te worden gebruikt, zoals blijkt uit de volgende voorbeelduitvoer:
```
NAME                   CLASS                                HOSTS   ADDRESS        PORTS   AGE
ship-manager-backend   webapprouting.kubernetes.azure.com   *       xx.xx.xx.xx    80      2m40s
```
De HOSTS waarde is * omdat dit inkomend object geen host: regel opgeeft. Hostnamen voor inkomend verkeer zijn optioneel. Wanneer u host: weglaat, worden aanvragen voor elke hostnaam door de ingress verwerkt, en opent u de app via het ingress ADDRESS.

Sla het adres voor inkomend verkeer op in een variabele. U gebruikt deze voor de front-endconfiguratie.

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

De front-endinterface implementeren

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

Sla het bestand op en upload het naar de Cloud Shell-sessie door Bestanden>uploaden beheren te selecteren.

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

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

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.

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

Sla het bestand op en upload het naar de Cloud Shell-sessie door Bestanden>uploaden beheren te selecteren.
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 kunt de toepassing openen in uw browser met behulp van http://$HOST_NAME. Voer uit echo $HOST_NAME om de waarde van de HOST_NAME variabele weer te geven.
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
```
Wanneer het veld ADDRESS in de uitvoer wordt ingevuld, betekent dit dat het inkomend verkeer is geïmplementeerd en klaar is om te worden geopend, zoals wordt weergegeven in de volgende voorbeelduitvoer:
```
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
```
U hebt nu toegang tot de toepassing op http://$HOST_NAME.

"Wis de variabelen"

Het is een goede gewoonte om variabele waarden te wissen, met name wanneer ze gevoelige gegevens bevatten, zoals de databaseverbindingsreeks.

unset COSMOS_CONNECTION_STRING

Feedback

Is deze pagina nuttig?