Exercice - Déployer un conteneur de microservices sur Kubernetes

Effectué

Kubernetes exécute des conteneurs pour vous. Vous décrivez ce que vous souhaitez que Kubernetes effectue par le biais d’un fichier YAML. Cet exercice vous guide dans la création du fichier pour pouvoir déployer et exécuter le service back-end sur Kubernetes.

Important

Avant de continuer, vous devez vérifier qu’une implémentation de Kubernetes est installée. Nous allons utiliser l’implémentation k3d en cours d’exécution dans l’espace de code. Nous allons démarrer le labo en installant cette implémentation.

Installer les outils et l’implémentation Kubernetes

Nous devons installer à la fois l’outil kubectl et l’implémentation k3d Kubernetes :

  1. Dans l’espace de code, basculez vers l’onglet TERMINAL, puis exécutez ces commandes pour installer les prérequis :

    sudo apt-get update
    sudo apt-get install -y apt-transport-https ca-certificates curl
    
  2. Ensuite, pour télécharger la clé de signature pour les référentiels de package Kubernetes, exécutez les commandes suivantes :

    sudo mkdir /etc/apt/keyrings
    curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.28/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
    

    Si vous recevez une erreur indiquant que le répertoire existe déjà, exécutez la commande curl séparément.

  3. Ajoutez le référentiel Kubernetes à votre configuration apt :

    echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.28/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list
    
  4. À présent, vous pouvez installer l’outil kubectl :

    sudo apt-get update
    sudo apt-get install -y kubectl
    
  5. Enfin, installez l’implémentation k3d de Kubernetes et créez un cluster :

    curl -s https://raw.githubusercontent.com/k3d-io/k3d/main/install.sh | bash
    k3d cluster create devcluster --config k3d.yml
    

Créer un fichier de déploiement pour le service principal

Vous pouvez créer un fichier pour gérer le déploiement conteneurisé dans Kubernetes avec un fichier YAML. Nous allons créer un fichier pour déployer le service principal.

  1. Créez un fichier dans le dossier donet-kubernetesdu codespace nommé backend-deploy.yml.

  2. Copiez le texte suivant dans le fichier, puis enregistrez-le.

    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
        name: productsbackend
    spec:
      replicas: 1
      template:
        metadata:
          labels:
            app: productsbackend
        spec:
          containers:
          - name: productsbackend
            image: [YOUR DOCKER USER NAME]/productservice:latest
            ports:
            - containerPort: 80
            env:
            - name: ASPNETCORE_URLS
              value: http://*:80
      selector:
        matchLabels:
          app: productsbackend
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: productsbackend
    spec:
      type: NodePort
      ports:
      - port: 80
        targetPort: 80
        nodePort: 32001
      selector:
        app: productsbackend
    
  3. Remplacez le caractère générique [YOUR DOCKER USER NAME] par votre nom d’utilisateur Docker réel.

Ce fichier fait un certain nombre de choses.

La première partie définit une spécification de déploiement pour le conteneur à déployer dans Kubernetes. Cela indique un réplica, l’emplacement de l’image de conteneur et les ports à ouvrir sur le conteneur, et définit des variables d’environnement. Cette première partie définit également les étiquettes et les noms qui peuvent être utilisés pour référencer le conteneur et la spécification.

La deuxième partie définit ensuite que le conteneur s’exécute en tant que service NodePort Kubernetes. Pour ce module, vous n’avez pas besoin de comprendre toutes les spécificités de NodePorts. Toutefois, vous devez savoir que ce type de service expose une adresse IP externe afin de pouvoir le tester en dehors du cluster.

Déployer et exécuter le microservice principal

