Vous êtes sur la page 1sur 58

Kubernetes (Approche DevOps)

09/02/2021
Sopra-Steria

Intervenant : Gérald BENOIT


Edensia

Edensia est une société spécialisée dans le développement d’applications riches


et de solutions BI (reporting, aggrégateurs, infographie)

Segments : prestation de service, formation, éditeur de logiciels en SaaS

Technologies : Java, J2EE, Oracle, MySQL, CI (Maven, Jenkins), Eclipse RCP et


RAP, e4, EMF, BIRT, JasperSoft Studio, HTML 5, Responsive Design, Mobilité

Domaines : Aéronautique, Spatial, Édition de logiciels, Assurances

Références : Safran, EADS S&DE, Airbus, Thales Alenia Space, PDF Solutions,
Keepcore, Steria, Gemalto, Prosodie, La Mutuelle des Motards

Notre credo : l’agilité au coeur de notre métier


Objectifs et Plan de la formation
Objectifs

● Domaine : intégration continue

● Kubernetes est une plateforme de déploiement dotés de multiples capacités


d’intégration

● Vous apprendrez à connaître le GKE (Google Kubernetes Engine)

● Vous apprendrez à déployer une application s’exécutant sur la plateforme


Kubernetes

● Prérequis : connaissances de base de Docker (vu dans le module précédent)


Plan du cours

● Introduction / Prérequis et installation

● Création d’une application de test en Node.js

● Création d’un conteneur d’image Docker encapsulant l’application

● Création d’un cluster / Création d’un pod

● Permettre le trafic externe

● Dimensionnement intelligent des services

● Roll out de mise à jour et réplication

● Console Kubernetes

● Nettoyage

● Pour aller plus loin....


Introduction
Kubernetes… en un schéma
Kubernetes : Introduction

Kubernetes : projet opensource disponible sur kubernetes.io

Peut s’exécuter sur différents environnements, d’un PC ou d’une architecture


multi-noeuds à haute disponibilité.

Dans cette formation, nous présenterons Kubernetes au travers de Google


Kubernetes Engine (une version hébergée de Kubernetes par Google) => nous
gagnerons du temps et irons à l’essentiel ;-)

Pour les Travaux pratiques et l’installation sur vos postes, vous pourrez utiliser
Minikube : http://kubernetes.io/docs/getting-started-guides/minikube/
Prérequis et installation
Installation de GKE (1/2)

Prérequis : Compte Google Account (Gmail ou Google Apps).

Enregistrez-vous sur la console de Google Cloud Platform


(console.cloud.google.com)

Créer un nouveau projet


Installation de GKE (2/2)

Retenez le project ID, il permet d’identifier de manière formelle votre projet parmis
tous les projets Google Cloud. Nous lui donnerons le nom PROJECT_ID jusqu’à la
fin de la formation.

Vous aurez besoin d’activer la facturation dans la Cloud Console pour utiliser les
ressources de Google Cloud.

N’oubliez pas de libérer les ressources utilisées à la fin de la formation pour ne


pas les consommer inutilement (voir la section Nettoyage).

Les nouveaux utilisateurs de Google Cloud Platform ont droit à $300 de


ressources.
Google Cloud Shell

Google Cloud et Kubernetes peut être utilisés à distance (en remote).

Nous utiliserons Google Cloud Shell, un environnement en ligne de commande qui


s’exécute sur le Cloud.

Le Google Cloud Shell est une VM Debian chargée avec tous les outils de
développement nécessaires. Il offre un volume de 5GB et s’exécute sur le Google
Cloud.

La seule chose dont vous aurez besoin est… d’un navigateur.

Pour activer Google Cloud Shell (attention, çà peut être un peu long au premier
démarrage):
Google Cloud Shell
Google Cloud Shell
Google Cloud Shell

Le système vous a déjà authentifié et positionné le projet PROJECT_ID.

$ gcloud auth list

Résultat de la commande :

Credentialed accounts:

- <myaccount>@<mydomain>.com (active)

Documentation disponible sur https://cloud.google.com/sdk/gcloud


Google Cloud Shell

gcloud config list project

Sortie :

[core]
project = <PROJECT_ID>

Cloud Shell peut aussi affecter des variables d’environnement par défaut =>
pratique pour de futures commandes.

echo $GOOGLE_CLOUD_PROJECT

