Héberger une nouvelle base de données en utilisant Azure Cosmos DB

  • 15 minutes

Maintenant que nous avons passé en revue les concepts de base des états externes et que nous savons comment les gérer en utilisant Kubernetes, créons d’abord les ressources qui prendront en charge l’application de votre société de transport, puis l’application elle-même.

Créer un groupe de ressources

Important

Vous avez besoin de votre propre abonnement Azure pour exécuter cet exercice et des frais pourraient vous être facturés. Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.

  1. Connectez-vous au portail Azure à l’aide de votre propre abonnement.

  2. Ouvrez le service Cloud Shell, puis sélectionnez Bash.

  3. Créez un groupe de ressources Azure en tirant parti de la commande az group create, puis spécifiez une région. Cet exemple crée un groupe de ressources nommé rg-ship-manager dans la région eastus :

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

    Le processus de création peut prendre un moment.

Créer l’état

Comme nous l’avons décrit précédemment, il est possible, mais déconseillé, de gérer un état dans Kubernetes. La gestion d’un état d’application à haute disponibilité devient trop difficile quand vous devez gérer l’état vous-même.

Pour résoudre ce problème, nous externalisons l’état vers une application spécialisée dans la gestion des états externes : Azure Cosmos DB.

Remarque

Même si nous créons une instance Azure Cosmos DB dans le cadre des ressources nécessaires pour exécuter l’application, Azure Kubernetes Service (AKS) et Azure Cosmos DB ne sont pas associés l’un à l’autre.

  1. Créez des variables Bash pour stocker le nom de compte Azure Cosmos DB et le nom de groupe de ressources à utiliser dans le reste du module.

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

  2. Créez un compte Azure Cosmos DB en utilisant la commande az cosmosdb create.

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

    Le processus de création peut prendre un moment.

  3. Créez une base de données en utilisant la commande az cosmosdb mongodb database create. Dans cet exemple, la base de données est nommée contoso-ship-manager.

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

  4. Vérifiez que la base de données a été correctement créée en tirant parti de la commande az cosmosdb mongodb database list.

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

    Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :

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

Maintenant que vous avez créé un état externe pour stocker toutes les données de l’application de gestion des bateaux, créons la ressource AKS pour stocker l’application proprement dite.

Créer le cluster AKS

  1. Créez une variable Bash pour stocker le nom du cluster à utiliser dans le reste du module.

    AKS_CLUSTER_NAME=ship-manager-cluster

  2. Créez un cluster AKS avec la commande 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

    Le processus de création peut prendre un moment.

    Remarque

    Tous les services Azure définissent des limites et des quotas par défaut pour les ressources et les fonctionnalités, notamment des restrictions d’utilisation pour certaines références SKU de machines virtuelles. Si vous rencontrez un erreur suggérant que votre référence SKU de machine virtuelle n’est pas disponible dans la région sélectionnée, vous devez probablement augmenter ce quota via une demande de support Azure (pour le type de Problème, sélectionnez Quota).

  3. Téléchargez la configuration kubectl en tirant parti de la commande az aks get-credentials.

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

    Si vous recevez des messages sur des clusters existants, par exemple :

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

    Entrez y pour remplacer.

  4. Testez la configuration en utilisant la commande kubectl get nodes.

    kubectl get nodes

    Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :

    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

Déployer l’application

Pour créer l’application, vous devez créer les fichiers YAML à déployer sur Kubernetes.

