Guía para configurar un clúster de Kubernetes (K8s) usando Ansible

Introducción

Kubernetes se ha convertido en la solución de referencia para la orquestación de contenedores, lo que permite a los desarrolladores implementar, administrar y escalar fácilmente aplicaciones en contenedores. Sin embargo, configurar un clúster de Kubernetes puede ser un proceso complejo que implica numerosos pasos y configuraciones. Aquí es donde entra en juego Ansible, una herramienta de automatización de código abierto. Al automatizar el proceso de implementación, Ansible puede facilitar mucho la creación de un clúster de Kubernetes.

En esta guía, lo guiaremos a través del proceso de creación de un clúster de Kubernetes usando Ansible. Se supone que todos los nodos del clúster K8 ejecutan el sistema operativo Ubuntu Linux.

Requisitos previos

Antes de sumergirnos en el proceso de configuración, asegúrese de tener los siguientes requisitos previos:

Ansible: Ansible debe instalarse en la máquina de control. La máquina de control es donde ejecutará sus scripts de Ansible y puede ser su máquina local o un servidor.
Nodos de destino: estas son las máquinas donde se instalará Kubernetes. Necesitará al menos dos nodos: uno para el nodo maestro y otro para el nodo trabajador. Asegúrese de que estos nodos estén ejecutando una distribución de Linux compatible.
Acceso SSH: Ansible se comunica con los nodos de destino a través de SSH. El acceso SSH debe configurarse para todos los nodos de destino desde la máquina de control.

Paso 1: instalar Ansible

Para comenzar, configure Ansible en su máquina de control. El proceso implica la instalación de Ansible, que varía según el sistema operativo. Utilice los siguientes comandos dependiendo de su distribución:

sudo apt-get update

sudo apt-get install ansible

Paso 2: configure su archivo de inventario

Después de instalar Ansible, continúe con la configuración del archivo de inventario. Cree un archivo llamado host.ini en su directorio de trabajo, que enumerará todos los nodos de destino junto con sus direcciones IP. Para mejorar la claridad, organícelos en grupos como maestros y trabajadores. Aquí hay un ejemplo:

[masters]
 master ansible_host=192.168.1.100

 [workers]
 worker1 ansible_host=192.168.1.101
 worker2 ansible_host=192.168.1.102

Paso 3: Configurar el clúster del Playbook K8s

Este manual le ayudará a configurar un clúster de Kubernetes utilizando sistemas Ubuntu. Incluye tareas para deshabilitar el firewall, deshabilitar el intercambio, configurar ajustes de red, agregar el repositorio de Docker, instalar Docker y sus componentes, ajustar la configuración del tiempo de ejecución del contenedor, agregar el repositorio de Kubernetes e instalar componentes de Kubernetes (kubelet, kubeadm, kubectl). Específicamente, kubectl se instala solo en nodos identificados como maestros. El manual demuestra un enfoque integral para preparar sistemas para Kubernetes, centrándose en los servicios necesarios, las configuraciones de seguridad y los componentes esenciales de Kubernetes.

Cree un archivo setup-playbook.yaml y agregue el siguiente contenido:

- 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"

Ejecute el libro de jugadas ejecutando:

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

Paso 4: Configurar el nodo maestro

Este manual de Ansible está diseñado para configurar el nodo maestro de un clúster de Kubernetes. Inicialice el clúster de Kubernetes con configuraciones de red específicas, cree un directorio .kube y copie el archivo de configuración de kube en el directorio de inicio del usuario para la administración del clúster. Instale también el complemento de red Calico para administrar la red de pods, asegurando que los pods puedan comunicarse entre sí a través de nodos. El manual automatiza el proceso de configuración inicial, simplificando la implementación de un clúster de Kubernetes.

Cree un archivo llamado master-playbook.yml y agregue el contenido a continuación:

- 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

Ejecute el libro de jugadas con el comando:

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

Paso 5: configurar el manual del nodo trabajador

Este manual se utiliza para automatizar el proceso de fusión de nodos de Kubernetes. Se ejecuta en todos los nodos, genera un comando de unión en el nodo maestro y lo distribuye a los nodos trabajadores. Inicialmente, recupera el comando de unión mediante kubeadm token create y lo almacena. Luego, establezca un hecho con este comando para usarlo en nodos trabajadores. Finalmente, los nodos trabajadores usan este comando para unirse al clúster de Kubernetes, sin pasar por las comprobaciones previas. Este manual simplifica el proceso de expansión del clúster al automatizar el proceso de fusión de nodos.

Cree un archivo llamado trabajador-playbook.yml y agregue el contenido a continuación:

- 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"

Ejecute el libro de jugadas con el comando:

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

Paso 5: verificar el clúster

Una vez que ejecute los manuales, podrá verificar que su clúster de Kubernetes esté configurado correctamente.

En el nodo maestro, ejecute:

kubectl get nodes

Debería ver todos los nodos enumerados con su estado Listo.

Conclusión

Si sigue estos pasos, habrá configurado correctamente un clúster de Kubernetes utilizando Ansible. Este método ofrece un proceso escalable y repetible, lo que facilita la gestión y automatización de la implementación de clústeres de Kubernetes. A medida que se familiarice con Ansible y Kubernetes, podrá personalizar aún más sus manuales para que se ajusten a sus requisitos específicos, como agregar más nodos trabajadores o configurar funciones avanzadas. ¡Feliz orquestación!