Sortie :

<PROJECT_ID>
Google Cloud Shell

Il est possible d’activer un projet spécifique avec la commande suivante :

gcloud config set project <PROJECT_ID>

Pour retrouver le PROJECT_ID :


Kubernetes - Hello world
Création d’une application Node.js avec Google Cloud Shell
Création d’une appli Node.js sur GCS (1/2)

Déployons une application sur Google Kubernetes Engine.


Pour celà, nous créons un simple serveur Node.js en utilisant le Cloud Shell :

vi server.js

avec ce contenu :

var http = require('http');


var handleRequest = function(request, response) {
response.writeHead(200);
response.end("Hello World!");
}
var www = http.createServer(handleRequest);
www.listen(8080);
Création d’une appli Node.js sur GCS (2/2)

Depuis le Cloud Shell, quittez l’éditeur et sauver ke server.js file. CloudShell a


l’exécutable node installé. Exécutons cette simple commande (pas de sortie) :

node server.js

Utilisez la fonctionnalité de prévisualisation de CloudShell pour ouvrir un nouveau


navigateur et exécuter l’application sur le port 8080 :
Kubernetes : Docker et GCR
Apprenez à packager votre application et à la rendre disponible
dans un registre privé pour Kubernetes
Conteneurisation de l’appli Node.js

Maintenant que l’application est créée… isolons là dans un conteneur Docker.

Avant de continuer, stopper le serveur node avec Ctrl-C dans CloudShell.


Création d’un Dockerfile

Créons un Dockerfile qui décrit l’image à construire.

Rappel : les images Docker peuvent étendre des images existantes. Dans ce
cours, nous étendons l’image à créer d’une image Node existante.

vi Dockerfile

avec ce contenu :

FROM node:12.12.0
EXPOSE 8080
COPY server.js .
CMD node server.js
Création de l’image Docker

Cette image Docker :

1. démarrera l’image node téléchargée depuis Docker hub


2. exposera le port 8080
3. copiera notre fichier server.js dans l’image
4. démarrera le serveur node server automatiquement

Sauvegarder le Dockerfile et construisez l’image en exécutant la commande :

docker build -t gcr.io/$GOOGLE_CLOUD_PROJECT/hello-node:v1 .


Exécution de l’image Docker

Tester l’image avec la commande suivante qui exécute le conteneur :

docker run -d -p 8080:8080


gcr.io/$GOOGLE_CLOUD_PROJECT/hello-node:v1
Tester l’application

Avec la fonctionnalité de prévisualisation du CloudShell.

Ou utiliser curl ou wget depuis le CloudShell :

curl http://localhost:8080

Sortie :

Hello World!
Arrêter le conteneur

Lister les conteneurs en cours d’exécution :

docker ps

Sortie de la console :

CONTAINER ID IMAGE COMMAND


2c66d0efcbd4 gcr.io/$GOOGLE_CLOUD_PROJECT/hello-node:v1 "/bin/sh -c
'node

Arrêter le conteneur en cours d’exécution :


docker stop 2c66d0efcbd4

Sortie de la console :

2c66d0efcbd4
GCR : Google Container Registry

L’image fonctionne comme prévue.

Nous pouvons maintenant la stocker dans Google Container Registry, un


repository privé pour images Docker images accessibles des projets Google
Cloud.

Il faut d’abord activer le registre.


Push de l’image Docker sur GCR (1/2)

You can now push your container image to this cloud private registry :

docker -- push gcr.io/$GOOGLE_CLOUD_PROJECT/hello-node:v1

This initial push may take a few minutes to complete:

The push refers to a repository [gcr.io/qwiklabs-gcp-6h281a111f098/hello-node]


ba6ca48af64e: Pushed
381c97ba7dc3: Pushed
604c78617f34: Pushed
fa18e5ffd316: Pushed
0a5e2b2ddeaa: Pushed
53c779688d06: Pushed
60a0858edcd5: Pushed
b6ca02dfe5e6: Pushed
v1: digest:
sha256:8a9349a355c8e06a48a1e8906652b9259bba6d594097f115060acca8e3e941a2 size:
2002
Push de l’image Docker sur GCR (2/2)

Vous devriez voir l’image du conteneur listée dans la console :

Tools > Container Registry.

