Vous êtes ici : Formations en Ligne Gratuites » Catalogue » workbooks » Préparation à la Certification K8S CKA » DOF307 - Troubleshooting K8s

Ceci est une ancienne révision du document !

Table des matières

DOF305 - Gestion du Réseau, des Services et d'une Architecture de Microservices

Version - 2022.02

Dernière mise-à-jour : 2022/09/16 05:51

DOF305 - Gestion du Réseau, des Services et d'une Architecture de Microservices

Contenu du Module

DOF305 - Gestion du Réseau, des Services et d'une Architecture de Microservices
- Contenu du Module
- LAB #1 - Gestion du Réseau et des Services
  - 1.1 - Présentation
  - 1.2 - Le Service NodePort
  - 1.3 - Le Service ClusterIP
- LAB #2 - Gestion de l'Architecture des Microservices
  - 2.1 - Présentation
  - 2.2 - Création des Deployments
  - 2.3 - Création des Services
  - 2.4 - Déployer l'Application
  - 2.5 - Scaling Up

LAB #1 - Gestion du Réseau et des Services

1.1 - Présentation

Kubernetes impose des conditions pour l’implémentation d'un réseau :

Les PODs sur un nœud peuvent communiquer avec tous les PODs sur tous le nœuds sans utiliser NAT,
Les agents sur un nœud (par exemple kubelet) peuvent communiquer avec tous les PODs sur le nœud.

Important : La description technique et détaillée de l'approche réseau de Kubernetes peut être consultée à l'adresse : https://kubernetes.io/docs/concepts/cluster-administration/networking/.

Dans le cluster de ce cours, le réseau mis en place pour Kubernetes est le 192.168.56.0/24

Actuellement il y a 3 PODs dans le cluster :

root@kubemaster:~# kubectl get pods
NAME                                READY   STATUS    RESTARTS   AGE
myapp-deployment-57c6cb89d9-dh4cb   1/1     Running   0          7h36m
myapp-deployment-57c6cb89d9-f69nk   1/1     Running   0          7h36m
myapp-deployment-57c6cb89d9-q7d4p   1/1     Running   0          7h36m

Sous Kubernetes, les adresses IP sont attachées aux PODs :

root@kubemaster:~# kubectl get pods -o wide
NAME                                READY   STATUS    RESTARTS   AGE     IP               NODE                       NOMINATED NODE   READINESS GATES
myapp-deployment-57c6cb89d9-dh4cb   1/1     Running   0          7h37m   192.168.150.12   kubenode2.ittraining.loc   <none>           <none>
myapp-deployment-57c6cb89d9-f69nk   1/1     Running   0          7h37m   192.168.239.19   kubenode1.ittraining.loc   <none>           <none>
myapp-deployment-57c6cb89d9-q7d4p   1/1     Running   0          7h37m   192.168.239.20   kubenode1.ittraining.loc   <none>           <none>

Important : Notez que les adresses 192.168.239.x sont associées aux PODs sur kubenode1 tandis que les adresses 192.168.150.x sont associées aux PODs sur kubenode2. Ces adresses sont issues du réseau 192.168.0.0/16 stipulé par l'option –pod-network-cidr lors de l'initialisation du maître du cluster.

En sachant que dans chaque POD existe un conteneur Nginx, testez si vous pouvez afficher la page d'accueil de Nginx en vous connectant à kubenode1 et kubenode2 à partir de votre Gateway :

trainee@kubemaster:~$ exit
déconnexion
Connection to 10.0.2.65 closed.
trainee@gateway:~$ curl 192.168.56.3
curl: (7) Failed to connect to 192.168.56.3 port 80: Connection refused
trainee@gateway:~$ curl 192.168.56.4
curl: (7) Failed to connect to 192.168.56.4 port 80: Connection refused

Important : Notez l'échec de la connexion.

Testez maintenant si vous pouvez afficher la page d'accueil de Nginx en vous connectant à un des PODs à partir de votre Gateway :

trainee@gateway:~$ curl 192.168.239.19
^C

Connectez-vous à kubemaster :

trainee@gateway:~$ ssh -l trainee 192.168.56.2
trainee@192.168.56.2's password: trainee
Linux kubemaster.ittraining.loc 4.9.0-19-amd64 #1 SMP Debian 4.9.320-2 (2022-06-30) x86_64

