I dette indlæg lærer vi, hvordan du bruger Kubernetes-plugin'et i Ansible-værktøjet. I Ansible er det svært at håndtere et stort antal containere. Men at bruge Kubernetes i Ansible er nyttigt, når du administrerer containerne. I denne vejledning lærer vi, hvad Kubernetes-beholdningskilden er, og hvordan den fungerer i Ansible.
Google lancerede den lettilgængelige administrationssoftware kaldet Kubernetes, som også er kendt som K8s, som bruges til at administrere de virtualiserede konfigurationer over et eksternt sæt af maskiner med installationsfunktioner uden nedetid, automatisk tilbagevenden og skalerbarhed, som giver Kubernetes-plugin'et en ekstremt tilpasningsdygtig arkitektur i Ansible. Gennem tilgængeligheden af REST API'er til den nødvendige funktionalitet er Kubernetes' primære mål at skjule de kompleksiteter, der er forbundet med at kontrollere en række containere.
Konfigurationen af Kubernetes er baseret på klient-server. Som standard er der dog kun én hovedserver, der fungerer som en kontrollerende vært. I Kubernetes kan vi også bruge multi-main controllere til konfigurationen af Kubernetes. K8s lagerkilde er lejlighedsvis nødvendig for at styre systemer og konfigurere tjenesterne på den eksterne vært til at styre pods. Men der er vanskeligheder med at få specifikke instruktioner om, hvordan man gør det. Som et resultat implementerer vi denne vejledning om, hvordan man laver en Ansible Playbook, der uddrager pods i et domæne og producerer en Kubernetes-opgørelseskilde.
Forudsætninger for brug af Kubernetes Inventory Source i Ansible
For at bruge Kubernetes-beholdningskilden i Ansible er der stadieprocesinstruktioner eller -kommandoer i hele denne vejledning. Sørg for, at du har den nødvendige forberedelse, hvis du vil komme videre i det:
- For at arbejde i et Ansible-scenarie sætter vi først Ansible-værktøjet op på serveren og sørger for, at du har Ansible version 2.11.7, så vi nemt kan bruge Kubernetes-pluginnet.
- For at vurdere Kubernetes-pluginnet har vi brug for en ekstern serverenhed med en Kubernetes-klynge indbygget.
- Fjernværten er i øjeblikket konfigureret til at udføre Ansible-instruktionerne og spillebøgerne samt en indbygget inventarfil. Navnet på målfjernenheden er K8s Master Node.
- Versionen af Python er 3.6 eller nyere, som skal installeres på enheden af Ansible-controlleren. Det kan også være i mål-fjernværtenheden.
- Udgaven af openshift-modulet i Python er 0.6 eller nyere. Vi har også brug for et pyYAML-modul med version 3.11 eller nyere. Begge moduler skal sættes op i fjernserverenheden såvel som i controllerenheden.
Eksempel:
Her er det allerførste eksempel, hvor vi implementerer Kubernetes i Ansible. For at gøre det bruger vi ethvert Ansible-miljø til at implementere Kubernetes-beholdningskilden. Følgende listede processer udføres i følgende scenarie ved hjælp af Kubernetes Inventory Plugin:
- Implementering af det nye navneområde i K8s-klyngen i Ansible.
- Oprettelse af nginx pod ved hjælp af Ansible playbook.
- Oprettelse af nginx-implementering i Ansible.
For at gøre koncepterne og udførelsen nemme at forstå, implementerer vi eksemplet i en række trin.
Trin 1: Implementer det nye navneområde i K8s-klyngen i Ansible
I det første trin opretter vi spillebogen, så vi kan skrive indholdet i '.yml'-formatet i Ansible. For at oprette afspilningsbogen er følgende kommando, som vi bruger:
[ rod @ mester ansible ] # nano nginx_pod.yml
Nu er 'pod.yml'-spillebogen oprettet og lanceret i den nye terminal af Ansible. Vi begynder at skrive manuskriptet. I afspilningsbogen definerer vi først API-versionen, som vi bruger i Ansible pod, som er 'v1'. Det navneområde, som vi definerer, er 'ansible-namespace'. Derefter viser vi metadataene for ansible-navnerummet. I metadataene bruger vi nginx-softwaren og etiketten, som indeholder en værdi-grænseflade i den. I afspilningsbogens spec viser vi navnet og billedet, der er gemt i beholderen; begge indeholder nginx i det.
Trin 2: Opret manifestdokumentet i Ansible
Nu opretter vi et andet dokument i den samme mappe af Ansible, som er implementeringsdokumentet i '.yml'-formatet. For at oprette manifestdokumentet skal du bruge følgende kommando i Ansible-terminalen:
[ rod @ mester ansible ] # nano nginx_deployment.yml
I manifestdokumentet definerer vi først igen appversionen, som er 'app/v1'. Derefter fortæller vi, hvilken slags fil det er, om det er en implementeringsfil. Derefter definerer vi navnerummet, som er ansible-namespace. For at bygge implementeringen viser to replikaer inde i ansible-namespace nummeret på poden. Nginx-billederne er 1.14.2, som er lanceret i poden. MatchLabels-parameteren leverer tags for pods og deres specifikationer under spec-parameteren. Hvis tags på pods på en eller anden måde matcher dem, der er angivet i konfigurationsoplysningerne, sker implementeringen i manifestdokumentet i Ansible.
Trin 3: Opret Playbook til Kubernetes-implementering i Ansible
Nu vil vi oprette endnu en spillebog i Ansible. I denne afspilningsbog implementerer vi funktionaliteten af Kubernetes i den. Brug følgende kommando til at oprette afspilningsbogen:
[ rod @ mester ansible ] # nano kubernetes_main.yml
Afspilningsbogen oprettes i samme mappe, hvor den tidligere spillebog og manifestdokument er gemt i Ansible. I playbook definerer vi først funktionaliteten af den playbook, som vi ønsker at implementere. For at opbygge forbindelsen leverer vi de fjernværter, som vi ønsker at målrette mod. Her målretter vi 'alle' værter. Dernæst definerer vi variablen for at kontrollere Python-fortolkeren i Ansible ved hjælp af stien, hvor den er gemt. Nu definerer vi opgaverne i spillebogen. Først tjekker vi status for minikube-enheden. Dernæst opretter vi et nyt Kubernetes-navneområde i afspilningsbogen. Dupliker derefter nginx_pod.yml og nginx_deployment .yml til fjernenheden.
Gennem disse yml-dokumenter bygger vi pod-implementeringen i fjernenheden. Derefter kontrollerer vi, om Kubernetes-poden er til stede eller ej på den angivne placering i fjernenheden.
Efter playbook-afslutningen bygger vi nu inventarfilen, så vi laver forbindelsen mellem Ansible-controlleren og mål-fjernværten.
Alle:værter:
k8s_Master_Node:
ansible_host: 192.168.3.229
ansible_user: ansible
ansible_password: ********
ansible_connection: ssh
ansible_port: 22
[ rod @ mester ansible ] # ansible-playbook kubernates_main.yml
Her er det ønskede output, hvor vi ser, at opgaverne er placeret med succes på målmaskinen:
Efter opgaven er placeret på målmaskinen, kontrollerer vi, om 'ansible-namespace' er i Kubernetes-klyngen eller ej. Vi bruger følgende 'grep' kommando:
[ rod @ mester ansible ] # kubectl få navneområde | grep ansible-namespace
Hvis du vil kontrollere den oprettede pod i navnerummet i Kubernetes-klyngen, skal du skrive følgende kommando for at kontrollere:
[ rod @ mester ansible ] # kubectl få pods --namespace ansible-namespace
Som du kan se i det forrige output, får vi de pods, der kører på enheden. Nu tjekker vi den udrulning, vi lavede i Kubernetes-klyngen. Brug følgende erklæring til at kontrollere de allerede udførte implementeringer:
[ rod @ mester ansible ] # kubectl få implementeringer --namespace ansible-namespace
Konklusion
Vi lærte, hvad der er Kubernetes-opgørelseskilden i Ansible. Vi lærte også, hvordan man bruger Kubernetes-beholdningen i Ansible. Derefter implementerede vi et eksempel, så vi vil lære mere klart om, hvordan Kubernetes lagerkilde fungerer i Ansible.