Exercice - Déployer un conteneur de microservices sur Kubernetes - Training

7 minutes

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 :

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

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

À présent, vous pouvez installer l’outil kubectl :

sudo apt-get update
sudo apt-get install -y kubectl

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.

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

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

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.

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

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.

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

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

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.
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.
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.
Sélectionnez Produits. Le catalogue affiche la marchandise Contoso.

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.

Continuer

Exercice - Déployer un conteneur de microservices sur Kubernetes

Installer les outils et l’implémentation Kubernetes

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

Déployer et exécuter le microservice principal

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

Commentaires