Déployer l’API du back-end

  1. Obtenez votre chaîne de connexion de base de données Azure Cosmos DB en utilisant la commande az cosmosdb keys list.

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

    Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :

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

  2. Créez un fichier nommé backend-deploy.yml et collez-le dans la spécification de déploiement suivante :

    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. Remplacez l’espace réservé {your database connection string} par la chaîne de connexion de base de données récupérée à l’étape précédente.

    Remarque

    N’oubliez pas d’ajouter des guillemets " aux variables d’environnement, car la chaîne de connexion présente parfois des caractères YAML non valides. Vous pouvez envisager d’utiliser des secrets comme moyen sécurisé de stocker et de récupérer une chaîne de connexion dans AKS.

  4. Enregistrez le fichier et fermez-le.

  5. Appliquez le déploiement de l’API back-end en tirant parti de la commande kubectl apply.

    kubectl apply -f backend-deploy.yml

    Un message similaire à l’exemple de sortie suivant doit s’afficher :

    deployment.apps/ship-manager-backend created

Pour mettre cette application à la disposition de tout le monde, vous devez créer un service et une entrée pour prendre en charge le trafic.

  1. Obtenez l’adresse de votre serveur d’API de cluster en tirant parti de la commande az aks show.

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

    Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :

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

  2. Créez un fichier nommé backend-network.yml et collez-le dans la spécification de mise en réseau suivante :

    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. Remplacez l’espace réservé <host-name> par la chaîne de connexion récupérée à l’étape précédente.

  4. Enregistrez le fichier et fermez-le.

  5. Appliquez le déploiement de mise en réseau back-end en tirant parti de la commande kubectl apply.

    kubectl apply -f backend-network.yml

    Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :

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

    Vous pouvez accéder à l’API via le nom d’hôte que vous avez collé dans votre ressource d’entrée. La ressource de zone Azure DNS peut prendre jusqu’à cinq minutes pour effectuer la détection DNS. Si vous ne pouvez pas accéder immédiatement à l’API, attendez quelques minutes, puis réessayez.

  6. Vérifiez l’état de l’entrée en interrogeant Kubernetes sur les entrées disponibles en utilisant la commande kubectl get ingress.

    kubectl get ingress

    Le champ ADDRESSE de sortie rempli signifie que l’entrée a été déployée et qu’elle est prête pour l’accès, comme illustré dans l’exemple de sortie suivant :

    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

Déployer l’interface du front-end

  1. Créez un fichier nommé frontend-deploy.yml et collez-le dans la spécification de déploiement suivante :

    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. Remplacez l’espace réservé {YOUR_BACKEND_URL} par l’URL du nom d’hôte de l’API back-end récupérée dans la section précédente.

  3. Enregistrez le fichier et fermez-le.

  4. Appliquez le déploiement front-end en utilisant la commande kubectl apply.

    kubectl apply -f frontend-deploy.yml

    Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :

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

Ensuite, vous pouvez créer les ressources de mise en réseau nécessaires à l’ouverture de cette application sur le web.

  1. Créez un fichier nommé frontend-network.yml et collez-le dans la spécification de mise en réseau suivante :

    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. Remplacez l’espace réservé <host-name> par la chaîne de connexion récupérée dans la section précédente.

  3. Enregistrez le fichier et fermez-le.

  4. Appliquez le déploiement de mise en réseau front-end en tirant parti de la commande kubectl apply.

    kubectl apply -f frontend-network.yml

    Vous devez obtenir un résultat semblable à l’exemple de sortie qui suit :

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

    Vous pouvez accéder à l’API via le nom d’hôte que vous avez collé dans votre ressource d’entrée. La ressource de zone Azure DNS peut prendre jusqu’à cinq minutes pour effectuer la détection DNS. Si vous ne pouvez pas accéder immédiatement à l’API, attendez quelques minutes, puis réessayez.

  5. Vérifiez l’état de l’entrée en interrogeant Kubernetes sur les entrées disponibles en utilisant la commande kubectl get ingress.

    kubectl get ingress

    Le champ ADDRESSE de sortie rempli signifie que l’entrée a été déployée et qu’elle est prête pour l’accès, comme illustré dans l’exemple de sortie suivant :

    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

Vous pouvez maintenant accéder à l’URL à partir du nom d’hôte de la ressource d’entrée pour entrer dans l’application de gestion des navires.