samedi , 22 septembre 2018
Home » Tutoriel » Comment créer un cluster Kubernetes 1.10 à l’aide de Kubeadm sur Ubuntu 16.04 ? Partie 2

Comment créer un cluster Kubernetes 1.10 à l’aide de Kubeadm sur Ubuntu 16.04 ? Partie 2

Étape 5 – Configuration des nœuds travailleurs

L’ajout de travailleurs (workers) au cluster implique l’exécution d’une seule commande sur chacun d’eux. Cette commande inclut les informations de cluster nécessaires, telles que l’adresse IP et le port du serveur API du maître, ainsi qu’un jeton sécurisé. Seuls les nœuds qui passent dans le jeton sécurisé pourront rejoindre le cluster.

Revenez à votre espace de travail et créez un playbook nommé workers.yml :

nano ~/kube-cluster/workers.yml

Ajoutez le texte suivant au fichier pour ajouter les travailleurs au cluster :

~/kube-cluster/workers.yml

- hosts: master
  become: yes
  gather_facts: false
  tasks:
    - name: get join command
      shell: kubeadm token create --print-join-command
      register: join_command_raw

    - name: set join command
      set_fact:
        join_command: "{{ join_command_raw.stdout_lines[0] }}"


- hosts: workers
  become: yes
  tasks:
    - name: join cluster
      shell: "{{ hostvars['master'].join_command }} >> node_joined.txt"
      args:
        chdir: $HOME
        creates: node_joined.txt

Voici ce que le playbook a fait :

  • Le premier jeu reçoit la commande join qui doit être exécutée sur les nœuds de travail. Cette commande aura le format suivant : kubeadm join –token <token> <master-ip>: <master-port> –discovery-token-ca-cert-hash sha256: <hash>. Une fois qu’il obtient la commande réelle avec les valeurs de token et de hachage (hash) appropriées, la tâche le définit comme un fait, de sorte que la prochaine lecture puisse accéder à cette information.
  • Le second jeu a une seule tâche qui exécute la commande join sur tous les nœuds de travail. À l’issue de cette tâche, les deux nœuds de travail feront partie du cluster.

Enregistrez et fermez le fichier lorsque vous avez terminé.

Exécutez le playbook localement en exécutant :

ansible-playbook -i hosts ~/kube-cluster/workers.yml

À la fin, vous verrez une sortie semblable à celle-ci :

Output
PLAY [master] ****

TASK [get join command] ****
changed: [master]

TASK [set join command] *****
ok: [master]

PLAY [workers] *****

TASK [Gathering Facts] *****
ok: [worker1]
ok: [worker2]

TASK [join cluster] *****
changed: [worker1]
changed: [worker2]

PLAY RECAP *****
master                     : ok=2    changed=1    unreachable=0    failed=0   
worker1                    : ok=2    changed=1    unreachable=0    failed=0  
worker2                    : ok=2    changed=1    unreachable=0    failed=0  

Avec l’ajout des nœuds de travail, votre cluster est maintenant entièrement configuré et fonctionnel, avec des travailleurs prêts à exécuter des charges de travail. Avant de planifier les applications, vérifions que le cluster fonctionne comme prévu.

Étape 6 – Vérification du cluster

Un cluster peut parfois échouer pendant l’installation lorsqu’un nœud est en panne ou la connectivité réseau entre le maître et le travailleur (worker) ne fonctionne pas correctement. Vérifions le cluster et assurons-nous que les nœuds fonctionnent correctement.

Vous devrez vérifier l’état actuel du cluster à partir du nœud maître pour vous assurer que les nœuds sont prêts. Si vous vous êtes déconnecté du nœud maître, vous pouvez le réinsérer dans SSH avec la commande suivante :

ssh ubuntu@master_ip

Ensuite, exécutez la commande suivante pour obtenir l’état du cluster :

kubectl get nodes

Vous verrez une sortie similaire à celle-ci :

Output
NAME      STATUS    ROLES     AGE       VERSION
master    Ready     master    1d        v1.10.1
worker1   Ready     <none>    1d        v1.10.1 
worker2   Ready     <none>    1d        v1.10.1

 

Si le STATUS de tous vos nœuds a la valeur Ready, cela signifie qu’ils font partie du cluster et qu’ils sont prêts à exécuter des charges de travail.

Si, toutefois, quelques nœuds ont NotReady comme STATUS, cela peut signifier que les nœuds de travail n’ont pas encore terminé leur configuration. Attendez environ cinq à dix minutes avant de redémarrer kubectl et d’inspecter la nouvelle sortie. Si quelques nœuds ont toujours le statut NotReady, vous devrez peut-être vérifier et relancer les commandes dans les étapes précédentes.

Maintenant que votre cluster est vérifié, planifions un exemple d’application Nginx sur le cluster.

Étape 7 – Exécution d’une application sur le cluster

