In questo post, impariamo come utilizzare il plug-in Kubernetes nello strumento Ansible. In Ansible è difficile gestire un gran numero di container. Ma l'utilizzo di Kubernetes in Ansible è utile durante la gestione dei container. In questa guida impareremo cos'è l'origine dell'inventario Kubernetes e come funziona in Ansible.
Google ha lanciato il software di gestione facilmente accessibile chiamato Kubernetes, noto anche come K8s, che viene utilizzato per gestire le configurazioni virtualizzate su un set remoto di macchine con funzionalità di installazione senza tempi di inattività, ripristino automatico e scalabilità che fornisce al plug-in Kubernetes un'interfaccia estremamente adattabile architettura in Ansible. Attraverso la disponibilità delle API REST per le funzionalità necessarie, l'obiettivo principale di Kubernetes è nascondere le complessità associate al controllo di un numero di container.
La configurazione di Kubernetes si basa su client-server. Tuttavia, per impostazione predefinita, esiste un solo server principale che funge da host di controllo. In Kubernetes, possiamo anche utilizzare controller multi-main per la configurazione di Kubernetes. L'origine dell'inventario K8s è occasionalmente necessaria per controllare i sistemi e configurare i servizi sull'host remoto per controllare i pod. Ma ci sono difficoltà nell'ottenere istruzioni specifiche su come farlo. Di conseguenza, implementiamo questo tutorial su come creare un Ansible Playbook che estrae i pod in un dominio e produce una sorgente di inventario Kubernetes.
Prerequisiti per l'utilizzo dell'origine dell'inventario Kubernetes in Ansible
Per utilizzare l'origine dell'inventario Kubernetes in Ansible, in questa guida sono presenti istruzioni o comandi del processo di fase. Assicurati di avere la preparazione necessaria se vuoi andare avanti:
- Per lavorare in uno scenario Ansible, per prima cosa configuriamo lo strumento Ansible sul server e ci assicuriamo di disporre della versione 2.11.7 di Ansible in modo da poter utilizzare facilmente il plug-in Kubernetes.
- Per valutare il plug-in Kubernetes, abbiamo bisogno di un dispositivo server remoto con un cluster Kubernetes integrato.
- L'host remoto è attualmente configurato per eseguire le istruzioni e i playbook di Ansible, oltre a un file di inventario creato. Il nome del dispositivo remoto di destinazione è K8s Master Node.
- La versione di Python è 3.6 o successiva che deve essere installata sul dispositivo del controller Ansible. Può anche trovarsi nel dispositivo host remoto di destinazione.
- La versione del modulo openshift di Python è 0.6 o successiva. Abbiamo anche bisogno di un modulo pyYAML della versione 3.11 o superiore. Entrambi i moduli devono essere configurati nel dispositivo server remoto e nel dispositivo controller.
Esempio:
Ecco il primissimo esempio in cui implementiamo Kubernetes in Ansible. Per fare ciò, utilizziamo qualsiasi ambiente Ansible per implementare l'origine dell'inventario Kubernetes. I seguenti processi elencati vengono eseguiti nel seguente scenario utilizzando il plug-in Kubernetes Inventory:
- Implementazione del nuovo spazio dei nomi nel cluster K8s in Ansible.
- Creazione del pod nginx utilizzando il playbook Ansible.
- Creazione del deployment nginx in Ansible.
Per semplificare la comprensione dei concetti e dell'esecuzione, implementiamo l'esempio in una serie di passaggi.
Passaggio 1: implementa il nuovo spazio dei nomi nel cluster K8s in Ansible
Nella prima fase, creiamo il playbook in modo da poter scrivere il contenuto nel formato '.yml' in Ansible. Per creare il playbook, il seguente è il comando che usiamo:
[ radice @ maestro ansible ] # nano nginx_pod.yml
Ora, il playbook 'pod.yml' viene creato e lanciato nel nuovo terminale di Ansible. Iniziamo a scrivere la sceneggiatura. Nel playbook, per prima cosa definiamo la versione dell'API che utilizziamo nel pod Ansible che è 'v1'. Lo spazio dei nomi che definiamo è 'ansible-namespace'. Quindi, elenchiamo i metadati dello spazio dei nomi ansible. Nei metadati utilizziamo il software nginx e l'etichetta che contiene un frontend di livello di valore. Nelle specifiche del playbook, elenchiamo il nome e l'immagine memorizzata nel contenitore; entrambi contengono il nginx in esso.
Passaggio 2: creare il documento manifest in Ansible
Ora creiamo un altro documento nella stessa directory di Ansible che è il documento di distribuzione nel formato '.yml'. Per creare il documento manifest, utilizzare il seguente comando nel terminale Ansible:
[ radice @ maestro ansible ] # nano nginx_deployment.yml
Nel documento manifest, per prima cosa definiamo nuovamente la versione dell'app che è 'app/v1'. Quindi, diciamo che tipo di file è, se si tratta di un file di distribuzione. Quindi, definiamo lo spazio dei nomi che è ansible-namespace. Per creare l'implementazione, due repliche all'interno dello spazio dei nomi ansible mostrano il numero del pod. Le immagini nginx sono 1.14.2 che vengono lanciate nel pod. Il parametro matchLabels fornisce i tag per i pod e le relative specifiche nel parametro spec. Se in qualche modo i tag sui pod corrispondono a quelli specificati nelle informazioni di configurazione, l'implementazione avviene nel documento manifest in Ansible.
Passaggio 3: creare il playbook per l'implementazione di Kubernetes in Ansible
Ora vogliamo creare un altro playbook in Ansible. In questo playbook, implementiamo la funzionalità di Kubernetes al suo interno. Utilizzare il seguente comando per creare il playbook:
[ radice @ maestro ansible ] # nano kubernetes_main.yml
Il playbook viene creato nella stessa directory in cui sono archiviati in Ansible il playbook e il documento manifest precedenti. Nel playbook, per prima cosa definiamo la funzionalità del playbook che vogliamo implementare. Per creare la connessione, forniamo gli host remoti che vogliamo scegliere come target. Qui, miriamo a 'tutti' gli host. Successivamente, definiamo la variabile per controllare l'interprete Python in Ansible utilizzando il percorso in cui è memorizzato. Ora, definiamo le attività nel playbook. Innanzitutto, controlliamo lo stato del dispositivo minikube. Successivamente, creiamo un nuovo spazio dei nomi Kubernetes nel playbook. Quindi, duplica nginx_pod.yml e nginx_deployment .yml sul dispositivo remoto.
Attraverso questi documenti yml, creiamo l'implementazione del pod nel dispositivo remoto. Quindi, controlliamo se il pod Kubernetes è presente o meno nella posizione specificata nel dispositivo remoto.
Dopo la chiusura del playbook, ora creiamo il file di inventario in modo da stabilire la connessione tra il controller Ansible e l'host remoto di destinazione.
Tutto:host:
k8s_Master_Node:
ansible_host: 192.168.3.229
ansible_user: ansible
password_ansible: ********
connessione_ansible: ssh
ansible_port: 22
[ radice @ maestro ansible ] # ansible-playbook kubernates_main.yml
Ecco l'output desiderato in cui vediamo che le attività sono state posizionate correttamente sulla macchina di destinazione:
Dopo che l'attività è stata posizionata sulla macchina di destinazione, controlliamo se 'ansible-namespace' si trova o meno nel cluster Kubernetes. Usiamo il seguente comando 'grep':
[ radice @ maestro ansible ] # kubectl ottiene lo spazio dei nomi | grep spazio dei nomi ansible
Se vuoi controllare il pod creato nello spazio dei nomi del cluster Kubernetes, scrivi il seguente comando per controllare:
[ radice @ maestro ansible ] # kubectl get pods --namespace ansible-namespace
Come puoi vedere nell'output precedente, otteniamo i pod in esecuzione sul dispositivo. Ora controlliamo la distribuzione che abbiamo effettuato nel cluster Kubernetes. Utilizzare la seguente dichiarazione per verificare le distribuzioni già effettuate:
[ radice @ maestro ansible ] # kubectl get deployments --namespace ansible-namespace
Conclusione
Abbiamo scoperto qual è l'origine dell'inventario Kubernetes in Ansible. Abbiamo anche imparato a utilizzare l'inventario Kubernetes in Ansible. Quindi, abbiamo implementato un esempio in modo da apprendere più chiaramente il funzionamento dell'origine dell'inventario Kubernetes in Ansible.