L’image Docker est disponible pour Kubernetes. Il peut y accéder et l'orchestrer.


Kubernetes : Cluster
Apprenez à créer et configurer un Cluster
Création d’un cluster

Nous sommes prêts à créer un cluster Kubernetes.

Allez dans la section Google Kubernetes Engine (GKE) de la console.


Cluster : définition

Un cluster est un serveur d’API maître de Kubernetes, géré par Google et


fonctionnant avec quelques noeuds de travail.

Les noeuds sont des machines virtuelles du Compute Engine.


Création d’un cluster (1/3)

Vérifiez que votre projet est bien activé dans gcloud :

gcloud config set project PROJECT_ID

Utilisons la commande gcloud depuis CloudShell pour créer un cluster avec deux
noeuds n1-standard-1 :

gcloud container clusters create hello-world \


--num-nodes 2 \
--machine-type n1-standard-1 \
--zone us-central1-f
Création d’un cluster (2/3)

Si la création du cluster s’est bien passée, vous devriez avoir :

Creating cluster hello-world...done.

Created
[https://container.googleapis.com/v1/projects/PROJECT_ID/zones/us-central1-f/c
lusters/hello-world].

kubeconfig entry generated for hello-world.

NAME LOCATION MASTER_VERSION MASTER_IP MACHINE_TYPE


NUM_NODES STATUS

hello-world us-central1-f 1.13.10-gke.0 35.232.69.3 n1-standard-1 2


RUNNING
Création d’un cluster (3/3)

Vous pouvez aussi créer ce cluster via la Console :

Compute > Kubernetes Engine > Kubernetes Clusters > Create a container cluster.

Vous devriez avoir maintenant un cluster Kubernetes fonctionnel géré par Google
Kubernetes Engine:
Kubernetes : pod
Déploiement dans un cluster
Définition du POD

Il est temps de déployer l’application conteneurisée dans le cluster Kubernetes!

Nous utiliserons la commande kubectl

Un pod Kubernetes est un groupe de conteneurs liés ensemble pour les besoins
de l’administration et du réseau.

Il peut contenir un ou plusieurs conteneurs.

Dans le TP, nous utilisons un container construit avec notre image Node.js stockée
dans notre registre de conteneurs privé. Le contenu sera disponible sur port 8080.

Un déploiement Kubernetes vérifie l’état du Pod et redémarre le conteneur du Pod


si celui-ci s’arrête.
Déploiement : création du POD

Créons un POD avec la commande kubectl create deployment pour créer un


déploiement. Le POD exécute un conteneur basée sur l’image Docker fournie :

kubectl create deployment hello-node \


--image=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-node:v1
La sortie console :

deployment.apps/hello-node created

Nous avons créé un objet deployment. Ce déploiement gère un replica d’un POD
exécutant l’image hello-node:v1.
Déploiement : commandes utiles (1/2)

Pour voir le déploiement créé, exécuter la commande suivante :

kubectl get deployments

Sortie de la console :

NAME READY UP-TO-DATE AVAILABLE AGE


hello-node 1/1 1 1 2m
Pour voir le POD créé par le déploiement, exécute la commande :

kubectl get pods

Sortie de la console :

NAME READY STATUS RESTARTS


AGE
hello-node-714049816-ztzrb 1/1 Running 0
6m
Déploiement : commandes utiles (2/2)

kubectl cluster-info

kubectl config view

kubectl get events

kubectl logs <pod-name>


Kubernetes : Trafic externe
Ouvrir votre déploiement à l’extérieur : permettre le trafic externe
Permettre le trafic externe (1/3)

Par défaut, le pod est seulement accessible à son adresse IP interne dans le
cluster.

Pour que notre application hello-node container soit accessible de l’extérieur de


notre réseau virtuel Kubernetes, il faut exposer le POD comme un service
Kubernetes.
Permettre le trafic externe (2/3)

Exposons le pod à l’internet public avec la commande kubectl expose combinée


au flag --type="LoadBalancer" . Ce flag est requis pour la création d’une IP
accessible de l’extérieur:

kubectl expose deployment hello-node --type=LoadBalancer


--port=8080

Sortie de la console :

service/hello-node exposed
Permettre le trafic externe (3/3)

Kubernetes crée le load balancer et les règles de Compute Engine forwarding,


target pools, et règles de firewall pour rendre le service accessible de l’extérieur.

