ANSIBLE KUBERNETES Source d'inventaire
Dans cet article, nous apprenons à utiliser le plugin Kubernetes dans l'outil ANSIBLE. Dans ANSIBLE, il est difficile de gérer un grand nombre de conteneurs. Mais l'utilisation de Kubernetes dans ANSIBLE est utile lors de la gestion des conteneurs. Dans ce guide, nous apprendrons quelle est la source d'inventaire de Kubernetes et comment elle fonctionne dans ANSIBLE.
Google a lancé le logiciel de gestion facilement accessible appelé Kubernetes qui est également connu sous le nom de K8S qui est utilisé pour gérer les configurations virtualisées via un ensemble distant de machines avec des fonctionnalités d'installation à zéro Architecture dans ANIBLE. Grâce à la disponibilité des API REST pour les fonctionnalités nécessaires, l'objectif principal de Kubernetes est de cacher les complexités associées au contrôle d'un certain nombre de conteneurs.
La configuration de Kubernetes est basée sur le client-serveur. Cependant, par défaut, il n'y a qu'un seul serveur principal qui sert d'hôte contrôlant. Dans Kubernetes, nous pouvons également utiliser des contrôleurs multi-hauts pour la configuration de Kubernetes. La source d'inventaire K8S est parfois nécessaire pour les systèmes de contrôle et configurez les services de l'hôte distant pour contrôler les pods. Mais il y a des difficultés à obtenir des instructions spécifiques sur la façon de le faire. En conséquence, nous mettons en œuvre ce tutoriel sur la façon de créer un livre de jeu anible qui extrait les gousses dans un domaine et produit une source d'inventaire de Kubernetes.
Prérequis de l'utilisation de la source d'inventaire de Kubernetes dans ANSIBLE
Pour utiliser la source d'inventaire de Kubernetes dans ANSIBLE, il existe des instructions de processus ou des commandes tout au long de ce guide. Assurez-vous que vous avez la préparation nécessaire si vous souhaitez avancer:
- Pour travailler dans un scénario anible, nous avons d'abord configuré l'outil ANSIBLE sur le serveur et nous assurons que vous avez la version 2 ANSIBLE.11.7 afin que nous puissions facilement utiliser le plugin Kubernetes.
- Pour évaluer le plugin Kubernetes, nous avons besoin d'un périphérique de serveur distant avec un cluster Kubernetes intégré.
- L'hôte distant est actuellement configuré pour exécuter les instructions et playbooks ANSible, ainsi qu'un fichier d'inventaire construit. Le nom de l'appareil distant cible est le nœud maître K8S.
- La version de Python est 3.6 ou au-dessus qui doit être installé sur l'appareil du contrôleur ANSIBLE. Il peut également être dans le périphérique hôte à distance cible.
- La version du module OpenShift de Python est 0.6 ou plus. Nous avons également besoin d'un module pyyaml de la version 3.11 ou plus. Les deux modules doivent être configurés dans le périphérique de serveur distant ainsi que dans le périphérique de contrôleur.
Exemple:
Voici le tout premier exemple où nous implémentons les Kubernetes dans ANSIBLE. Pour ce faire, nous utilisons n'importe quel environnement ansible pour implémenter la source d'inventaire de Kubernetes. Les processus énumérés suivants sont effectués dans le scénario suivant à l'aide du plugin d'inventaire Kubernetes:
- Implémentation du nouvel espace de noms dans le cluster K8S dans ANIBLE.
- Création de nginx pod en utilisant le manuel ANSIBLE.
- Création du déploiement de Nginx dans ANSIBLE.
Pour rendre les concepts et l'exécution simples à comprendre, nous mettons en œuvre l'exemple dans un certain nombre d'étapes.
Étape 1: Implémentez le nouvel espace de noms dans le cluster K8S dans ANSIBLE
Dans la première étape, nous créons le playbook afin que nous puissions écrire le contenu dans le «.Format YML »dans ANSIBLE. Pour créer le playbook, ce qui suit est la commande que nous utilisons:
[root @ maître anible] # nano nginx_pod.YML
Maintenant, le «Pod.YML »Playbook est créé et lancé dans le nouveau terminal d'Anble. Nous commençons à écrire le script. Dans le livre de jeu, nous définissons d'abord la version API que nous utilisons dans le pod anible qui est «V1». L'espace de noms que nous définissons est «ANSIBLE-NAMESPACE». Ensuite, nous énumérons les métadonnées de l'espace ANSIBLE-NAMES. Dans les métadonnées, nous utilisons le logiciel Nginx et l'étiquette qui contient un niveau de frontend de valeur. Dans les spécifications du playbook, nous énumérons le nom et l'image qui est stockée dans le conteneur; Les deux contiennent le nginx dedans.
Étape 2: Créez le document manifeste dans Ansible
Maintenant, nous créons un autre document dans le même répertoire d'Anible qui est le document de déploiement dans le «.format yml ”. Pour créer le document manifeste, utilisez la commande suivante dans le terminal anible:
[root @ maître anible] # nano nginx_deployment.YML
Dans le document manifeste, nous définissons d'abord la version de l'application qui est «App / V1». Ensuite, nous disons de quel type de fichier il s'agit, s'il s'agit d'un fichier de déploiement. Ensuite, nous définissons l'espace de noms qui est ANSIBLE-NAMEPACE. Pour construire la mise en œuvre, deux répliques à l'intérieur de l'Anible-Namespace montrent le numéro du pod. Les images Nginx sont 1.14.2 qui sont lancés dans le pod. Le paramètre MatchLabels fournit les balises pour les pods et leurs spécifications sous le paramètre SPEC. Si en quelque sorte les balises sur les pods correspondent à celles spécifiées dans les informations de configuration, l'implémentation se produit dans le document manifeste dans Anible.
Étape 3: Créez la mise en œuvre du Playbook for Kubernetes dans ANSIBLE
Maintenant, nous voulons créer un autre manuel dans ANSIBLE. Dans ce playbook, nous mettons en œuvre les fonctionnalités de Kubernetes dedans. Utilisez la commande suivante pour créer le playbook:
[root @ maître anible] # nano kubernetes_main.YML
Le playbook est créé dans le même répertoire où le livre de jeu et le document manifeste précédent sont stockés dans ANSIBLE. Dans le playbook, nous définissons d'abord la fonctionnalité du playbook que nous voulons implémenter. Pour établir la connexion, nous fournissons les hôtes distants que nous voulons cibler. Ici, nous ciblons «tous» hôtes. Ensuite, nous définissons la variable pour vérifier l'interprète Python dans ANSIBLE en utilisant le chemin où il est stocké. Maintenant, nous définissons les tâches dans le livre de jeu. Tout d'abord, nous vérifions l'état de l'appareil minikube. Ensuite, nous créons un nouvel espace de noms Kubernetes dans le livre de jeu. Ensuite, dupliquez le nginx_pod.yml et nginx_deployment .YML à l'appareil distant.
Grâce à ces documents YML, nous construisons l'implémentation des pods dans l'appareil distant. Ensuite, nous vérifions si le pod Kubernetes est présent ou non sur l'emplacement spécifié dans l'appareil distant.
Après la terminaison de Playbook, nous construisons maintenant le fichier d'inventaire afin que nous établissions la connexion entre le contrôleur ANSIBLE et l'hôte distant cible.
Tous:
Hôtes:
k8s_master_node:
ANSIBLE_HOST: 192.168.3.229
ANIBLE_USER: ANSIBLE
ANSIBLE_PASSWORD: ********
ANSIBLE_CONNECTION: SSH
ANSIBLE_PORT: 22
[root @ maître anible] # anible-playbook kubernates_main.YML
Voici la sortie souhaitée où nous voyons que les tâches sont placées avec succès sur la machine cible:
Une fois la tâche placée sur la machine cible, nous vérifions si le «ANSIBLE-NAMEPACE» est dans le cluster Kubernetes ou non. Nous utilisons la commande «grep» suivante:
[root @ maître anible] # Kubectl Get Namespace | grep anible-namespace
Si vous souhaitez vérifier le pod créé dans l'espace de noms du cluster Kubernetes, écrivez la commande suivante pour vérifier:
[root @ maître anible] # kubectl get pods --Namespace anible-namespace
Comme vous le voyez dans la sortie précédente, nous obtenons les pods qui s'exécutent sur l'appareil. Maintenant, nous vérifions le déploiement que nous avons effectué dans le cluster Kubernetes. Utilisez l'instruction suivante pour vérifier les déploiements déjà fabriqués:
[root @ maître anible] # kubectl obtenez les déploiements - namespace anible-namespace
Conclusion
Nous avons appris quelle est la source d'inventaire de Kubernetes dans ANIBLE. Nous avons également appris à utiliser l'inventaire de Kubernetes dans ANIBLE. Ensuite, nous avons mis en œuvre un exemple afin que nous apprenons plus clairement sur le fonctionnement de la source d'inventaire de Kubernetes dans Ansible.