The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.
Last login: Wed Jul 13 15:45:46 2022 from 10.0.2.40
trainee@kubemaster:~$ su -
Mot de passe : fenestros
root@kubemaster:~#

Bien évidement, il est possible d'afficher la page en vous connectant à un des PODs de l'intérieur du cluster :

root@kubemaster:~# curl 192.168.239.19
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
    body {
        width: 35em;
        margin: 0 auto;
        font-family: Tahoma, Verdana, Arial, sans-serif;
    }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>

Important : Retenez donc qu'à ce stade il n'est pas possible d'afficher la page d'accueil de Nginx en vous connectant de l'extérieur du cluster.

Lors de l'installation du cluster nous avons spécifié l'utilisation d'une extension réseau appelée Calico, issue de la liste suivante :

Calico,
Cilium,
Flannel,
Kube-router,
Romana,
WeaveNet,
Antrea,
kube-ovn,
Canal (utilise Flannel pour le réseau et Calico pour le pare-feu).

Important : Une étude comparative des extensions réseau pour Kubernetes peut être trouvée à la page : https://itnext.io/benchmark-results-of-kubernetes-network-plugins-cni-over-10gbit-s-network-updated-august-2020-6e1b757b9e49.

Ces extensions permettent la mise en place de Services :

NodePort,
- Ce Service rend un POD accessible sur un port du nœud le contenant,
ClusterIP
- Ce Service crée une adresse IP virtuelle afin de permettre la communication entre de services différents dans le cluster, par exemple des serveurs front-end avec des serveurs back-end,
LoadBalancer
- Ce service provisionne un équilibrage de charge pour une application dans certains fournisseurs de Cloud publique tels Amazon Web Services et Google Cloud Platform.

1.2 - Le Service NodePort

Le Service NodePort définit trois ports :

TargetPort : le port sur le POD,
Port : le port sur le Service lié à un IP du Cluster,
NodePort : le port sur le Nœud issu de la plage 30000-32767.

Si dans le même nœud, plusieurs PODs ont les étiquettes qui correspondent au selector du Service, le Service identifie les PODs et s'étend automatiquement pour englober tous les PODs. Les PODs sont appelés des End-Points :

Important : Notez que dans ce cas l'équilibrage de charge est automatique est utilise l’algorithme Random avec une affinité de session..

De même, quand les PODs sont distribués sur plusieurs nœuds, le Service s'étend pour tout englober :

Créez donc le fichier YAML service-definition.yaml :

root@kubemaster:~# vi service-definition.yaml
root@kubemaster:~# cat service-definition.yaml
apiVersion: v1
kind: Service
metadata:
  name: myapp-service

spec:
  type: NodePort
  ports:
    - targetPort: 80
      port: 80
      nodePort: 30008
  selector:
    app: myapp
    type: front-end

Important : Notez que si le champ type: est manquant, sa valeur par défaut est ClusterIP. Notez aussi que dans ports, seul le champ port est obligatoire. Si le champ targetPort est manquant, sa valeur par défaut est celle du champ port. Si le champ nodePort est manquant, sa valeur par défaut est le premier port disponible dans la plage entre 30 000 et 32 767. Dernièrement, il est possible de spécifier de multiples définitions de ports dans le service.

Le champs selector contient les étiquettes des PODs concernés par la mise en place du Service :

root@kubemaster:~# cat pod-definition.yaml
apiVersion: v1
kind: Pod
metadata:
  name: myapp-pod
  labels:
    app: myapp
    type: front-end
spec:
  containers:
    - name: nginx-container
      image: nginx

Créez le Service en utilisant le fichier service-definition.yaml :

root@kubemaster:~# kubectl create -f service-definition.yaml
service/myapp-service created

Constatez la création du Service :

root@kubemaster:~# kubectl get services
NAME            TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)        AGE
kubernetes      ClusterIP   10.96.0.1      <none>        443/TCP        26h
myapp-service   NodePort    10.97.228.14   <none>        80:30008/TCP   13s

Important : Notez que le Service a une adresse IP du cluster et qu'il a exposé le port 30 008.

Testez maintenant si vous pouvez afficher la page d'accueil de Nginx en vous connectant à un des PODs à partir de votre Gateway en utilisant le port exposé :

root@kubemaster:~# exit
déconnexion

trainee@kubemaster:~$ exit
déconnexion
Connection to 192.168.56.2 closed.

