Ospitare un nuovo database usando Azure Cosmos DB

  • 15 minuti

Ora che sono stati esaminati i concetti di base degli stati esterni ed è stato spiegato come gestirli tramite Kubernetes, è possibile creare le risorse che supporteranno l'applicazione dell’azienda di spdizioni e quindi creare l'applicazione stessa.

Creare un gruppo di risorse

Importante

Per eseguire questo esercizio è necessario disporre di una propria sottoscrizione di Azure e questo potrebbe comportare dei costi. Se non hai ancora una sottoscrizione di Azure, crea un account gratuito prima di iniziare.

  1. Accedere al portale di Azure usando la propria sottoscrizione.

  2. Aprire Cloud Shell e selezionare Bash.

  3. Creare un gruppo di risorse di Azure usando il comando az group create e specificare un'area. Questo esempio crea un gruppo di risorse denominato rg-ship-manager nell'area eastus:

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

    Il completamento del processo di creazione potrebbe richiedere alcuni minuti.

Creare lo stato

Come descritto in precedenza, è possibile, ma non consigliabile, gestire lo stato in Kubernetes. La gestione di uno stato dell'applicazione a disponibilità elevata può diventare troppo difficile quando è necessario gestire manualmente lo stato.

Per risolvere il problema, lo stato verrà esternalizzato a un'applicazione specializzata nella gestione dello stato esterno: Azure Cosmos DB.

Nota

Anche se si sta creando un'istanza di Azure Cosmos DB nell'ambito delle risorse necessarie per eseguire l'applicazione, il servizio Azure Kubernetes e Azure Cosmos DB non sono correlati tra loro.

  1. Creare variabili Bash per archiviare il nome dell'account Azure Cosmos DB e il nome del gruppo di risorse da usare nel resto del modulo.

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

  2. Creare un nuovo account Azure Cosmos DB usando il comando az cosmosdb create.

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

    Il completamento del processo di creazione potrebbe richiedere alcuni minuti.

  3. Creare un nuovo database usando il comando az cosmosdb mongodb database create. In questo esempio il database è denominato contoso-ship-manager.

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

  4. Verificare che il database sia stato creato correttamente usando il comando az cosmosdb mongodb database list.

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

    L'output dovrebbe essere simile all'esempio di output seguente:

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

Ora che è stato creato uno stato esterno per archiviare tutti i dati dall'applicazione di gestione delle navi, è possibile passare alla creazione della risorsa del servizio Azure Kubernetes per archiviare l'applicazione stessa.

Creare il cluster del servizio Azure Kubernetes

  1. Creare una variabile Bash per archiviare il nome del cluster da usare nel resto del modulo.

    AKS_CLUSTER_NAME=ship-manager-cluster

  2. Creare un cluster del servizio Azure Kubernetes usando il comando 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

    Il completamento del processo di creazione potrebbe richiedere alcuni minuti.

    Nota

    Tutti i servizi di Azure impostano limiti e quote predefiniti per risorse e funzionalità, incluse le restrizioni di utilizzo per determinati SKU di macchine virtuali. Se si verifica un errore che suggerisce che lo SKU di macchina virtuale desiderato non è disponibile nell'area selezionata, probabilmente è necessario aumentare la quota tramite una richiesta di supporto tecnico di Azure (per il tipo diProblema, selezionare Quota).

  3. Scaricare la configurazione di kubectl usando il comando az aks get-credentials.

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

    Se vengono visualizzati messaggi relativi ai cluster esistenti, ad esempio:

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

    Immettere y per sovrascrivere.

  4. Testare la configurazione usando il comando kubectl get nodes.

    kubectl get nodes

    L'output dovrebbe essere simile all'esempio di output seguente:

    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

Distribuire l'applicazione

Per creare l'applicazione, è necessario creare i file YAML da distribuire in Kubernetes.

