Guida per configurare un cluster Kubernetes K8s con Ansible

Introduzione

Kubernetes è diventata la soluzione di riferimento per l'orchestrazione dei container, consentendo agli sviluppatori di distribuire, gestire e scalare facilmente le applicazioni containerizzate. Tuttavia, la configurazione di un cluster Kubernetes può essere un processo complesso, che prevede numerosi passaggi e configurazioni. È qui che entra in gioco Ansible, uno strumento di automazione open source. Automatizzando il processo di distribuzione, Ansible può semplificare notevolmente la creazione di un cluster Kubernetes.

In questa guida ti guideremo attraverso il processo di creazione di un cluster Kubernetes utilizzando Ansible. Si presuppone che tutti i nodi nel cluster K8 siano in esecuzione con il sistema operativo Ubuntu Linux.

Prerequisiti

Prima di immergerci nel processo di configurazione, assicurati di disporre dei seguenti prerequisiti:

Ansible: è necessario che Ansible sia installato sulla macchina di controllo. La macchina di controllo è il luogo in cui eseguirai gli script Ansible e può essere la tua macchina locale o un server.
Nodi di destinazione: queste sono le macchine in cui verrà installato Kubernetes. Avrai bisogno di almeno due nodi: uno per il nodo master e uno per un nodo di lavoro. Assicurati che questi nodi eseguano una distribuzione Linux compatibile.
Accesso SSH: Ansible comunica con i nodi di destinazione tramite SSH. È necessario che l'accesso SSH sia configurato per tutti i nodi di destinazione dalla macchina di controllo.

Passaggio 1: installazione di Ansible

Per iniziare, configura Ansible sulla tua macchina di controllo. Il processo prevede l'installazione di Ansible, che varia a seconda del sistema operativo. Utilizza i seguenti comandi in base alla tua distribuzione:

sudo apt-get update

sudo apt-get install ansible

Passaggio 2: imposta il file di inventario

Dopo aver installato Ansible, procedi con la configurazione del file di inventario. Crea un file denominato host.ini nella tua directory di lavoro, che enumererà tutti i nodi di destinazione insieme ai rispettivi indirizzi IP. Per migliorare la chiarezza, organizzarli in gruppi come maestri e lavoratori. Ecco un esempio:

[masters]
master ansible_host=192.168.1.100

[workers]
worker1 ansible_host=192.168.1.101
worker2 ansible_host=192.168.1.102

Passaggio 3: configurazione del Cluster Playbook K8s

Questo playbook ti aiuterà a configurare un cluster Kubernetes utilizzando i sistemi Ubuntu. Include attività per disabilitare il firewall, disattivare lo scambio, configurare le impostazioni di rete, aggiungere il repository Docker, installare Docker e i suoi componenti, regolare le impostazioni di runtime del contenitore, aggiungere il repository Kubernetes e installare i componenti Kubernetes (kubelet, kubeadm, kubectl). In particolare, kubectl è installato solo sui nodi identificati come master. Il playbook dimostra un approccio completo alla preparazione dei sistemi per Kubernetes, concentrandosi sui servizi richiesti, sulle configurazioni di sicurezza e sui componenti essenziali di Kubernetes.

Crea un file setup-playbook.yaml e aggiungi il contenuto seguente:

- name: Initialize master and worker nodes
  hosts: all
  tasks:

   - name: disable UFW firewall for labs
     service:
        name: ufw
        state: stopped
        enabled: false

   - name: Disable SWAP
     shell: |
       swapoff -a

   - name: Disable SWAP in fstab
     lineinfile:
       path: /etc/fstab
       regexp: '^.*swap.*$'
       line: '#\0'
       backrefs: yes

   - name: ensure net.bridge.bridge-nf-call-ip6tables is set to 1
     sysctl:
       name: net.bridge.bridge-nf-call-iptables
       value: '1'
       state: present
       reload: yes

   - name: Installation of apt-utils
     apt:
      name: apt-transport-https
      state: present
      update_cache: yes

   - name: Adding Docker GPG key
     ansible.builtin.apt_key:
       url: https://download.docker.com/linux/ubuntu/gpg
       state: present

   - name: Adding Docker Repository
     apt_repository:
       repo: deb [arch=amd64] https://download.docker.com/linux/ubuntu {{ ansible_distribution_release }} stable
       state: present

   - name: Installation of Docker
     apt:
      name: "{{ item }}"
      state: present
     loop:
       - docker-ce
       - docker-ce-cli
       - containerd.io
       - docker-compose

   - name: Setting value of SystemdCgroup
     shell: |
       containerd config default | sudo tee /etc/containerd/config.toml | grep SystemdCgroup
       sed -i 's/SystemdCgroup = false/SystemdCgroup = true/g' /etc/containerd/config.toml

   - name : Starting Service of Docker
     service:
       name: docker
       state: started
       enabled: yes

   - name: Add Kubernetes apt repository
     apt_repository:
       repo: deb https://apt.kubernetes.io/ kubernetes-xenial main
       state: present

   - name: Install kubelet and kubeadm
     apt:
        name: "{{ item }}"
        state: present
     loop:
       - kubeadm
       - kubelet

   - name: start kubelet
     service:
       name: kubelet
       enabled: yes
       state: started

   - name: install kubectl
     apt:
        name: kubectl
        state: present
     when: "'masters' in group_names"

