Ansible Kubernetes Inventory Source

I dette innlegget lærer vi hvordan du bruker Kubernetes -plugin i Ansible -verktøyet. I Ansible er det vanskelig å administrere et stort antall containere. Men å bruke Kubernetes i Ansible er nyttig mens du administrerer containerne. I denne guiden lærer vi hva som er Kubernetes varekild og hvordan den fungerer i Ansible.

Google lanserte den lett tilgjengelige styringsprogramvaren kalt Kubernetes, som også er kjent som K8s, som brukes til å administrere de virtualiserte konfigurasjonene over et eksternt sett med maskiner med null-downtime installasjonsfunksjoner, automatisert reversering og skalerbarhet som gir Kubernetes-plugin en ekstremt tilpasningsdyktig Arkitektur i Ansible. Gjennom tilgjengeligheten av REST APIer for nødvendig funksjonalitet, er Kubernetes 'primære mål å skjule kompleksitetene som er assosiert med å kontrollere en rekke containere.

Konfigurasjonen av Kubernetes er basert på klient-server. Som standard er det imidlertid bare en hovedserver som fungerer som en kontrollerende vert. I Kubernetes kan vi også bruke multi-main-kontrollere for konfigurasjon av Kubernetes. K8S -varekilden er tidvis nødvendig for kontrollsystemer og konfigurerer 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 belgene i et domene og produserer en Kubernetes varekilde.

Forutsetninger for bruk av Kubernetes Inventory Source i Ansible

For å bruke Kubernetes Inventory Source i Ansible, er det sceneprosessinstruksjoner eller kommandoer gjennom denne guiden. Forsikre deg om at du har nødvendig forberedelse hvis du vil komme videre i den:

• For å jobbe i et Ansible -scenario, satte 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 -plugin.
• For å vurdere Kubernetes -plugin, trenger vi en ekstern serverenhet med en Kubernetes -klynge innebygd.
• Den eksterne verten er for øyeblikket konfigurert for å utføre Ansible -instruksjonene og spillbøkene, samt en bygget inventarfil. Navnet på Target Remote -enheten er K8S Master Node.
• Versjonen av Python er 3.6 eller over som må installeres på enheten til Ansible -kontrolleren. Det kan også være i målet om ekstern vert.
• Versjonen av OpenShift -modulen til Python er 0.6 eller over. Vi trenger også en Pyyaml ​​-modul av versjon 3.11 eller over. Begge modulene må settes opp i den eksterne serverenheten så vel som kontrollerenheten.

Eksempel:

Her er det aller første eksemplet der vi implementerer Kubernetes i Ansible. For å gjøre det, bruker vi ethvert som var til å implementere Kubernetes Inventory Source. Følgende listede prosesser utføres i følgende scenario ved hjelp av Kubernetes Inventory Plugin:

• Implementering av det nye navneområdet i K8S -klyngen i Ansible.
• Opprettelse av Nginx Pod ved hjelp av Ansible Playbook.
• Opprettelse av Nginx -distribusjon i Ansible.

For å gjøre konseptene og utførelsen enkelt å forstå, implementerer vi eksemplet i en rekke trinn.

Trinn 1: Implementere det nye navneområdet i K8S -klyngen i Ansible

I det første trinnet lager vi spillboken slik at vi kan skrive innholdet i ".YML ”-format i Ansible. For å opprette spillboken, er følgende kommandoen som vi bruker:

[root@master ansible]# nano nginx_pod.yml

Nå, “Pod.YML ”Playbook er opprettet og lansert i den nye terminalen til Ansible. Vi begynner å skrive manuset. I spillboken definerer vi først API -versjonen som vi bruker i Ansible Pod som er "V1". Navnområdet som vi definerer er “Ansible-Namespace”. Deretter viser vi metadataene til Ansible-Namespace. I metadataene bruker vi Nginx -programvaren og etiketten som inneholder en nivå av verdifrontend i den. I spesifikasjonen av spillboken viser vi navnet og bildet som er lagret i beholderen; Begge inneholder nginx i den.

Trinn 2: Opprett manifestdokumentet i Ansible

Nå oppretter vi et annet dokument i samme katalog over Ansible som er distribusjonsdokumentet i ".YML ”-format. For å opprette manifestdokumentet, bruk følgende kommando i Ansible -terminalen:

[root@master ansible]# nano nginx_deployment.yml

I Manifest -dokumentet definerer vi først app -versjonen som er "APP/V1". Deretter forteller vi hva slags fil det er, enten det er en distribusjonsfil. Deretter definerer vi navneområdet som er Ansible-Namespace. For å bygge implementeringen viser to kopier inne i Ansible-Namespace antallet POD. Nginx -bildene er 1.14.2 som lanseres i pod. Matchlabels -parameteren gir taggene for belgene og deres spesifikasjoner under spesifikasjonsparameteren. 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 spillboken for implementering av Kubernetes i Ansible

Nå ønsker vi å lage en annen spillbok i Ansible. I denne lekeboken implementerer vi funksjonaliteten til Kubernetes i den. Bruk følgende kommando for å opprette spillboken:

[root@master ansible]# nano kubernetes_main.yml

Playbooken er opprettet i samme katalog der det forrige playbook- og manifestdokumentet er lagret i Ansible. I spillboken definerer vi først funksjonaliteten til spillboken som vi ønsker å implementere. For å bygge forbindelsen, gir vi de eksterne vertene som vi ønsker å målrette. Her er vi målrettet 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 lager vi et nytt Kubernetes navneområde i spillboken. 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 Pod er til stede eller ikke på det spesifiserte stedet i den eksterne enheten.

Etter Playbook -avslutningen bygger vi nå varelagerfilen slik at vi gjør forbindelsen mellom Ansible Controller og Target Remote Host.

Alle:
verter:
k8s_master_node:
Ansible_host: 192.168.3.229
Ansible_user: Ansible
Ansible_Password: ********
Ansible_Connection: SSH
Ansible_port: 22

[root@master ansible]# ansible-playbook kubernates_main.yml

Her er ønsket utgang der vi ser at oppgavene er 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:

[root@master ansible]# kubectl få navneområde | Grep Ansible-Namespace

Hvis du vil sjekke den opprettede poden i navneområdet til Kubernetes -klyngen, skriver du følgende kommando for å sjekke:

[root@master ansible]# kubectl get pods-namespace ansible-namespace

Som du ser i forrige utgang, får vi belgene som kjører på enheten. Nå sjekker vi distribusjonen som vi laget i Kubernetes -klyngen. Bruk følgende uttalelse for å sjekke de allerede laget distribusjonene:

[root@master ansible]# kubectl få distribusjoner-namespace ansible-namespace

Konklusjon

Vi lærte hva som er Kubernetes -varekilden i Ansible. Vi lærte også hvordan vi bruker Kubernetes -varelageret i Ansible. Deretter implementerte vi et eksempel slik at vi skal lære tydeligere om arbeidet med Kubernetes Inventory Source i Ansible.