Ensuite, nous allons déployer et exécuter le microservice.

  1. Dans l’onglet TERMINAL, exécutez la commande suivante :

    kubectl apply -f backend-deploy.yml
    

    Cette commande indique à Kubernetes d’exécuter le fichier que nous avons créé. Elle télécharge l’image à partir de Docker Hub et créer le conteneur.

  2. La commande kubectl apply retourne rapidement. Mais la création du conteneur peut prendre un certain temps. Pour afficher la progression, utilisez le code suivant.

    kubectl get pods
    

    Dans la sortie résultante, vous voyez une ligne avec productsbackend, suivie d’une chaîne de caractères aléatoires sous la colonne NOM. Quand tout est prêt, il y a un 1/1 sous la colonne READY et Running sous la colonne STATUS.

  3. Pour tester le service, basculez vers l’onglet PORTS, puis à côté de l’adresse locale du port Back End, sélectionnez l’icône du globe. Le navigateur ouvre un nouvel onglet à cette adresse.

  4. Pour interroger des produits, ajoutez l’adresse avec /api/product, puis appuyez sur Entrée. Vous devriez voir certaines informations de produit répertoriées au format JSON.

    [
        {
            "id": 1,
            "name": "Solar Powered Flashlight",
            "description": "A fantastic product for outdoor enthusiasts",
            "price": 19.99,
            "imageUrl": "product1.png"
        },
        {
            "id": 2,
            "name": "Hiking Poles",
            "description": "Ideal for camping and hiking trips",
            "price": 24.99,
            "imageUrl": "product2.png"
        },
        {
            "id": 3,
            "name": "Outdoor Rain Jacket",
            "description": "This product will keep you warm and dry in all weathers",
            "price": 49.99,
            "imageUrl": "product3.png"
        },
        ...
    

Créer un fichier de déploiement et exécuter le service frontal

À l’instar du service back-end, nous aurons également besoin d’un fichier de déploiement pour le front-end.

  1. Créer un fichier dans le dossier donet-kubernetes nommé frontend-deploy.yml

  2. Collez le code suivant dans le fichier :

    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: storefrontend
    spec:
      replicas: 1
      template:
        metadata:
          labels:
            app: storefrontend
        spec:
          containers:
          - name: storefrontend
            image: [YOUR DOCKER USER NAME]/storeimage:latest
            ports:
            - containerPort: 80
            env:
            - name: ASPNETCORE_URLS
              value: http://*:80
            - name: ProductEndpoint
              value: http://productsbackend
      selector:
        matchLabels:
          app: storefrontend
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: storefrontend
    spec:
      type: NodePort
      ports:
      - port: 80
        targetPort: 80
        nodePort: 32000
      selector:
        app: storefrontend
    
  3. Remplacez le caractère générique [YOUR DOCKER USERNAME] par votre nom d’utilisateur Docker réel.

    Vous remarquerez que ce fichier est semblable à celui que nous avons créé pour le microservice back-end. Deux différences sont à noter :

    • Nous spécifions un conteneur différent à exécuter sous la valeur spec.template.spec.containers.image du déploiement.
    • Il y a une nouvelle variable d’environnement sous la section spec.template.spec.containers.env. Le code de l’application storefrontend appelle le back-end, mais comme nous n’avons pas spécifié de nom de domaine complet et que nous ne connaissons pas l’adresse IP du microservice back-end, nous utilisons le nom que nous avons spécifié sous le nœud metadata.name du Deployment. Kubernetes se charge du reste.
  4. Déployez le conteneur sur Kubernetes avec la commande suivante :

    kubectl apply -f frontend-deploy.yml
    

    Là encore, vous pouvez utiliser kubectl get pods pour afficher l’état du déploiement. Une fois que la ligne de storefrontend affiche Exécution en cours sous la colonne ÉTAT, tout est prêt à l’emploi.

  5. Pour tester le service front-end, basculez vers l’onglet PORTS, puis à droite de l’adresse locale du port Front End, sélectionnez l’icône du globe. Le navigateur affiche la page d’accueil.

  6. Sélectionnez Produits. Le catalogue affiche la marchandise Contoso.

    A screenshot of the eSHopLite products page.

Dans cet exercice, vous avez créé un fichier de déploiement qui décrit exactement comment vous souhaitez que les conteneurs s’exécutent dans Kubernetes. Ensuite, vous avez fait en sorte que Kubernetes télécharge l’image à partir de Docker Hub et démarre les conteneurs.