Distribuire l'API back-end

  1. Ottenere la stringa di connessione del database Azure Cosmos DB usando il comando az cosmosdb keys list.

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

    L'output dovrebbe essere simile all'esempio di output seguente:

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

  2. Creare un nuovo file denominato backend-deploy.yml e incollarlo nella specifica di distribuzione seguente:

    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. Sostituire il segnaposto {your database connection string} con la stringa di connessione del database ottenuta nel passaggio precedente.

    Nota

    Non dimenticare di aggiungere le virgolette " alle variabili di ambiente, perché la stringa di connessione a volte presenta caratteri YAML non validi. Si potrebbe prendere in considerazione l’uso deisegreti per archiviare e recuperare in modo sicuro la stringa di connessione nel servizio Azure Kubernetes.

  4. Salva e chiudi il file.

  5. Applicare la distribuzione dell'API back-end usando il comando kubectl apply.

    kubectl apply -f backend-deploy.yml

    Verrà visualizzato un messaggio simile all'output di esempio seguente:

    deployment.apps/ship-manager-backend created

Per rendere disponibile a tutti questa applicazione, è necessario creare un servizio e un ingresso per gestire il traffico.

  1. Ottenere l'indirizzo del server API del cluster usando il comando az aks show.

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

    L'output dovrebbe essere simile all'esempio di output seguente:

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

  2. Creare un nuovo file denominato backend-network.yml e incollarlo nella specifica di rete seguente:

    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. Sostituire il segnaposto <host-name> con la stringa di connessione ottenuta nel passaggio precedente.

  4. Salva e chiudi il file.

  5. Applicare la distribuzione di rete back-end usando il comando kubectl apply.

    kubectl apply -f backend-network.yml

    L'output dovrebbe essere simile all'esempio di output seguente:

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

    È possibile accedere all'API tramite il nome host incollato nella risorsa di ingresso. La risorsa della zona DNS di Azure può richiedere fino a cinque minuti per completare il rilevamento del DNS. Se non si riesce ad accedere subito all'API, attendere qualche minuto e riprovare.

  6. Controllare lo stato in ingresso eseguendo una query su Kubernetes per gli ingressi disponibili utilizzando il comando kubectl get ingress.

    kubectl get ingress

    Il campo ADDRESS compilato nell'output indica che l'ingresso è stato distribuito ed è pronto per l'accesso, come illustrato nell'output di esempio seguente:

    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

Distribuire l'interfaccia front-end

  1. Creare un nuovo file denominato frontend-deploy.yml e incollarlo nella specifica di distribuzione seguente:

    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. Sostituire il segnaposto {YOUR_BACKEND_URL} con l'URL del nome host dell'API back-end ottenuta nella sezione precedente.

  3. Salva e chiudi il file.

  4. Applicare la distribuzione front-end usando il comando kubectl apply.

    kubectl apply -f frontend-deploy.yml

    L'output dovrebbe essere simile all'esempio di output seguente:

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

Sarà quindi possibile creare le risorse di rete che devono essere aperte sul Web per questa applicazione.

  1. Creare un nuovo file denominato frontend-network.yml e incollarlo nella specifica di rete seguente:

    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. Sostituire il segnaposto <host-name> con la stringa di connessione ottenuta nel passaggio precedente.

  3. Salva e chiudi il file.

  4. Applicare la distribuzione di rete front-end usando il comando kubectl apply.

    kubectl apply -f frontend-network.yml

    L'output dovrebbe essere simile all'esempio di output seguente:

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

    È possibile accedere all'API tramite il nome host incollato nella risorsa di ingresso. La risorsa della zona DNS di Azure può richiedere fino a cinque minuti per completare il rilevamento del DNS. Se non si riesce ad accedere subito all'API, attendere qualche minuto e riprovare.

  5. Controllare lo stato in ingresso eseguendo una query su Kubernetes per gli ingressi disponibili utilizzando il comando kubectl get ingress.

    kubectl get ingress

    Il campo ADDRESS compilato nell'output indica che l'ingresso è stato distribuito ed è pronto per l'accesso, come illustrato nell'output di esempio seguente:

    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

È ora possibile accedere all'URL dal nome host della risorsa in ingresso per accedere all'applicazione di gestione delle navi.