trainee@gateway:~$ curl 192.168.56.3:30008
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
    body {
        width: 35em;
        margin: 0 auto;
        font-family: Tahoma, Verdana, Arial, sans-serif;
    }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>

trainee@gateway:~$ curl 192.168.56.4:30008
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
    body {
        width: 35em;
        margin: 0 auto;
        font-family: Tahoma, Verdana, Arial, sans-serif;
    }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>

1.3 - Le Service ClusterIP

Le Service ClusterIP permet de regrouper les PODs offrant le même service afin de faciliter la communication, par exemple :

3 PODs front-end = une adresse ClusterIP,
3 PODs back-end = une autre adresse ClusterIP.

Pour créer un Service ClusterIP, créez le fichier clusterip-definition.yaml :

trainee@gateway:~$ ssh -l trainee 192.168.56.2
trainee@192.168.56.2's password: trainee
Linux kubemaster.ittraining.loc 4.9.0-19-amd64 #1 SMP Debian 4.9.320-2 (2022-06-30) x86_64

The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.
Last login: Wed Jul 13 15:53:15 2022 from 10.0.2.40
trainee@kubemaster:~$ su -
Mot de passe : fenestros
root@kubemaster:~# vi clusterip-definition.yaml
root@kubemaster:~# cat clusterip-definition.yaml
---
apiVersion: v1
kind: Service
metadata:
  name: back-end

spec:
  type: ClusterIP
  ports:
    - targetPort: 80
      port: 80
  selector:
    app: myapp
    type: front-end

Créez le Service en utilisant le fichier clusterip-definition.yaml :

root@kubemaster:~# kubectl create -f clusterip-definition.yaml
service/back-end created

Vérifiez maintenant la présence du Service :

root@kubemaster:~# kubectl get services
NAME            TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
back-end        ClusterIP   10.111.91.134   <none>        80/TCP         3m35s
kubernetes      ClusterIP   10.96.0.1       <none>        443/TCP        28h
myapp-service   NodePort    10.97.228.14    <none>        80:30008/TCP   98m

Supprimez maintenant les Services créés :

root@kubemaster:~# kubectl delete service myapp-service
service "myapp-service" deleted

root@kubemaster:~# kubectl delete service back-end
service "back-end" deleted

Dernièrement supprimez le Deployment myapp-deployment :

root@kubemaster:~# kubectl delete deployment myapp-deployment
deployment.extensions "myapp-deployment" deleted

Vérifiez qu'il ne reste que le service par défaut kubernetes :

root@kubemaster:~# kubectl get all
NAME                 TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
service/kubernetes   ClusterIP   10.96.0.1    <none>        443/TCP   28h

LAB #2 - Gestion d'une Architecture de Microservices

2.1 - Présentation

Vous allez mettre en place une application simple, appelé demo-voting-app et développé par Docker, sous forme de microservices :

Dans cette application le conteneur voting-app permet de voter pour des chats ou des chiens. Cette application tourne sous Python et fournit une interace HTML :

Lors de la vote, le résultat de celle-ci est stocké dans Redis dans une base de données en mémoire. Le résultat est ensuite passé au conteneur Worker qui tourne sous .NET et qui met à jour la base de données persistante dans le conteneur db qui tourne sous PostgreSQL.

L'application result-app qui tourne sous NodeJS lit ensuite la table dans la base de données PostgreSQL et affiche le résultat sous forme HTML :

Cette application peut être mise en place sous docker avec les commandes suivantes :

docker run -d --name=redis redis
docker run -d --name=db -e POSTGRES_PASSWORD=postgres -e POSTGRES_USER=postgres postgres:9.4 
docker run -d --name=vote -p 5000:80 --link redis:redis dockersamples/examplevotingapp_vote
docker run -d --name=result -p 5001:80 --link db:db dockersamples/examplevotingapp_result
docker run -d --name=worker --link db:db --link redis:redis dockersamples/examplevotingapp_worker

Par contre, Docker annonce le retrait éventuel de l'option –lien et indique qu'il vaudrait mieux utiliser des réseaux pour assurer la communication entre les conteneurs :

“Warning: The –link flag is a legacy feature of Docker. It may eventually be removed. Unless you absolutely need to continue using it, we recommend that you use user-defined networks to facilitate communication between two containers instead of using –link. One feature that user-defined networks do not support that you can do with –link is sharing environment variables between containers. However, you can use other mechanisms such as volumes to share environment variables between containers in a more controlled way.”

