Dans cet article, vous découvrirez ce qu’est un Replication Controller et un ReplicaSet ainsi que leur utilité sur Kubernetes. Vous saurez également comment créer et supprimer ces éléments. Si vous souhaitez approfondir vos connaissances en gestion de conteneurs, notre formation Kubernetes peut vous intéresser.

ReplicaSet et Replication Controller

Pourquoi avons nous besoin d’un Replication Controller ou d’un ReplicaSet ?

Le Replication Controller ou le ReplicaSet servent à trouver l’équilibre entre le chargement et la haute disponibilité. Lorsqu’une application est déployée à l’aide d’un seul Pod, au sein d’un cluster Kubernetes, l’utilisateur perd l’accès à l’application si elle tombe en panne. Cette perte d’accès est due à la mort du Pod au moment de la panne.

La mort des Pods a un effet néfaste sur l’expérience utilisateur, les usagers ne manipulant plus les programmes qui échouent fréquemment. C’est là que le Replication Controller et le ReplicaSet sont utiles, ils servent à surveiller l’état du Pod. Ces deux éléments créent un nouveau Pod identique à celui ayant disparu. Ainsi, l’utilisateur pourra toujours accéder à l’application.

Qu’est-ce qu’un Replication Controller et un Replicaset ?

Le Replication Controller ou « contrôleur de réplication » souvent abrégé « rc », est une boucle d’arbitrage qui surveille l’état d’un cluster. Il gère spécifiquement la réplication et la mise à l’échelle d’un Pod. Il peut aussi créer des Pods de remplacement si le noeud sous-jacent est défectueux.

Le ReplicaSet est un objet ayant pour but de garantir la stabilité d’un ensemble de Pods. Il est utilisé pour maintenir la disponibilité d’un certain nombre de Pods identiques.

Comment le Replication Controller fonctionne ?

Le Replication Controller augmente le nombre de Pods quand il n’y en a pas assez ou il en supprime quand ils sont trop nombreux. Un ReplicationController ressemble à un superviseur de processus, mais au lieu de superviser des processus individuels sur un nœud unique, le ReplicationController supervise plusieurs Pods sur plusieurs nœuds.

Comment le ReplicaSet fonctionne ?

Le ReplicaSet est paramétrable grâce à des champs. Ces champs indiquent le nombre de Pods à maintenir et les données des Pods qui seront créées. Le ReplicaSet créera alors de nouveaux Pods avec les données indiquées lorsque le nombre de Pods est inférieur et il en supprimera quand le nombre de Pods est trop élevé.

La différence entre le ReplicaSet et le Replication Controller

Le ReplicaSet et le Replication Controller veillent tous les deux à ce que le bon nombre de Pods soit déclenché. La différence réside dans l’utilisation de sélecteurs pour répliquer les Pods. Le ReplicationController utilise des sélecteurs basés sur l’équité tandis que le Replica Set utilise également des sélecteurs basés sur l’ensemble.

La différence entre le déploiement et le ReplicaSet/Replication Controller

Le déploiement est un concept plus récent et de plus haut niveau que les contrôleurs de réplication. Ils gèrent le déploiement des Replica Set, et permettent de mettre facilement à jour un Replica Set ainsi que de nombreuses autres fonctionnalités utiles comme revenir à un déploiement précédent.

Comment créer un ReplicaSet sur Kubernetes ?

Créer le fichier YAML

Le fichier YAML est crée avec la commande :


1
nano rs.yaml

Il faut ensuite définir la version de l’API et la méthode de déploiement (ReplicaSet) :


1
2
apiVersion: apps/v1
kind: ReplicaSet

On crée les metadonnées :


1
2
3
4
5
metadata:
   name: frontend
   labels:
      app: guestbook
      tier: frontend

La partie suivante définit les spécifications du ReplicaSet. Dans notre exemple, nous déployons 3 replicas et nous utilisons matchLabels pour indiquer à Kubernetes à quels Pods le déploiement s’appliquera. Nous allons également nommer les conteneurs et définir l’image à utiliser pour le Pod :


