I dette innlegget lærer vi hvordan du bruker Kubernetes-pluginen i Ansible-verktøyet. I Ansible er det vanskelig å administrere store antall containere. Men å bruke Kubernetes i Ansible er nyttig når du administrerer beholderne. I denne veiledningen vil vi lære hva som er Kubernetes-lagerkilden og hvordan den fungerer i Ansible.
Google lanserte den lett tilgjengelige administrasjonsprogramvaren kalt Kubernetes, som også er kjent som K8s, som brukes til å administrere de virtualiserte konfigurasjonene over et eksternt sett med maskiner med installasjonsfunksjoner uten nedetid, automatisk tilbakeføring og skalerbarhet som gir Kubernetes-plugin en ekstremt tilpasningsdyktig arkitektur i Ansible. Gjennom tilgjengeligheten av REST APIer for nødvendig funksjonalitet, er Kubernetes sitt primære mål å skjule kompleksiteten som er forbundet med å kontrollere en rekke containere.
Konfigurasjonen av Kubernetes er basert på klient-tjener. Som standard er det imidlertid bare én hovedserver som fungerer som en kontrollerende vert. I Kubernetes kan vi også bruke multi-main kontrollere for konfigurasjonen av Kubernetes. K8s inventarkilde er av og til nødvendig for å kontrollere systemer og konfigurere tjenestene på den eksterne verten for å kontrollere pods. Men det er vanskeligheter med å få spesifikke instruksjoner om hvordan du gjør det. Som et resultat implementerer vi denne opplæringen om hvordan du lager en Ansible Playbook som trekker ut podene i et domene og produserer en Kubernetes-inventarkilde.
Forutsetninger for å bruke Kubernetes inventarkilde i Ansible
For å bruke Kubernetes-inventarkilden i Ansible, er det trinnprosessinstruksjoner eller -kommandoer i denne veiledningen. Sørg for at du har de nødvendige forberedelsene hvis du vil gå videre i det:
- For å jobbe i et Ansible-scenario setter vi først opp Ansible-verktøyet på serveren og sørger for at du har Ansible versjon 2.11.7 slik at vi enkelt kan bruke Kubernetes-pluginen.
- For å vurdere Kubernetes-pluginen trenger vi en ekstern serverenhet med en innebygd Kubernetes-klynge.
- Den eksterne verten er for øyeblikket konfigurert til å utføre Ansible-instruksjonene og spillebøkene, samt en innebygd inventarfil. Navnet på den eksterne enheten er K8s Master Node.
- Versjonen av Python er 3.6 eller nyere som må installeres på enheten til Ansible-kontrolleren. Det kan også være i den eksterne målvertsenheten.
- Versjonen av openshift-modulen til Python er 0.6 eller høyere. Vi trenger også en pyYAML-modul med versjon 3.11 eller nyere. Begge modulene må settes opp i den eksterne serverenheten så vel som kontrollenheten.
Eksempel:
Her er det aller første eksemplet der vi implementerer Kubernetes i Ansible. For å gjøre det bruker vi et hvilket som helst Ansible-miljø for å implementere Kubernetes-lagerkilden. Følgende oppførte prosesser utføres i følgende scenario ved å bruke Kubernetes Inventory Plugin:
- Implementering av det nye navneområdet i K8s-klyngen i Ansible.
- Oppretting av nginx-pod ved å bruke Ansible-spilleboken.
- Oppretting av nginx-distribusjon i Ansible.
For å gjøre konseptene og utførelsen enkle å forstå, implementerer vi eksemplet i en rekke trinn.
Trinn 1: Implementer det nye navneområdet i K8s-klyngen i Ansible
I det første trinnet lager vi spilleboken slik at vi kan skrive innholdet i '.yml'-formatet i Ansible. For å lage spilleboken, er følgende kommandoen vi bruker:
[ rot @ mester ansible ] # nano nginx_pod.yml
Nå er 'pod.yml'-spilleboken opprettet og lansert i den nye terminalen til Ansible. Vi begynner å skrive manuset. I playbook definerer vi først API-versjonen som vi bruker i Ansible pod som er 'v1'. Navneområdet som vi definerer er 'ansible-namespace'. Deretter viser vi metadataene til ansible-navneområdet. I metadataene bruker vi nginx-programvaren og etiketten som inneholder et verdi-grensesnitt i den. I spesifikasjonen til spilleboken viser vi navnet og bildet som er lagret i beholderen; begge inneholder nginx i den.
Trinn 2: Lag manifestdokumentet i Ansible
Nå oppretter vi et annet dokument i den samme katalogen til Ansible som er distribusjonsdokumentet i '.yml'-formatet. For å lage manifestdokumentet, bruk følgende kommando i Ansible-terminalen:
[ rot @ mester ansible ] # nano nginx_deployment.yml
I manifestdokumentet definerer vi først igjen appversjonen som er 'app/v1'. Deretter forteller vi hva slags fil det er, om det er en distribusjonsfil. Deretter definerer vi navneområdet som er ansible-navneområde. For å bygge implementeringen viser to replikaer inne i ansible-namespace nummeret til poden. Nginx-bildene er 1.14.2 som lanseres i poden. MatchLabels-parameteren gir taggene for podene og deres spesifikasjoner under spec-parameteren. Hvis taggene på podene på en eller annen måte samsvarer med de som er spesifisert i konfigurasjonsinformasjonen, skjer implementeringen i manifestdokumentet i Ansible.
Trinn 3: Lag Playbook for Kubernetes-implementering i Ansible
Nå ønsker vi å lage en ny spillebok i Ansible. I denne lekeboken implementerer vi funksjonaliteten til Kubernetes i den. Bruk følgende kommando for å lage spilleboken:
[ rot @ mester ansible ] # nano kubernetes_main.yml
Spilleboken opprettes i samme katalog der forrige spillebok og manifestdokument er lagret i Ansible. I playbook definerer vi først funksjonaliteten til playbook som vi ønsker å implementere. For å bygge tilkoblingen gir vi de eksterne vertene som vi ønsker å målrette mot. Her retter vi oss mot «alle» verter. Deretter definerer vi variabelen for å sjekke Python-tolken i Ansible ved å bruke banen der den er lagret. Nå definerer vi oppgavene i lekeboken. Først sjekker vi statusen til minikube-enheten. Deretter oppretter vi et nytt Kubernetes-navneområde i spilleboken. Dupliser deretter nginx_pod.yml og nginx_deployment .yml til den eksterne enheten.
Gjennom disse yml-dokumentene bygger vi pod-implementeringen i den eksterne enheten. Deretter sjekker vi om Kubernetes-poden er til stede eller ikke på den angitte plasseringen i den eksterne enheten.
Etter playbook-avslutningen bygger vi nå inventarfilen slik at vi oppretter forbindelsen mellom Ansible-kontrolleren og den eksterne målverten.
Alle:verter:
k8s_Master_Node:
ansible_host: 192.168.3.229
ansible_user: ansible
ansible_password: ********
ansible_connection: ssh
ansible_port: 22
[ rot @ mester ansible ] # ansible-playbook kubernates_main.yml
Her er ønsket utgang der vi ser at oppgavene er vellykket plassert på målmaskinen:
Etter at oppgaven er plassert på målmaskinen, sjekker vi om 'ansible-namespace' er i Kubernetes-klyngen eller ikke. Vi bruker følgende 'grep' kommando:
[ rot @ mester ansible ] # kubectl få navneområde | grep ansible-namespace
Hvis du vil sjekke den opprettede poden i navneområdet til Kubernetes-klyngen, skriv følgende kommando for å sjekke:
[ rot @ mester ansible ] # kubectl få pods --namespace ansible-namespace
Som du ser i forrige utgang, får vi podene som kjører på enheten. Nå sjekker vi distribusjonen vi har laget i Kubernetes-klyngen. Bruk følgende setning for å sjekke de allerede utførte distribusjonene:
[ rot @ mester ansible ] # kubectl få distribusjoner --namespace ansible-namespace
Konklusjon
Vi lærte hva som er Kubernetes-beholdningskilden i Ansible. Vi lærte også hvordan vi kan bruke Kubernetes-beholdningen i Ansible. Deretter implementerte vi et eksempel slik at vi vil lære mer tydelig om hvordan Kubernetes lagerkilde fungerer i Ansible.