Esegui il playbook eseguendo:

ansible-playbook -i hosts.ini setup-playbook.yml

Passaggio 4: configurazione del nodo principale

Questo playbook Ansible è progettato per configurare il nodo master di un cluster Kubernetes. Inizializza il cluster Kubernetes con configurazioni di rete specifiche, crea una directory .kube e copia il file di configurazione kube nella directory home dell'utente per la gestione del cluster. Installa inoltre il plug-in di rete Calico per gestire la rete dei pod, garantendo che i pod possano comunicare tra loro attraverso i nodi. Il playbook automatizza il processo di configurazione iniziale, semplificando la distribuzione di un cluster Kubernetes.

Crea un file denominato master-playbook.yml e aggiungi il contenuto di seguito:

- name: Configuration of master node
  hosts: masters
  tasks:
    - name: initialize K8S cluster
      shell: kubeadm init --pod-network-cidr=172.16.0.0/16 --apiserver-advertise-address=192.168.100.5 --ignore-preflight-errors=all

    - name: create .kube directoryi and copy kube config file
      shell: "{{ item }}"
      loop:
        -  mkdir -p $HOME/.kube
        -  cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
        - chown $(id -u):$(id -g) $HOME/.kube/config

    - name: install Pod network
      become: yes
      shell: kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.25.0/manifests/calico.yaml >> pod_network_setup.txt
      args:
        chdir: $HOME
        creates: pod_network_setup.txt

Esegui il playbook con il comando:

ansible-playbook -i hosts.ini master-playbook.yml

Passaggio 5: configura il playbook dei nodi di lavoro

Questo playbook viene utilizzato per automatizzare il processo di unione dei nodi Kubernetes. Viene eseguito su tutti i nodi, generando un comando di join sul nodo master e distribuendolo ai nodi di lavoro. Inizialmente, recupera il comando join utilizzando kubeadm token create e lo archivia. Quindi, imposta un fatto con questo comando da utilizzare sui nodi di lavoro. Infine, i nodi di lavoro utilizzano questo comando per unirsi al cluster Kubernetes, ignorando i controlli preflight. Questo playbook semplifica il processo di espansione del cluster automatizzando la procedura di unione dei nodi.

Crea un file denominato lavoratore-playbook.yml e aggiungi il contenuto di seguito:

- name: Generating token on master node and token deployment to worker node
  hosts: all
  gather_facts: false
  tasks:
    - name: get join command
      shell: kubeadm token create --print-join-command
      register: join_command_raw
      when: "'masters' in group_names"

    - name: set join command
      set_fact:
        join_command: "{{ join_command_raw.stdout_lines[0] }}"
      when: "'masters' in group_names"

    - name: join cluster
      shell: "{{ hostvars['master'].join_command }} --ignore-preflight-errors all  >> node_joined.txt"
      args:
        chdir: $HOME
        creates: node_joined.txt
      when: "'workers' in group_names"

Esegui il playbook con il comando:

ansible-playbook -i hosts.ini worker-playbook.yml

Passaggio 5: verifica del cluster

Una volta eseguiti i playbook, puoi verificare che il cluster Kubernetes sia configurato correttamente.

Sul nodo master, esegui:

kubectl get nodes

Dovresti vedere tutti i nodi elencati con il loro stato come Pronto.

Conclusione

Seguendo questi passaggi, hai configurato correttamente un cluster Kubernetes utilizzando Ansible. Questo metodo offre un processo scalabile e ripetibile, semplificando la gestione e l'automazione della distribuzione dei cluster Kubernetes. Man mano che acquisisci maggiore familiarità con Ansible e Kubernetes, puoi personalizzare ulteriormente i tuoi playbook per adattarli ai tuoi requisiti specifici, ad esempio aggiungendo più nodi di lavoro o configurando funzionalità avanzate. Buona orchestrazione!

Guida per configurare un cluster Kubernetes (K8s) utilizzando Ansible