Exercice - Déployer un conteneur de microservices sur Kubernetes

7 minutes

Kubernetes exécute des conteneurs pour vous. Vous décrivez ce que vous souhaitez que Kubernetes effectue via un fichier YAML. Cet exercice vous guide tout au long de la création du fichier afin de pouvoir déployer et exécuter le service back-end sur Kubernetes.

Important

Avant de continuer, vous devez être sûr d’avoir installé une implémentation Kubernetes. 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 curl commande 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 déploiement de conteneur de gestion de fichiers 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-kubernetes de l’espace de code 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 l’espace réservé [YOUR DOCKER USER NAME] par votre nom d’utilisateur Docker réel.

Ce fichier effectue quelques opérations.

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 des étiquettes et des 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 Kubernetes NodePort. 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 tester le service à partir de l’extérieur du cluster.

Déployer et exécuter le microservice back-end

Ensuite, déployons et exécutons 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éé. Il télécharge l’image à partir de Docker Hub et crée le conteneur.
La kubectl apply commande 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 avez une ligne avec productsbackend suivie d’une chaîne de caractères aléatoires sous la colonne NAME . Lorsque tout est prêt, il existe un 1/1 sous la colonne READY et en cours d’exécution sous la colonne STATUS .
Pour tester le service, basculez vers l’onglet PORTS , près de l’adresse locale du port principal , sélectionnez l’icône globe. Le navigateur ouvre un nouvel onglet à cette adresse.

Pour interroger certains 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

Tout comme le service back-end, nous avons également besoin d’un fichier de déploiement pour le serveur frontal.

Créez 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 l’espace réservé [YOUR DOCKER USERNAME] par votre nom d’utilisateur Docker réel.

Notez que ce fichier est similaire à celui que nous avons créé pour le microservice principal. Il existe deux différences :
- Nous spécifions un conteneur différent à exécuter sous la valeur spec.template.spec.containers.image du déploiement.
- Il existe une nouvelle variable d’environnement sous la spec.template.spec.containers.env section. Le code de l’application storefrontend appelle le back-end, mais parce que nous n’avons pas spécifié de nom de domaine complet (FQDN), nous ne connaissons pas l’adresse IP du microservice principal, nous utilisons le nom que nous avons spécifié sous le metadata.name nœud du Deployment. Kubernetes s’occupe 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 de Contoso.

Dans cet exercice, vous avez créé un fichier de déploiement qui décrit exactement la façon dont vous souhaitez que les conteneurs s’exécutent dans Kubernetes. Kubernetes a ensuite téléchargé l’image à partir de Docker Hub et démarré les conteneurs.

Rétroaction

Cette page vous a-t-elle été utile ?