Cette application peut être mise en place sous docker swarm avec les commandes suivantes :

docker@manager1:~$ docker node ls
ID                            HOSTNAME            STATUS              AVAILABILITY        MANAGER STATUS      ENGINE VERSION
vwshwppuaoze785gy12k0gh62 *   manager1            Ready               Active              Leader              18.09.3
t0rjtq76j35mbn44olp0t3yeq     worker1             Ready               Active                                  18.09.3
udv7w988tepuba7pf6rb5k1o3     worker2             Ready               Active                                  18.09.3
uz2m26qe0hdf7lplb9a5m0ysv     worker3             Ready               Active                                  18.09.3
sfig9atrbgzt41sjxhj95wfgu     worker4             Ready               Active                                  18.09.3
56az1cupssf9uqx9h0yvbmydw     worker5             Ready               Active                                  18.09.3

docker@manager1:~$ vi docker-stack.yml
docker@manager1:~$ cat docker-stack.yml
version: "3"
services:

  redis:
    image: redis:alpine
    ports:
      - "6379"
    networks:
      - frontend
    deploy:
      replicas: 1
      update_config:
        parallelism: 2
        delay: 10s
      restart_policy:
        condition: on-failure
  db:
    image: postgres:9.4
    volumes:
      - db-data:/var/lib/postgresql/data
    networks:
      - backend
    deploy:
      placement:
        constraints: [node.role == manager]
  vote:
    image: dockersamples/examplevotingapp_vote:before
    ports:
      - 5000:80
    networks:
      - frontend
    depends_on:
      - redis
    deploy:
      replicas: 2
      update_config:
        parallelism: 2
      restart_policy:
        condition: on-failure
  result:
    image: dockersamples/examplevotingapp_result:before
    ports:
      - 5001:80
    networks:
      - backend
    depends_on:
      - db
    deploy:
      replicas: 1
      update_config:
        parallelism: 2
        delay: 10s
      restart_policy:
        condition: on-failure

  worker:
    image: dockersamples/examplevotingapp_worker
    networks:
      - frontend
      - backend
    deploy:
      mode: replicated
      replicas: 1
      labels: [APP=VOTING]
      restart_policy:
        condition: on-failure
        delay: 10s
        max_attempts: 3
        window: 120s
      placement:
        constraints: [node.role == manager]

  visualizer:
    image: dockersamples/visualizer:stable
    ports:
      - "8080:8080"
    stop_grace_period: 1m30s
    volumes:
      - "/var/run/docker.sock:/var/run/docker.sock"
    deploy:
      placement:
        constraints: [node.role == manager]

networks:
  frontend:
  backend:

volumes:
  db-data:

docker@manager1:~$ docker stack deploy -c docker-stack.yml app
Creating network app_backend
Creating network app_frontend
Creating network app_default
Creating service app_worker
Creating service app_visualizer
Creating service app_redis
Creating service app_db
Creating service app_vote
Creating service app_result

2.2 - Création des Deployments

Créez le répertoire myapp. Placez-vous dans ce répertoire et créez le fichier voting-app-deployment.yaml :

root@kubemaster:~# mkdir myapp
root@kubemaster:~# cd myapp
root@kubemaster:~/app# vi voting-app-deployment.yaml
root@kubemaster:~/app# cat voting-app-deployment.yaml
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: voting-app-deployment
  labels:
    app: demo-voting-app
spec:
  replicas: 1
  selector:
    matchLabels:
      name: voting-app-pod
      app: demo-voting-app
  template:
    metadata:
      name: voting-app-pod
      labels:
        name: voting-app-pod
        app: demo-voting-app

    spec:
      containers:
      - name: voting-app
        image: dockersamples/examplevotingapp_vote
        ports:
        - containerPort: 80

Important : Ce fichier décrit un Deployment. Notez que le Deployment crée un replica du POD spécifié par template contenant un conteneur dénommé voting-app qui utilise le port 80 et qui est créé à partir de l'image dockersamples/examplevotingapp_vote.

Créez maintenant le fichier redis-deployment.yaml :

root@kubemaster:~/app# vi redis-deployment.yaml
root@kubemaster:~/app# cat redis-deployment.yaml
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: redis-deployment
  labels:
    app: demo-voting-app