1
2
3
4
5
6
7
8
9
10
11
12
13
spec:
   replicas: 3
   selector:
      matchLabels:
         tier: frontend
   template:
      metadata:
         labels:
            tier: frontend
      spec:
         containers:
         - name: hello
           image: gcr.io/google-samples/hello-app:1.0

Voici le fichier YAML entier :


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
apiVersion: apps/v1
kind: ReplicaSet
metadata:
   name: frontend
   labels:
      app: guestbook
      tier: frontend
spec:
   replicas: 3
   selector:
      matchLabels:
         tier: frontend
   template:
      metadata:
         labels:
         tier: frontend
      spec:
         containers:
         - name: hello
         image: gcr.io/google-samples/hello-app:1.0

Pour en savoir plus sur la création du ReplicaSet nous vous invitons à consulter la documentation officielle de Kubernetes.

Déployer le ReplicaSet

Pour le déploiement, il suffit de lancer cette commande :


1
kubectl apply -f rs.yaml

Ou celle-ci :


1
kubectl create -f rs.yaml

Vous pouvez vérifier si le Replica Set a été créé grâce à cette commande :


1
kubectl get ReplicaSet

Comment créer un Replication Controller sur Kubernetes ?

Les Replication Controllers sont créés grâce à cette commande :

$ kubectl create -f FILE

Les éléments du fichier de configuration sont les mêmes que pour le ReplicaSet, ils peuvent être écrits au format YAML ou JSON. Voici le code entier du Replication Controller :


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
{
   "kind": "ReplicationController",
   "apiVersion": "v1",
   "metadata": {
      "name": "frontend",
      "labels": "",
   },
   "spec": {
      "replicas": 3,
      "selector": {
         "app": "frontend"
      },
      "template": {
         "metadata": {
            "labels": {
               "app": "frontend"
            }    
    },
       "spec": {
          "containers": [
          {
              "name": "hello",
              "image": "gcr.io/google-samples/hello-app:1.0",
              "ports": [
                 {
                     "containerPort": 80,
                     "protocol": "TCP"
                 }
              ],
              "imagePullPolicy": "IfNotPresent"
         }
      ],
   }
}
}

Pour en savoir plus sur la création du ReplicationController, nous vous invitons à consulter la documentation officielle de Kubernetes.

Comment supprimer un Replication Controller sur Kubernetes ?

Par défaut, kubectl delete rc redimensionnera le contrôleur à zéro, supprimant alors tous les Pods :


1
$ kubectl delete rc NOM

Si vous voulez supprimer un contrôleur de réplication sans supprimer ses Pods, spécifiez –cascade=false :


1
$ kubectl delete rc NOM --cascade=false

Comment supprimer un ReplicaSet sur Kubernetes ?

Le ReplicaSet se supprime grâce à cette commande :


1
kubectl delete rs NOM

Si vous voulez supprimer un ReplicaSet sans supprimer ses Pods, spécifiez –cascade=false :


1
kubectl delete rs NOM --cascade=false

ReplicaSet VS Replication Controller

Le ReplicaSet étant une technologie plus récente, nous vous conseillons de l’utiliser au détriment du Replication Controller. Les Replica Sets vous aideront à scaler vos applications simplement en créant une nouvelle instance de Pod si le Pod en cours d’exécution échoue.

UNE QUESTION ? UN PROJET ? UN AUDIT DE CODE / D'INFRASTRUCTURE ?

Pour vos besoins d’expertise que vous ne trouvez nulle part ailleurs, n’hésitez pas à nous contacter.

ILS SE SONT FORMÉS CHEZ NOUS

partenaire sncf
partenaire hp
partenaire allianz
partenaire sfr
partenaire engie
partenaire boursorama
partenaire invivo
partenaire orange
partenaire psa
partenaire bnp
partenaire sncf
partenaire hp
partenaire allianz
partenaire sfr
partenaire engie
partenaire boursorama
partenaire invivo
partenaire orange
partenaire psa
partenaire bnp