Vous pouvez maintenant déployer n’importe quelle application conteneurisée sur votre cluster. Pour se familiariser avec tout cela, déployons Nginx en utilisant Déploiements et Services pour voir comment cette application peut être déployée sur le cluster. Vous pouvez également utiliser les commandes ci-dessous pour d’autres applications conteneurisées, à condition de modifier le nom de l’image Docker et les indicateurs pertinents (tels que les ports et les volumes).

Toujours dans le nœud maître, exécutez la commande suivante pour créer un déploiement nommé nginx :

kubectl run nginx --image=nginx --port 80

Un déploiement est un type d’objet Kubernetes qui garantit qu’un nombre spécifié de pods est toujours exécuté en fonction d’un modèle défini, même si le pod se bloque pendant la durée de vie du cluster. Le déploiement ci-dessus créera un pod avec un conteneur à partir de l’image Nginx Docker du registre Docker.

Ensuite, exécutez la commande suivante pour créer un service nommé nginx qui exposera l’application publiquement. Cela se fera via un NodePort, un schéma qui rendra le pod accessible via un port arbitraire ouvert sur chaque nœud du cluster :

kubectl expose deploy nginx --port 80 --target-port 80 --type NodePort

Les services sont un autre type d’objet Kubernetes qui expose les services internes du cluster aux clients, internes et externes. Ils sont également capables de gérer des demandes d’équilibrage de charge vers plusieurs modules, et font partie intégrante de Kubernetes, interagissant fréquemment avec d’autres composants.

Exécutez la commande suivante :

kubectl get services

Cela fera sortir un texte comme suit :

Output
NAME         TYPE        CLUSTER-IP       EXTERNAL-IP           PORT(S)        AGE
kubernetes   ClusterIP   10.96.0.1        <none>                443/TCP        1d
nginx        NodePort    10.109.228.209   <none>                80:nginx_port/TCP   40m

À partir de la troisième ligne de la sortie ci-dessus, vous pouvez récupérer le port sur lequel s’exécute Nginx. Kubernetes affectera automatiquement un port aléatoire supérieur à 30000, tout en s’assurant que le port n’est pas déjà lié par un autre service.

Pour tester que tout fonctionne, visitez http://worker_1_ip:nginx_port ou http://worker_2_ip:nginx_port via un navigateur sur votre ordinateur local. Vous verrez la page d’accueil familière de Nginx.

Si vous souhaitez supprimer l’application Nginx, supprimez d’abord le service nginx du nœud maître :

kubectl delete service nginx

Exécutez les opérations suivantes pour vous assurer que le service a été supprimé :

kubectl get services

Vous verrez la sortie suivante :

Output
NAME         TYPE        CLUSTER-IP       EXTERNAL-IP           PORT(S)        AGE
kubernetes   ClusterIP   10.96.0.1        <none>                443/TCP        1d

Puis, supprimez le déploiement :

kubectl delete deployment nginx

Exécutez les opérations suivantes pour confirmer que cela a fonctionné :

kubectl get deployments


Output
No resources found.

Conclusion

Dans ce guide, vous avez réussi à configurer un cluster Kubernetes sur Ubuntu 16.04 en utilisant Kubeadm et Ansible pour l’automatisation.

Si vous vous demandez ce qu’il faut faire avec le cluster maintenant qu’il est configuré, une bonne étape consistera à vous familiariser avec le déploiement de vos propres applications et services sur le cluster. Voici une liste de liens avec des informations supplémentaires qui peuvent vous guider dans le processus :

  • Dockerizer des applications – listes des exemples qui détaillent comment conteneuriser des applications en utilisant Docker.
  • Présentation de Pod – décrit en détail le fonctionnement des Pods et leur relation avec les autres objets Kubernetes. Les pods sont omniprésents dans Kubernetes, donc les comprendre facilitera votre travail.
  • Présentation des déploiements : celle-ci fournit une présentation des déploiements. Il est utile de comprendre comment les contrôleurs tels que les déploiements fonctionnent, car ils sont fréquemment utilisés dans les applications sans état pour mettre à l’échelle et résoudre de façon automatique les applications malsaines.
  • Présentation des services – ceci couvre les services, un autre objet fréquemment utilisé dans les clusters Kubernetes. Comprendre les types de services et les options dont ils disposent est essentiel pour exécuter des applications sans état et avec état.

D’autres concepts importants que vous pouvez voir sont Volumes, Ingresses et Secrets, qui sont tous utiles lors du déploiement d’applications de production.

Kubernetes a beaucoup de fonctionnalités à offrir. La documentation officielle de Kubernetes est le meilleur endroit pour en apprendre davantage sur les concepts, trouver des guides spécifiques aux tâches et rechercher des références d’API pour divers objets.

À lire aussi

Les compétences en machine learning que les ingénieurs logiciels doivent avoir

Vous n’avez pas besoin d’être un scientifique des données pour faire de machine learning (apprentissage …