spec:
  replicas: 1
  selector:
    matchLabels:
      name: redis-pod
      app: demo-voting-app
  template:
    metadata:
      name: redis pod
      labels:
        name: redis-pod
        app: demo-voting-app

    spec:
      containers:
      - name: redis
        image: redis
        ports:
        - containerPort: 6379

Important : Ce fichier décrit un Deployment. Notez que le Deployment crée un replica du POD spécifié par template contenant un conteneur dénommé redis qui utilise le port 6379 et qui est créé à partir de l'image redis.

Créez le fichier worker-deployment.yaml :

root@kubemaster:~/app# vi worker-deployment.yaml
root@kubemaster:~/app# cat worker-deployment.yaml
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: worker-app-deployment
  labels:
    app: demo-voting-app
spec:
  replicas: 1
  selector:
    matchLabels:
      name: worker-app-pod
      app: demo-voting-app
  template:
    metadata:
      name: worker-app-pod
      labels:
        name: worker-app-pod
        app: demo-voting-app

    spec:
      containers:
      - name: worker-app
        image: dockersamples/examplevotingapp_worker

Important : Ce fichier décrit un Deployment. Notez que le Deployment crée un replica du POD spécifié par template contenant un conteneur dénommé worker-app qui est créé à partir de l'image dockersamples/examplevotingapp_worker.

Créez ensuite le fichier postgres-deployment.yaml :

root@kubemaster:~/app# vi postgres-deployment.yaml
root@kubemaster:~/app# cat postgres-deployment.yaml
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: postgres-deployment
  labels:
    app: demo-voting-app
spec:
  replicas: 1
  selector:
    matchLabels:
      name: postgres-pod
      app: demo-voting-app
  template:
    metadata:
      name: postgres pod
      labels:
        name: postgres-pod
        app: demo-voting-app

    spec:
      containers:
      - name: postgres
        image: postgres:9.4
        env:
        - name: POSTGRES_USER
          value: postgres
        - name: POSTGRES_PASSWORD
          value: postgres
        ports:
        - containerPort: 5432

Important : Ce fichier décrit un Deployment. Notez que le Deployment crée un replica du POD spécifié par template contenant un conteneur dénommé postgres qui utilise le port 5432 et qui est créé à partir de l'image postgres:9.4.

Dernièrement, créez le fichier result-app-deployment.yaml :

root@kubemaster:~/app# vi result-app-deployment.yaml
root@kubemaster:~/app# cat result-app-deployment.yaml
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: result-app-deployment
  labels:
    app: demo-voting-app
spec:
  replicas: 1
  selector:
    matchLabels:
      name: result-app-pod
      app: demo-voting-app
  template:
    metadata:
      name: result-app-pod
      labels:
        name: result-app-pod
        app: demo-voting-app

    spec:
      containers:
      - name: result-app
        image: dockersamples/examplevotingapp_result
        ports:
        - containerPort: 80

Important : Ce fichier décrit un Deployment. Notez que le Deployment crée un replica du POD spécifié par template contenant un conteneur dénommé result-app qui utilise le port 80 et qui est créé à partir de l'image dockersamples/examplevotingapp_result.

2.3 - Création des Services

Créez maintenant le fichier redis-service.yaml :

root@kubemaster:~/app# vi redis-service.yaml
root@kubemaster:~/app# cat redis-service.yaml
---
apiVersion: v1
kind: Service
metadata:
  name: redis
  labels:
    name: redis-service
    app: demo-voting-app

spec:
  ports:
  - port: 6379
    targetPort: 6379
  selector:
    name: redis-pod
    app: demo-voting-app

Important : Ce fichier décrit un Service ClusterIP. Notez que le Service expose le port 6379 sur tout POD ayant le nom redis-pod.

Créez ensuite le fichier postgres-service.yaml :

root@kubemaster:~/app# vi postgres-service.yaml
root@kubemaster:~/app# cat postgres-service.yaml
---
apiVersion: v1
kind: Service
metadata:
  name: db
  labels:
    name: db-service
    app: demo-voting-app

spec:
  ports:
  - port: 5432
    targetPort: 5432
  selector:
    name: postgres-pod
    app: demo-voting-app

Important : Ce fichier décrit un Service ClusterIP. Notez que le Service expose le port 5432 sur tout POD ayant le nom postgres-pod.

Créez le fichier voting-app-service.yaml :