Pour trouver l’adresse IP externe, exécuter la commande suivantes pour lister tous
les services du cluster :

kubectl get services

Sortie de la console :
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE

hello-node LoadBalancer 10.3.29.107 104.154.90.147 8080:32036/TCP 3m6s

kubernetes ClusterIP 10.3.240.1 <none> 443/TCP 8m


Accéder au service depuis Internet

Maintenant, vous devriez pouvoir accéder au service en tapant l’adresse suivante


dans votre navigateur :

http://<EXTERNAL_IP>:8080

Nous avons appris à conteneuriser et déployer une application simple avec


Kubernetes. A partir de là, Kubernetes se charge de tout le reste (répartition de
charge, firewall, maintenance, monitoring…)
Kubernetes : Scaling
Faire évoluer votre infrastructure
Faire évoluer l’infrastructure (1/3)

Une des fonctionnalités les plus puissantes de Kubernetes est sa capacité à


évoluer automatiquement et simplement.

Vous pouvez contrôler le nombre de répliques de vos applications :

kubectl scale deployment hello-node --replicas=4

Sortie console :

deployment.extensions/hello-node scaled
Faire évoluer l’infrastructure (2/3)

Pour vérifier que la réplication a bien été prise en compte :

kubectl get deployment

Sortie console :

NAME READY UP-TO-DATE AVAILABLE AGE

hello-node 4/4 4 4 12m


Faire évoluer l’infrastructure (3/3)

Théoriquement, nous devrions avoir 4 pods (1 pour chaque réplique). Vérifions en


listant les pods :

kubectl get pods

Sortie console :

NAME READY STATUS RESTARTS AGE

hello-node-714049816-g4azy 1/1 Running 0 1m

hello-node-714049816-rk0u6 1/1 Running 0 1m

hello-node-714049816-sh812 1/1 Running 0 1m

hello-node-714049816-ztzrb 1/1 Running 0 16m


Etat des lieux
Kubernetes : Roll-out and upgrade
Mettre à jour l’infrastructure sans interruption de service
Roll-out and upgrade (1/4)

A un moment donné, vous serez amené à déployer des correctifs de bugs ou de


nouvelles fonctionnalités.

Kubernetes vous permet de déployer une nouvelle version sans impacter les
utilisateurs. Wow!!!! Comment?

Modifions notre application Node JS. Depuis le CloudShell, éditez server.js et


mettez à jour le message de réponse :

response.end("Hello Kubernetes World!");


Roll-out and upgrade (2/4)

Construisons et publions une nouvelle image Docker avec un nouveau tag (v2) :

docker build -t gcr.io/$GOOGLE_CLOUD_PROJECT/hello-node:v2 .

docker -- push gcr.io/$GOOGLE_CLOUD_PROJECT/hello-node:v2

Nous sommes prêts à mettre à jour notre application, en modifiant l’image


associée au déploiement hello-node.

Nous allons faire passer gcr.io/PROJECT_ID/hello-node:v1 à


gcr.io/PROJECT_ID/hello-node:v2
Roll-out and upgrade (3/4)

Nous utiliserons la commande kubectl set image. Cette commande déclenchera


un nouveau déploiement en utilisant la nouvelle image.

kubectl set image deployment.apps/hello-node \

hello-node=gcr.io/$GOOGLE_CLOUD_PROJECT/hello-node:v2

Pour observer le déroulé de ce rollout :

kubectl rollout status deployment hello-node

Sortie de la console :

Waiting for deployment "hello-node" rollout to finish: 3 of


4 updated replicas are available...

deployment "hello-node" successfully rolled out


Roll-out and upgrade (4/4)

Pendant l’opération, les utilisateurs finaux ne verront pas d’interruption.

A la fin de l’opération, les utilisateurs accèderont automatiquement à la nouvelle


version.

Bien intégrer ce point lors des développements logiciels car beaucoup trop de
développements ne prennent pas en compte ces capacités liées aux technologies
de déploiement.

C’est une fonctionnalité extrêmement puissante qui vous permet de vous focaliser
sur l’application plutôt que sur l’infrastructure.
Merci
Pour me contacter

Edensia

Gérald BENOIT

email : gerald.benoit@edensia.com
web : www.edensia.com

Vous aimerez peut-être aussi