root@kubemaster:~/app# vi voting-app-service.yaml
root@kubemaster:~/app# cat voting-app-service.yaml
---
apiVersion: v1
kind: Service
metadata:
  name: voting-service
  labels:
    name: voting-service
    app: demo-voting-app

spec:
  type: NodePort
  ports:
  - port: 80
    targetPort: 80
  selector:
    name: voting-app-pod
    app: demo-voting-app

Important : Ce fichier décrit un Service NodePort. Notez que le Service expose le port 80 sur tout POD ayant le nom voting-app-pod.

Dernièrement, créez le fichier result-app-service.yaml :

root@kubemaster:~/app# vi result-app-service.yaml
root@kubemaster:~/app# cat result-app-service.yaml
---
apiVersion: v1
kind: Service
metadata:
  name: result-service
  labels:
    name: result-service
    app: demo-voting-app

spec:
  type: NodePort
  ports:
  - port: 80
    targetPort: 80
  selector:
    name: result-app-pod
    app: demo-voting-app

Important : Ce fichier décrit un Service NodePort. Notez que le Service expose le port 80 sur tout POD ayant le nom result-app-pod.

2.4 - Déployer l'Application

Vérifiez que vous avez créé tous les fichiers YAML necéssaires :

root@kubemaster:~/myapp# ls
postgres-deployment.yaml  redis-deployment.yaml  result-app-deployment.yaml  voting-app-deployment.yaml  worker-deployment.yaml
postgres-service.yaml     redis-service.yaml     result-app-service.yaml     voting-app-service.yaml

Utilisez ensuite la commande kubectl create :

root@kubemaster:~/myapp# kubectl create -f .
deployment.apps/postgres-deployment created
service/db created
deployment.apps/redis-deployment created
service/redis created
deployment.apps/result-app-deployment created
service/result-service created
deployment.apps/voting-app-deployment created
service/voting-service created
deployment.apps/worker-app-deployment created

Important : Notez l'utilisation du caractère . qui indique tout fichier dans le répertoire courant.

Attendez que tous les Deployments soient READY (7 à 10 minutes) :

root@kubemaster:~/myapp# kubectl get deployments
NAME                    READY   UP-TO-DATE   AVAILABLE   AGE
postgres-deployment     1/1     1            1           51m
redis-deployment        1/1     1            1           51m
result-app-deployment   1/1     1            1           51m
voting-app-deployment   1/1     1            1           51m
worker-app-deployment   1/1     1            1           51m

Contrôlez ensuite l'état des PODs :

root@kubemaster:~/myapp# kubectl get pods
NAME                                     READY   STATUS    RESTARTS   AGE
postgres-deployment-5b8bd66778-j99zz     1/1     Running   0          51m
redis-deployment-67d4c466c4-9wzfn        1/1     Running   0          51m
result-app-deployment-b8f9dc967-nzbgd    1/1     Running   0          51m
voting-app-deployment-669dccccfb-jpn6h   1/1     Running   0          51m
worker-app-deployment-559f7749b6-jh86r   1/1     Running   0          51m

ainsi que la liste des Services :

root@kubemaster:~/myapp# kubectl get services
NAME             TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
db               ClusterIP   10.107.90.45     <none>        5432/TCP       24h
kubernetes       ClusterIP   10.96.0.1        <none>        443/TCP        4d9h
redis            ClusterIP   10.102.154.105   <none>        6379/TCP       24h
result-service   NodePort    10.103.192.107   <none>        80:31526/TCP   24h
voting-service   NodePort    10.96.42.244     <none>        80:32413/TCP   24h

Dans le cas donc de l'exemple dans ce cours, l'application ressemble maintenant au diagramme suivant :

2.5 - Scaling Up

Éditez le fichier voting-app-deployment.yaml et modifiez la valeur du champ replicas de 1 à 3 :

root@kubemaster:~/app# vi voting-app-deployment.yaml
root@kubemaster:~/app# cat voting-app-deployment.yaml
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: voting-app-deployment
  labels:
    app: demo-voting-app
spec:
  replicas: 3
  selector:
    matchLabels:
      name: voting-app-pod
      app: demo-voting-app
  template:
    metadata:
      name: voting-app-pod
      labels:
        name: voting-app-pod
        app: demo-voting-app

    spec:
      containers:
      - name: voting-app
        image: dockersamples/examplevotingapp_vote
        ports:
        - containerPort: 80

Éditez le fichier result-app-deployment.yaml et modifiez la valeur du champ replicas de 1 à 3 :

root@kubemaster:~/app# vi result-app-deployment.yaml
root@kubemaster:~/app# cat result-app-deployment.yaml
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: result-app-deployment
  labels:
    app: demo-voting-app
spec:
  replicas: 3
  selector:
    matchLabels:
      name: result-app-pod
      app: demo-voting-app
  template:
    metadata:
      name: result-app-pod
      labels:
        name: result-app-pod
        app: demo-voting-app

    spec:
      containers:
      - name: result-app
        image: dockersamples/examplevotingapp_result
        ports:
        - containerPort: 80

Appliquez les modifications à l'aide de la commande kubectl apply :

root@kubemaster:~/myapp# kubectl apply -f voting-app-deployment.yaml
Warning: kubectl apply should be used on resource created by either kubectl create --save-config or kubectl apply
deployment.apps/voting-app-deployment configured

root@kubemaster:~/myapp# kubectl apply -f result-app-deployment.yaml
Warning: kubectl apply should be used on resource created by either kubectl create --save-config or kubectl apply
deployment.apps/result-app-deployment configured

Contrôlez ensuite les Deployments :

root@kubemaster:~/myapp# kubectl get deployments
NAME                    READY   UP-TO-DATE   AVAILABLE   AGE
postgres-deployment     1/1     1            1           23h
redis-deployment        1/1     1            1           23h
result-app-deployment   3/3     3            3           23h
voting-app-deployment   3/3     3            3           23h
worker-app-deployment   1/1     1            1           23h

ainsi que les PODs :

root@kubemaster:~/myapp# kubectl get pods -o wide
NAME                                     READY   STATUS    RESTARTS   AGE     IP                NODE        NOMINATED NODE   READINESS GATES
postgres-deployment-5b8bd66778-j99zz     1/1     Running   1          169m    192.168.35.83     kubenode2   <none>           <none>
redis-deployment-67d4c466c4-9wzfn        1/1     Running   1          169m    192.168.205.217   kubenode1   <none>           <none>
result-app-deployment-b8f9dc967-nzbgd    1/1     Running   1          169m    192.168.205.218   kubenode1   <none>           <none>
result-app-deployment-b8f9dc967-r84k6    1/1     Running   0          2m36s   192.168.35.86     kubenode2   <none>           <none>
result-app-deployment-b8f9dc967-zbsk2    1/1     Running   0          2m36s   192.168.35.85     kubenode2   <none>           <none>
voting-app-deployment-669dccccfb-jpn6h   1/1     Running   1          169m    192.168.35.82     kubenode2   <none>           <none>
voting-app-deployment-669dccccfb-ktd7d   1/1     Running   0          2m50s   192.168.35.84     kubenode2   <none>           <none>
voting-app-deployment-669dccccfb-x868p   1/1     Running   0          2m50s   192.168.205.219   kubenode1   <none>           <none>
worker-app-deployment-559f7749b6-jh86r   1/1     Running   2          169m    192.168.205.216   kubenode1   <none>           <none>

Dans le cas de l'exemple dans ce cours, l'application ressemble maintenant au diagramme suivant :

Retournez sur le navigateur de votre machine hôte et rafraichissez la page du voting-app :

Important : Notez le POD qui a servi la page.

Rafraîchissez la page de nouveau :

Important : Notez que le POD qui a servi la page a changé.

Notez que ce changement de POD n'indique pas un équilibrage de charge. En effet, il faudrait mettre en place une autre machine virtuelle sous, par exemple, HAProxy pour obtenir l'équilibrage.

Par contre, dans le cas d'une application sur GCP par exemple, il convient de modifier les deux fichiers suivants en changeant la valeur de champ type de NodePort à LoadBalancer puis de configurer une instance du Load Balancer natif de GCP :

root@kubemaster:~/app# vi voting-app-service.yaml
root@kubemaster:~/app# cat voting-app-service.yaml
---
apiVersion: v1
kind: Service
metadata:
  name: voting-service
  labels:
    name: voting-service
    app: demo-voting-app

spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 80
  selector:
    name: voting-app-pod
    app: demo-voting-app

Important : Ce fichier décrit un Service LoadBalancer. Notez que le Service expose le port 80 sur tout POD ayant le nom voting-app-pod.