Cómo instalar Kubernetes en Ubuntu
La instalación manual de contenedores de Docker en varios servidores puede llevar mucho tiempo, lo que ocupa por completo la agenda de cualquier administrador de sistemas encargado de esta tarea. En el sector de las tecnologías de la información actual, la popularidad de la nube, los microservicios y los contenedores sigue creciendo y, por este motivo, se han desarrollado soluciones como Kubernetes.
Kubernetes es una solución de código abierto para la gestión y orquestación de contenedores que permite crear un clúster para facilitar la instalación de contenedores en entornos distribuidos, así como para proporcionar alta disponibilidad a las aplicaciones en contenedores. El objetivo de esta entrada del blog es explicar cómo instalar Kubernetes en Ubuntu para ejecutar aplicaciones en contenedores Docker.
Requisitos y configuración del sistema para instalar Kubernetes en Ubuntu
El clúster de Kubernetes está formado por nodos maestros y nodos de trabajo. La configuración del hardware depende de tus necesidades y de las aplicaciones que tengas previsto ejecutar en contenedores Docker. Los requisitos mínimos de hardware para instalar Kubernetes en Ubuntu son:
- Al menos una CPU (unidad central de procesamiento) x86/x64 de 2 núcleos
- 2 GB de RAM (memoria de acceso aleatorio) o más
- Acceso a Internet
Puertos que deben abrirse para instalar Kubernetes en Ubuntu:
| Protocolo y intervalo de puertos | Origen | Finalidad | Dirección |
| TCP 443 | Nodos de trabajo, usuarios finales, solicitudes de API | Servidor de la API de Kubernetes | Entrante del nodo maestro |
| TCP 10250 | Nodos maestros | Puerto de comprobación de estado de Kubelet del nodo de trabajo | Entrante del nodo de trabajo |
| TCP 30000-32767 | Clientes de aplicaciones externas | Intervalo de puertos predeterminado para la prestación de servicios externos | |
| UDP 8285 | Nodos de trabajo | Backend UDP de la red superpuesta Flannel | |
| UDP 8472 | Nodos de trabajo | Backend VXLAN de la red superpuesta Flannel | |
| TCP 179 | Nodos de trabajo | Solo se requiere si se utiliza la red BGP de Calico | |
| TCP 2379-2380 | Nodos maestros | API de cliente del servidor etcd | Entrada al nodo etcd |
| TCP 2379-2380 | Nodos de trabajo | API de cliente del servidor etcd necesaria si se utiliza Flannel o Calico |
Por defecto, el cortafuegos iptables viene instalado en Ubuntu, pero no hay ninguna regla de bloqueo «preconfigurada». Por lo tanto, si estás instalando Ubuntu para probar Kubernetes, no es necesario que edites las reglas del cortafuegos. Kube-proxy coloca primero sus cadenas de iptables y, a continuación, inserta dos reglas de iptables. Estas reglas son KUBE-EXTERNAL-SERVICES y KUBE-FIREWALL, que se insertan al principio de la cadena INPUT.
La instalación de Kubernetes en Ubuntu puede realizarse tanto en máquinas físicas como en máquinas virtuales. La recomendación general es utilizar la última versión de Ubuntu Linux de 64 bits. La entrada de blog de hoy explica cómo instalar Kubernetes en Ubuntu 18.04 LTS ejecutado en máquinas virtuales de VMware. El primer tipo de instalación de Kubernetes que se explica es el que utiliza un nodo maestro y dos nodos de trabajo para el clúster de Kubernetes. Consulta la tabla siguiente para ver el número de nodos (en función de las condiciones), los roles de los nodos, los nombres de host y las direcciones IP de las máquinas utilizadas en el ejemplo que se analiza.
| N.º | Rol del nodo | Dirección IP | Nombre de host |
| 1 | Maestro | 192.168.101.21 | docker-nakivo21 |
| 2 | Trabajador | 192.168.101.31 | docker-nakivo31 |
| 3 | Trabajador | 192.168.101.32 | docker-nakivo32 |
Puedes utilizar máquinas virtuales que se ejecuten en hosts ESXi de VMware si utilizas VMware vSphere, o bien puedes ejecutar máquinas virtuales en VMware Workstation instalado en tu ordenador personal con Linux o Windows. En el ejemplo de hoy utilizamos máquinas virtuales que se ejecutan en VMware Workstation. Las máquinas virtuales utilizan la red NAT red con acceso a Internet, y si prefieres VirtualBox a VMware, puedes utilizarlo.
La dirección IP de la máquina host: 10.10.10.53
La dirección IP de la puerta de enlace virtual para la red NAT (VMNet8): 192.168.101.2
El mismo usuario de Linux existe en todas las máquinas Ubuntu: kubernetes-user
Configuración de la máquina virtual: 2 CPU, 4 GB de RAM, disco virtual de 20 GB
Puedes cambiar las direcciones IP de VMNet8 accediendo a Edit > Virtual Network Editor en VMware Workstation.
Para facilitar la comprensión, en el ejemplo de hoy todos los componentes se instalarán en Linux manualmente, sin herramientas de automatización como Ansible.
Implementación de la máquina virtual de Ubuntu
Crea una nueva máquina virtual con el nombre docker-nakivo21 .
Instala Ubuntu de 64 bits en la primera máquina y configura el nombre de host y el nombre de usuario.
Nombre de la máquina virtual: docker-nakivo21
Nombre de usuario: kubernetes-user
Instala VMware Tools después del primer inicio de sesión en el sistema operativo instalado. Si utiliza máquinas físicas, no es necesario utilizar VMware Tools y puede omitir este paso.
Nota : El carácter $ al principio significa que un comando se ejecuta como usuario normal ( kubernetes-user en este caso). Si la cadena comienza con el carácter # , el comando debe ejecutarse como root . El comando sudo (sustituye «user do» por «superusuario do») te permite ejecutar comandos como otro usuario, incluido root. Puedes escribir sudo -i para obtener privilegios de root en la consola. Pulsa Ctrl+D para salir del modo root.
Puedes instalar VMware Tools desde la imagen ISO que se incluye con el hipervisor de VMware o desde los repositorios de Linux (como se explica a continuación).
$ sudo apt-get install open-vm-tools
Si necesitas funciones avanzadas del escritorio, como el portapapeles compartido, arrastrar y soltar archivos, etc., ejecuta:
$ sudo apt-get install open-vm-tools-desktop
Reinicia la máquina virtual.
$ init 6
Configura tu máquina Ubuntu antes de instalar Kubernetes
Es necesario realizar algunos preparativos antes de instalar Kubernetes en máquinas Ubuntu. En primer lugar, debes configurar la dirección IP estática y el nombre de host, como en cualquier servidor habitual.
Configura la dirección IP estática
Al igual que con cualquier otro tipo de clúster, se recomienda encarecidamente utilizar direcciones IP estáticas en los nodos.
Instala las herramientas de red de Linux antes de configurar la dirección IP.
$ sudo apt-get install net-tools
Escribe ifconfig para comprobar la dirección IP actual de tu máquina virtual Ubuntu.
Verás que la dirección IP se obtiene automáticamente a través de DHCP. Recuerda el nombre de la interfaz de red. En el ejemplo actual, este nombre es ens33 . El nombre de la primera interfaz de red Ethernet suele ser eth0 en el caso de las máquinas físicas.
Necesitarás un editor de texto para editar los archivos de configuración. Instala vim como editor de texto.
$ sudo apt-get install vim
En las últimas versiones de Ubuntu, la configuración de red se establece en un archivo YAML. Abre el archivo YAML de configuración de red en vim.
$ sudo vim /etc/netplan/01-network-manager-all.yaml
La vista predeterminada del archivo de configuración es:
Edita este archivo de configuración de red tal y como se muestra a continuación:
network:
version: 2
renderer: networkd
ethernets:
ens33:
dhcp4: no
addresses: [192.168.101.21/24]
gateway4: 192.168.101.2
nameservers:
addresses: [192.168.101.2,8.8.8.8]
Guarda los cambios y sal.
:wq
$ sudo netplan try
Pulsa INTRO para aceptar la nueva configuración.
Comprueba si se ha modificado la configuración de red e intenta hacer ping, por ejemplo, a nakivo.com .
$ ifconfig
$ ping nakivo.com
Configurar un nombre de host
Comprueba tu nombre de host actual.
$ hostnamectl
Como recordarás, el nombre de host de la primera máquina virtual, que es docker-nakivo21 , ya se configuró durante la instalación. Para cambiar el nombre de host, haz lo siguiente (esto será necesario para configurar la segunda y la tercera máquina virtual después de la clonación. Está previsto que esas dos máquinas virtuales se configuren como nodos de trabajo):
Por ejemplo, si necesitas cambiar el nombre de host a docker-nakivo21 en la primera máquina virtual, ejecuta: $ sudo hostnamectl set-hostname docker-nakivo21
Comprueba que se haya aplicado el nuevo nombre de host.
$ less /etc/hostname
Edita el archivo hosts de .
$ sudo vim /etc/hosts
El contenido del archivo hosts debe ser similar a este:
127.0.0.1 localhost
127.0.1.1 docker-nakivo21
Reinicia la máquina.
$ init 6
Desactivar un archivo de intercambio
Kubernetes no admite el uso de un archivo de intercambio (partición de intercambio) y es necesario desactivar el «swappiness» para instalar Kubernetes en Ubuntu correctamente.
Desactive el archivo de intercambio para evitar un elevado consumo de CPU por parte de kubelet.
$ sudo swapoff -a
Edite /etc/fstab y comente la línea utilizando el carácter # .
$ sudo vim /etc/fstab
#/swapfile none swap sw 0 0
Puedes hacer lo mismo con sed con un solo comando:
$ sudo sed -i '/ swap / s/^(.*)$/#1/g' /etc/fstab
Desactiva el swap en sysctl.conf
$ sudo echo "vm.swappiness=0" | sudo tee --append /etc/sysctl.conf
Donde 0 es el porcentaje de swapiness. En este caso, el swap solo se puede utilizar si te quedas sin RAM (por defecto, el swap se utiliza cuando más del 60 % de la RAM está llena).
Aplica los cambios de configuración sin reiniciar.
$ sudo sysctl -p
Nota : Si la partición de swap no está desactivada, el kswapd0 proceso de Ubuntu Linux que ejecuta Kubernetes puede consumir una gran cantidad de recursos de CPU en tu máquina, lo que provoca que las aplicaciones dejen de responder y que el sistema se cuelgue. Esto ocurre cuando el sistema operativo se queda sin memoria y un proceso del núcleo de Linux traslada las páginas de memoria antiguas al swap. Por motivos desconocidos, a veces las cosas salen mal y se produce un bucle infinito que consume todos los recursos de la CPU. En la captura de pantalla que aparece a continuación, se observa un elevado consumo de CPU por parte del proceso kswapd0 cuando Kubernetes está instalado en Ubuntu. El valor medio de carga es excesivamente alto.
Si kswapd0 sigue sobrecargando la CPU, ejecuta el siguiente comando para invalidar todas las cachés de memoria y detener kswapd0 (ejecútalo como root).
# echo 1 > /proc/sys/vm/drop_caches
Apaga la máquina virtual.
$ init 0
Esta máquina virtual parcialmente configurada ( docker-nakivo21 ) se va a utilizar como nodo maestro. Crea dos máquinas que se utilizarán como nodos de trabajo. Si utilizas máquinas físicas, repite los pasos anteriores manualmente (o utiliza herramientas de automatización como Ansible para configurar varias máquinas Linux simultáneamente a través de SSH). Dado que en este ejemplo se utilizan máquinas virtuales, estas se pueden clonar para ahorrar tiempo durante la preparación del entorno para la instalación de Kubernetes en máquinas Ubuntu.
Clona la máquina virtual
Clona tu primera máquina virtual. Si utilizas VMware ESXi, puedes usar la función de clonación integrada. Puedes obtener más información sobre este tema leyendo nuestra entrada de blog en clonación de máquinas virtuales mediante plantillas de máquinas virtuales. Si utilizas VMware Workstation, también puedes clonar máquinas virtuales mediante dos métodos (la herramienta de clonación integrada y de forma manual). Puedes hacer clic en VM > Manage > Clone para crear un clon vinculado. Creemos un clon completo de la primera máquina virtual y copiemos manualmente los archivos de la máquina virtual. En este caso, los archivos se copian desde el directorio docker-nakivo21 al directorio docker-nakivo31. Los directorios deben crearse manualmente antes de copiar los archivos de la máquina virtual.
Edita el archivo VMX, ya que se han modificado el nombre de la máquina virtual y la ruta al archivo del disco virtual.
displayName = "docker-nakivo31"
scsi0:0.fileName = "C:VirtualKUBERNETESdocker-nakivo31docker-nakivo31.vmdk"
nvram = "docker-nakivo31.nvram"
Ya se ha creado la máquina virtual que se utilizará como primer nodo de trabajo. Clona la primera máquina virtual una vez más para preparar el segundo nodo de trabajo del clúster de Kubernetes.
Edita el archivo VMX de la tercera máquina virtual (el segundo nodo de trabajo), tal y como has hecho anteriormente.
displayName = "docker-nakivo32"
scsi0:0.fileName = "C:VirtualKUBERNETESdocker-nakivo31docker-nakivo32.vmdk"
nvram = "docker-nakivo32.nvram"
Abre los clones de la máquina virtual en VMware Workstation (File> Open y selecciona el archivo VMX de la máquina virtual), o simplemente haz doble clic en el archivo VMX de la máquina virtual. Enciende las tres máquinas virtuales (tu máquina virtual de origen y los dos clones). Haga clic en «Lo he copiado» , cuando se le solicite.
Nota : Si utiliza máquinas virtuales, edite la dirección IP y el nombre de host en cada clon de máquina virtual una vez que se hayan clonado las máquinas virtuales. Si utilizas máquinas físicas, sigue todos los pasos anteriores según tus direcciones IP y nombres de host para cada máquina.
Configuración de direcciones IP y nombres de host en máquinas virtuales
Cambia la dirección IP y el nombre de host en docker-nakivo31 y docker-nakivo32 (tal y como se muestra arriba).
Repite los pasos explicados en las secciones anteriores para configurar las direcciones IP estáticas y los nombres de host.
La dirección IP debe ser: 192.168.101.31 y 192.168.101.32 ; los nombres de host deben ser docker-nakivo31 y docker-nakivo32 respectivamente en los nodos de trabajo.
Todas las máquinas deben estar configuradas para resolver los nombres de host de los nodos a direcciones IP. Puede configurar un servidor DNS o realizar la edición del archivo hosts de en cada máquina. Vamos a editar el archivo hosts de .
Añada las siguientes cadenas al archivo hosts de en cada máquina ( docker-nakivo21 , docker-nakivo31 , docker-nakivo32 ).
$ sudo vim /etc/hosts
Añada estas líneas al archivo hosts de :
192.168.101.21 docker-nakivo21
192.168.101.31 docker-nakivo31
192.168.101.32 docker-nakivo32
Realice un ping a otros hosts desde cada host para asegurarse de que los nombres de host se resuelven: $ ping docker-nakivo21
$ ping docker-nakivo31
$ ping docker-nakivo32
Configurar el acceso SSH en todos los hosts (máquinas virtuales)
Configura el acceso SSH en todos los hosts. Instala el servidor OpenSSH ejecutando los comandos en cada máquina.
$ sudo apt-get install openssh-server
Ve al directorio de inicio de kubernetes-user y genera el par de claves SSH (un conjunto de claves criptográficas que consta de una clave privada y una clave pública). Los pares de claves SSH se pueden utilizar para acceder a la consola remota de Linux a través de SSH sin necesidad de contraseñas. La clave pública se puede copiar en un equipo desde el que necesites conectarte de forma remota, mientras que la clave privada es altamente confidencial y debe almacenarse en el equipo al que necesites conectarte.
$ ssh-keygen
No es necesario introducir la contraseña para generar las claves (la contraseña es opcional).
Copia las claves a otros equipos con Ubuntu:
$ ssh-copy-id kubernetes-user@192.168.101.31
$ ssh-copy-id kubernetes-user@192.168.101.32
Introduce tu contraseña de usuario para confirmar la copia de las claves.
Intenta conectarte al segundo equipo ( docker-nakivo31 ) como kubernetes-user (que es un usuario normal).
$ ssh 'kubernetes-user@192.168.101.31'
A continuación, prueba la conexión con la tercera máquina ( docker-nakivo32 ).
$ ssh 'kubernetes-user@192.168.101.32'
Verás el nombre de la máquina remota en la línea de comandos de tu consola después de que se establezca la conexión.
Pulsa Ctrl+D para salir de la consola remota.
¿Cómo copio la clave para conectarme vía SSH como usuario root?
Dado que necesitarás privilegios de root en Kubernetes, vamos a crear claves para configurar el acceso SSH para root. Ejecuta los siguientes comandos en todas las máquinas (docker-nakivo21, docker-nakivo31 y docker-nakivo32) a las que debas acceder vía SSH como usuario root.
$ sudo -i
Edita el archivo de configuración del servidor SSH.
# vim /etc/ssh/sshd_config
Añade o edita la siguiente cadena en este archivo.
PermitRootLogin yes
Reinicia el demonio del servidor SSH.
# /etc/init.d/ssh stop
# /etc/init.d/ssh start
Establece la contraseña de root (contraseña del usuario root).
# passwd
$ cd /home/kubernetes-user/
$ sudo ssh-keygen -t rsa
Copia la clave pública para poder iniciar sesión de forma remota a través de SSH como root (la clave se almacena en el directorio de inicio del usuario normal, ya que el comando anterior se ejecutó desde ese directorio).
$ sudo ssh-copy-id -i /home/kubernetes-user/.ssh/id_rsa.pub 127.0.0.1
Si tu clave está guardada en el directorio de inicio del usuario root, copia la clave con este comando:
# ssh-copy-id -i /root/.ssh/id_rsa.pub 127.0.0.1
Confirma esta operación e introduce tu contraseña.
Repite la acción, copiando la clave de cada máquina a las demás. Por ejemplo, en la máquina docker-nakivo21 ejecuta:
# ssh-copy-id -i /root/.ssh/id_rsa.pub 192.168.101.31
# ssh-copy-id -i /root/.ssh/id_rsa.pub 192.168.101.32
Autoriza la clave pública.
# cat /root/.ssh/id_rsa.pub >> /root/.ssh/authorized_keys
Verifica si puedes iniciar sesión como usuario root a través de SSH en la máquina local. $ sudo ssh root@127.0.0.1
Intenta conectarte desde/hacia la máquina remota sin introducir una contraseña.
$ sudo ssh root@192.168.101.21
$ sudo ssh root@192.168.101.31
$ sudo ssh root@192.168.101.32
Nota : Conectarse como usuario root puede no ser seguro. No te conectes como root si no es necesario; es mejor conectarse vía SSH como usuario normal y utilizar el comando sudo .
Instalación de Docker
Docker es la plataforma de contenedores de aplicaciones empresariales más popular compatible con Kubernetes. Instala Docker en todas las máquinas. Ejecute los comandos que se muestran a continuación en docker-nakivo21 , docker-nakivo31 , docker-nakivo32 .
Sin embargo, no hay por qué precipitarse. Para empezar, puede instalar Docker simplemente utilizando el comando habitual:
$ sudo apt-get install -y docker.io
No obstante, en este caso, es posible que la versión de Docker utilizada no sea la más reciente. Vamos a solucionarlo instalando la última versión de Docker.
En primer lugar, instala los paquetes necesarios.
$ sudo apt-get install apt-transport-https ca-certificates curl software-properties-common
Curl es una herramienta universal y compacta diseñada para transferir datos desde y hacia un servidor sin intervención del usuario, utilizando uno de los protocolos compatibles (HTTP, HTTPS, FTP, FTPS, SFTP, LDAP, LDAPS, IMAP, IMAPS, POP3, POP3S, SCP, SMB, SMTP, TELNET, etc.).
Añade la clave GPG del repositorio oficial de Docker a tu sistema Ubuntu:
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
La salida de la consola debe ser OK.
Añade el repositorio oficial de Docker a tu gestor de paquetes apt:
$ sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable"
Actualiza la base de datos del gestor de paquetes después de realizar los cambios manuales con el comando anterior.
$ sudo apt-get update
Comprueba la versión del paquete de Docker disponible en el repositorio oficial.
$ apt-cache policy docker-ce
Instala Docker.
$ sudo apt-get install docker-ce
Puedes comprobar la versión de Docker después de la instalación.
$ docker --version
En este caso, el resultado es: Docker versión 18.09.6, compilación 481bc77 .
Inicia Docker y configura su daemon para que se cargue automáticamente al arrancar el sistema.
$ sudo systemctl start docker
$ sudo systemctl enable docker
Una vez que hayas instalado Docker en todas las máquinas, puedes pasar directamente al paso de instalación de Kubernetes en Ubuntu.
Instalación de Kubernetes en Ubuntu e inicialización del clúster
Ahora, ya nada te impide instalar los componentes principales de Kubernetes.
Ejecuta los comandos como root en todas las máquinas que se vayan a incluir en el clúster de Kubernetes.
$ sudo -i
Añade la clave GPG del repositorio oficial de Docker a tu sistema Ubuntu:
# curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -
Añade el repositorio oficial de Kubernetes a la base de datos de repositorios de paquetes disponibles para tu gestor de paquetes apt.
# cat <<EOF >/etc/apt/sources.list.d/kubernetes.list
deb http://apt.kubernetes.io/ kubernetes-xenial main
EOF
Como alternativa, puedes añadir el repositorio con este comando: # echo 'deb http://apt.kubernetes.io/ kubernetes-xenial main' | sudo tee /etc/apt/sources.list.d/kubernetes.list
Donde tee es una herramienta que lee la entrada estándar y escribe los datos de entrada en la salida estándar y en los archivos definidos.
Actualiza la lista de paquetes de los repositorios disponibles en tu sistema Ubuntu.
# apt-get update
Instalar kubectl , kubeadm y kubectl es fundamental para instalar Kubernetes en Ubuntu.
# apt-get install -y kubelet kubeadm kubectl
Instala keepalived.
# apt-get install keepalived
# systemctl enable keepalived && systemctl start keepalived
Verifica si el valor es 1 para garantizar el correcto funcionamiento de Kubernetes instalado en Ubuntu.
# sysctl net.bridge.bridge-nf-call-iptables
Para establecer este valor en 1 ejecuta el comando:
sysctl net.bridge.bridge-nf-call-iptables=1
Edita el archivo de configuración de kubeadm.
# vim /etc/systemd/system/kubelet.service.d/10-kubeadm.conf
Añade la cadena después de la cadena Environment existente:
Environment=”cgroup-driver=systemd/cgroup-driver=cgroupfs”
Los cgroups son grupos de control que aíslan el uso de recursos como el procesador, la memoria, la entrada/salida de disco y la red.
En el nodo maestro ( docker-nakivo21 ) ejecuta el comando para inicializar el clúster de Kubernetes en Ubuntu.
# kubeadm init --pod-network-cidr=10.244.0.0/16 --apiserver-advertise-address=192.168.101.21
Donde
–pod-network-cidr es un requisito del controlador Flannel. CIDR (Classless Inter-Domain Routing) define la dirección de tu red superpuesta (como Flannel) que se configurará más adelante. La máscara de red también define cuántos pods pueden ejecutarse por nodo. La dirección de red CIDR y la dirección de red utilizada para Flannel deben ser las mismas.
–apiserver-advertise-address=192.168.101.21 define la dirección IP que Kubernetes anunciará como su servidor API.
Lee la salida y guarda los comandos que aparecen al final del texto. Este es un punto importante. El token generado es necesario para añadir nodos de trabajo al clúster de Kubernetes.
Ejecuta los siguientes comandos como el usuario que ha ejecutado kubeadm init. En este caso, los comandos se ejecutan como usuario root.
# mkdir -p $HOME/.kube
# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
# sudo chown $(id -u):$(id -g) $HOME/.kube/config
Si no ejecutas estos comandos, Kubernetes mostrará el error: «La conexión al servidor localhost:8080 ha sido rechazada. ¿Has especificado el host o el puerto correctos?»
Kubernetes no copia automáticamente este archivo de configuración al directorio de usuario. Debes realizar esta operación manualmente.
Comprueba los nodos añadidos al clúster
# kubectl get nodes
Puedes ver un nodo maestro que tiene el estado «NotReady» en el clúster de Kubernetes que se está instalando en Ubuntu. Esto se debe a que la red superpuesta no se ha configurado. Configura Flannel para solucionar el estado «NotReady» del nodo maestro de Kubernetes. Crea el directorio para almacenar los archivos YAML de Docker y Kubernetes; por ejemplo: /home/kubernetes-user/kubernetes/
YAML (Yet Another Markup Language) te ofrece mayor comodidad a la hora de crear pods y instalaciones en Kubernetes. Puedes definir todos los parámetros de los contenedores que deben instalarse en el archivo de configuración YAML, en lugar de ejecutar cada comando manualmente en la consola de Linux. Los archivos YAML también se denominan «archivos de manifiesto» en el contexto de Kubernetes.
Crea el archivo de configuración YAML con el siguiente contenido:
Ejecuta el comando
# kubectl apply -f ./kube-flannel.yml
Como alternativa, puedes encontrar ejemplos gratuitos ya preparados de configuraciones de instalación YAML para Kubernetes en GitHub.
kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/a70459be0084506e4ec919aa1c114638878db11b/Documentation/kube-flannel.yml
Comprueba los nodos añadidos al clúster de Kubernetes que estás instalando en Ubuntu:
# kubectl get nodes
El estado del nodo maestro ahora es «Ready».
Asegúrate de que Flannel se ha configurado correctamente:
# kubectl get pods --all-namespaces
Puedes ver que el pod de Flannel se está ejecutando. Este pod consta de dos contenedores: el daemon de Flannel y el initContainer, que se utiliza para instalar la configuración de CNI en una ubicación legible para Kubernetes.
A veces, al instalar Kubernetes en Ubuntu, puede producirse el siguiente error:
No se puede conectar al servidor: net/http: tiempo de espera de handshake TLS agotado.
¿Cómo se puede solucionar este problema? Espera unos segundos y vuelve a intentarlo; suele ser suficiente.
Los espacios de nombres son entidades lógicas del clúster de Kubernetes que representan los recursos del clúster y pueden considerarse clústeres virtuales. Un clúster físico puede dividirse lógicamente en varios clústeres virtuales. Los espacios de nombres predeterminados de Kubernetes son Default , Kube-public y Kube-system . Puedes obtener la lista de espacios de nombres:
# kubectl get namespaces
Como recordarás, la unidad básica de instalación en Kubernetes es un pod, que es un conjunto de contenedores que comparten el espacio de nombres de red y de montaje. Todos los contenedores del pod se programan en el mismo nodo de Kubernetes. Comprueba los pods disponibles:
# kubectl -n kube-system get pods
Si deseas reiniciar o detener el clúster, ejecuta:
# kubeadm reset
Todo está bien en el nodo maestro. Esto significa que ahora puede continuar con la instalación de Kubernetes en Ubuntu y pasar a añadir nodos de trabajo al clúster.
En los nodos de trabajo ( docker-nakivo31 , docker-nakivo32 ) ejecute el comando:
# kubeadm join 192.168.101.21:6443 --token d8mbzb.uulxu01jbty8yh4z
--discovery-token-ca-cert-hash sha256:65ace7a4ff6fff795abf086f18d5f0d97da71d4639a0d0a6b93f42bea4948a79
El token y el hash se anotaron después de la inicialización del clúster con el comando kubeadm init , como quizá recuerde.
En el nodo maestro, compruebe de nuevo el estado del clúster. # kubectl get nodes
Ahora puedes ver un nodo maestro y dos nodos de trabajo en el clúster de Kubernetes que se ejecuta en máquinas con Ubuntu.
Puedes comprobar la configuración de Kubernetes:
# kubectl cluster-info
Instalación de un pod en Kubernetes
Ahora puedes instalar un pod con contenedores en tu clúster de Kubernetes. Como recordarás, en Kubernetes los contenedores se incluyen en los pods. Si utilizas archivos YAML, crea un directorio para almacenarlos y que te resulte más cómodo. Ve a ese directorio y ejecuta los siguientes comandos: kubectl apply -f test.yaml
Este directorio ya se ha creado al configurar Flannel: /home/kubernetes-user/kubernetes/
Es el momento de instalar un nuevo pod. Primero debes crear una instalación. La instalación es un concepto de controlador que se utiliza para proporcionar actualizaciones declarativas a los pods y a los conjuntos de réplicas. Puedes crear una instalación con un único comando o utilizando archivos YAML.
Ejemplo 1: instalación de MySQL
En este ejemplo, vamos a crear un archivo YAML. El nombre del archivo es mysql-deployment.yaml
Consulta el archivo adjunto para ver la configuración.
# vim mysql-deployment.yaml
Existen dos enfoques habituales para la gestión de recursos con kubectl . ¿Cuál es la diferencia entre kubectl create y kubectl apply ? Al utilizar kubectl create , le indicas a Kubernetes qué quieres crear, sustituir o eliminar; este comando sobrescribe todos los cambios. Como alternativa, kubectl apply aplica cambios incrementales y este comando se puede utilizar para guardar los cambios aplicados a un objeto activo.
Crear una instalación:
# kubectl apply -f ./mysql-deployment.yaml
Kubernetes puede mostrar información sobre tu instalación.
# kubectl describe deployment mysql
Comprobar pods:
# kubectl get po
o
# kubectl get pods
o
# kubectl get pods -l app=mysql
Si ves el estado «pendiente» para el pod, puede significar que no hay suficientes recursos informáticos. Intenta añadir algo de capacidad de CPU y memoria para solucionar el estado «pendiente» del pod en Kubernetes.
Puedes eliminar el servicio si es necesario:
# kubectl delete service <service_name>
También puedes eliminar un pod:
# kubectl delete pod mysql-7b9b7999d8-nz5tm
Ejemplo 2: instalación de nginx
Implementemos nginx utilizando otro método sin archivos YAML.
Crea una instalación.
# kubectl create deployment nginx --image=nginx
Comprueba que se haya creado la instalación.
# kubectl get deployments
Crea un servicio.
# kubectl create service nodeport nginx --tcp=80:80
Se puede crear un servicio utilizando los siguientes tipos de servicio: ClusterIP, NodePort, LoadBalance y ExternalName. Si se utiliza el tipo NodePort, se asigna un puerto aleatorio del intervalo 30000-32767 para acceder a los servicios proporcionados. El tráfico que se envía a este puerto se reenvía al servicio correspondiente.
Comprueba que el servicio se haya creado y que esté a la escucha en el puerto definido.
# kubectl get svc
Anota el número de puerto (31453 en este caso).
Comprueba si tu servicio está instalado y disponible (en este ejemplo, el comando se ejecuta en el nodo maestro). Utiliza el nombre de host del nodo y el puerto que has anotado en el paso anterior.
# curl docker-nakivo31:31453
También puedes comprobar que se puede acceder al servicio desde el navegador de cualquier nodo. En la barra de direcciones del navegador web, intenta visitar las páginas:
http:// 10.101.235.90
o
http://docker-nakivo31:31453
http://docker-nakivo32:31453
. Si todo va bien, verás la página de bienvenida de nginx.
También es posible visitar la página de prueba de nginx desde cualquier máquina que tenga acceso a la red a la que están conectados los nodos de Kubernetes —( 192.168.101.0/24 ) en este caso. Por ejemplo, puedes visitar las páginas web con tu navegador:
http://192.168.101.21:31453/
http://192.168.101.31:31453/
http://192.168.101.32:31453/
Configurar la interfaz web para la supervisión de Kubernetes
La instalación de Kubernetes en Ubuntu está casi completa, pero también puedes instalar el panel de control de Kubernetes para mayor comodidad. El panel de control de Kubernetes es una interfaz web para la gestión y supervisión de Kubernetes. Para instalar el panel de control, crea el archivo kubernetes-dashboard.yaml , tal y como has hecho anteriormente antes de ejecutar los comandos.
# kubectl create -f ./kubernetes-dashboard.yaml
# kubectl apply -f ./kubernetes-dashboard.yaml
Comprueba los pods.
# kubectl get pods -o wide --all-namespaces
Inicia el proxy del servidor de la API de Kubernetes.
# kubectl proxy
Para introducir los siguientes comandos en la consola, abre otra ventana de consola. De lo contrario, el proceso se interrumpirá.
En el navegador web del nodo maestro, ve a la página:
http://localhost:8001
Podrás ver la página de prueba.
Introduce la dirección completa en la barra de direcciones del navegador web.
http://localhost:8001/api/v1/namespaces/kube-system/services/https:kubernetes-dashboard:/proxy/
Crea un panel de control con una cuenta de servicio ejecutando los comandos en la nueva ventana de la consola.
# kubectl create serviceaccount dashboard -n default
# kubectl create clusterrolebinding dashboard-admin -n default
--clusterrole=cluster-admin
--serviceaccount=default:dashboard
# kubectl get secret $(kubectl get serviceaccount dashboard -o jsonpath="{.secrets[0].name}") -o jsonpath="{.data.token}" | base64 –decode
Ahora puedes ver el token generado:
Copia el token generado y pégalo en la sección de tokens de la interfaz web para iniciar sesión en el panel de control.
En la captura de pantalla siguiente, puedes ver la interfaz web del panel de control de Kubernetes. Puedes ver el estado de los nodos, las instalaciones y los pods, así como consultar los roles, las clases de almacenamiento y otros componentes. 
Configurar Heapster, la herramienta de monitorización
Instala Heapster para ampliar las opciones de monitorización del panel de control de Kubernetes añadiendo parámetros de CPU, memoria y otros. Crea un archivo de manifiesto con el nombre heapster.yaml .
# vim heapster.yaml
En el siguiente paso, instala Heapster.
# kubectl create -f heapster.yaml
Edita el rol RBAC (control de accesos basado en roles) de Heapster y añade permisos para acceder a las estadísticas de los nodos.
# kubectl edit clusterrole system:heapster
Comprueba que se puedan medir las métricas de CPU y memoria en la consola.
# kubectl top node
Ahora puedes abrir la interfaz web del panel de control de Kubernetes y verás que se han añadido algunas secciones, incluidos los gráficos de uso de CPU y de memoria.
Tu clúster de Kubernetes ya está configurado y listo para funcionar.
Instalación de un clúster de Kubernetes de alta disponibilidad con varios nodos maestros en Ubuntu
Disponer de un clúster de Kubernetes con un nodo maestro y un par de nodos de trabajo es una buena opción, pero a veces el único nodo maestro puede fallar por motivos como problemas de hardware o cortes de corriente. Para lograr una mayor tolerancia a fallos del clúster de Kubernetes instalado en nodos Ubuntu, es mejor plantearse la instalación de un clúster de Kubernetes de alta disponibilidad con varios nodos maestros. El uso de este modelo de instalación de clústeres de Kubernetes permite evitar un único punto de fallo. Se recomienda utilizar un número impar de nodos maestros, y el número mínimo de nodos maestros que puede proporcionar tolerancia a fallos es tres. Si se utilizan más de tres nodos maestros y el número de nodos es par, la tolerancia a fallos de todo el clúster no aumenta. Consulte la tabla siguiente para comparar el nivel de tolerancia a fallos en función del número de nodos maestros del clúster de Kubernetes. Por ejemplo, si tiene un clúster con 5 nodos maestros, el clúster puede sobrevivir al fallo de 2 nodos maestros, ya que tres nodos maestros siguen activos (3 de 5 es más del 50 % y constituye la mayoría). El tamaño del clúster se refiere al número de nodos maestros que lo componen.
| Tamaño del clúster | Mayoría | Tolerancia a fallos |
| 1 | 1 | 0 |
| 2 | 2 | 0 |
| 3 | 2 | 1 |
| 4 | 3 | 1 |
| 5 | 3 | 2 |
| 6 | 4 | 2 |
| 7 | 4 | 3 |
| 8 | 5 | 3 |
| 9 | 5 | 4 |
En esta sección de la entrada del blog de hoy se explica cómo instalar Kubernetes en nodos Ubuntu en el marco de la instalación de un clúster de Kubernetes de alta disponibilidad, un proxy HA y algunos nodos de trabajo. En la tabla siguiente, puedes ver las direcciones IP, los nombres de host y los roles de los hosts utilizados para instalar el clúster de Kubernetes de alta disponibilidad en nodos Ubuntu en el laboratorio de pruebas que se explica en este ejemplo.
| N.º | Rol del nodo | Dirección IP | Nombre de host |
| 1 | Maestro | 192.168.101.21 | docker-nakivo21 |
| 2 | Maestro | 192.168.101.22 | docker-nakivo22 |
| 3 | Maestro | 192.168.101.23 | docker-nakivo23 |
| 4 | HA Proxy | 192.168.101.19 | ha-proxy19 |
| 5 | Worker | 192.168.101.31 | docker-nakivo31 |
| 6 | Worker | 192.168.101.32 | docker-nakivo32 |
Algunos comandos son los mismos que para instalar Kubernetes en Ubuntu utilizando el modelo de un único nodo maestro. Por este motivo, no se repiten los comentarios de algunos comandos. Puedes desplazarte hacia arriba en esta página para consultar la explicación de los comandos.
Prepara todas las máquinas (proxy de alta disponibilidad, nodos maestros y nodos de trabajo) para instalar Kubernetes siguiendo estos pasos:
- Configura las direcciones IP estáticas.
- Establece los nombres de host. Los nombres de todos los hosts deben resolverse a direcciones IP.
- El acceso SSH debe estar habilitado y configurado mediante certificados.
- El swap debe estar desactivado.
Estos pasos deben realizarse antes de iniciar la instalación de Docker en cada máquina, de forma muy similar a lo que se ha explicado en la sección anterior al describir la instalación de Kubernetes en Ubuntu utilizando un único nodo maestro. Una vez preparadas todas las máquinas, acceda a ( 192.168.101.19 ).
Configuración del equilibrador de carga HA Proxy
El equilibrador de carga HA Proxy se utiliza para distribuir el tráfico de entrada entre los nodos de Kubernetes. El equilibrador de carga se instala delante de los nodos maestros. Abre la consola del servidor ha-proxy19 y realiza las acciones que se indican a continuación.
Instala cfssl
Cfssl (CloudFlare SSL) es un conjunto de herramientas que se utiliza para generar diferentes certificados, incluidas cadenas de certificados TLS/SSL.
Descarga los binarios del repositorio oficial.
# wget https://pkg.cfssl.org/R1.2/cfssl_linux-amd64
# wget https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64
Haz que los archivos binarios descargados sean ejecutables.
# chmod +x cfssl*
Mueve estos archivos binarios a /usr/local/bin/
# mv cfssl_linux-amd64 /usr/local/bin/cfssl
# mv cfssljson_linux-amd64 /usr/local/bin/cfssljson
Verifica la instalación verificando la versión de cfssl instalada.
# cfssl version
Actualiza el árbol del repositorio.
# apt-get update
Instala HA Proxy.
# apt-get install haproxy
Crea y edita el archivo haproxy.cfg
# vim /etc/haproxy/haproxy.cfg
Añade estas líneas al final de este archivo de configuración.
frontend kubernetes
bind 192.168.101.19:6443
option tcplog
mode tcp
default_backend kubernetes-master-nodes
backend kubernetes-master-nodes
mode tcp
balance roundrobin
option tcp-check
server docker-nakivo21 192.168.101.21:6443 check fall 3 rise 2
server docker-nakivo22 192.168.101.22:6443 check fall 3 rise 2
server docker-nakivo23 192.168.101.23:6443 check fall 3 rise 2
Reinicia el servicio.
# systemctl restart haproxy
Genera certificados TLS
Puedes seguir utilizando la consola del servidor HA Proxy. Crea el archivo de configuración de la autoridad de certificación, que se llama ca-config.json .
# vim ca-config.json
Añade el siguiente contenido a este archivo de configuración:
{
"signing": {
"default": {
"expiry": "8760h"
},
"profiles": {
"kubernetes": {
"usages": ["signing", "key encipherment", "server auth", "client auth"],
"expiry": "8760h"
}
}
}
}
Crea el archivo de configuración de la solicitud de firma de la autoridad de certificación.
# vim ca-csr.json
Añada el contenido a este archivo tal y como se muestra a continuación:
{
«CN»: «Kubernetes»,
«key»: {
«algo»: «rsa»,
«tamaño»: 2048
},
«names»: [
{
«C»: «GB»,
«L»: «London»,
«O»: «Kubernetes»,
«OU»: «CA»,
«ST»: «Nakivo»
}
]
}
Donde:
C – país, por ejemplo, GB (Gran Bretaña).
L – ubicación, como una ciudad o localidad.
O – organización.
OU – unidad organizativa (por ejemplo, un departamento definido como propietario de la clave).
ST – el estado o la provincia.
Ahora genera la clave pública y la privada.
# cfssl gencert -initca ca-csr.json | cfssljson -bare ca
Verifica que se hayan generado las claves ca-key.pem y ca.pem .
# ls -al
Creación del certificado para el clúster de Etcd
Etcd admite la comunicación entre servidores o dentro del clúster mediante la autenticación a través de certificados de cliente. Debes disponer de un certificado de CA y un par de claves firmado para un miembro del clúster.
Crea el archivo de configuración de la solicitud de firma de certificado.
# vim kubernetes-csr.json
{
"CN": "kubernetes",
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "GB",
"L": "London",
"O": "Kubernetes",
"OU": "Kubernetes",
"ST": "Nakivo"
}
]
}
Después de eso, genera el certificado y la clave privada.
# cfssl gencert
-ca=ca.pem
-ca-key=ca-key.pem
-config=ca-config.json
-hostname=192.168.101.21,192.168.101.22,192.168.101.23,192.168.101.19,127.0.0.1,kubernetes.default
-profile=kubernetes kubernetes-csr.json |
cfssljson -bare kubernetes
Muestra el contenido del directorio para verificar que se han generado los archivos kubernetes-key.pem y kubernetes.pem .
# ls -al
Copia el certificado creado en cada nodo. # scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.21:~
# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.22:~
# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.23:~
# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.31:~
# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.32:~
# scp ca.pem kubernetes.pem kubernetes-key.pem kubernetes-user@192.168.101.33:~
Donde ~ es el directorio de inicio de kubernetes-user en los hosts de Ubuntu.
Preparación de los nodos de Ubuntu para la instalación de Kubernetes
Ejecuta los comandos que se muestran en esta sección en todos los nodos maestros y nodos de trabajo. Instala Docker y, a continuación, instala Kubernetes en las máquinas de Ubuntu que se incluirán en el clúster de Kubernetes. Comencemos por preparar el 192.168.101.21 nodo maestro.
Instala Docker.
# apt-get install apt-transport-https ca-certificates curl software-properties-common
# curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
# add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable"
# apt-get update
# apt-get install docker-ce
Docker ya está instalado. kubeadm, kublet y kubectl son los componentes de Kubernetes necesarios para instalar Kubernetes en Ubuntu.
Instalar los componentes de Kubernetes: kubeadm, kubelet y kubectl.
# curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -
# echo 'deb http://apt.kubernetes.io/ kubernetes-xenial main' | sudo tee /etc/apt/sources.list.d/kubernetes.list
# apt-get update
# apt-get install -y kubelet kubeadm kubectl
Una vez que hayas preparado todos los nodos e instalado Docker, kubelet, kubeadm y kubectl, debes instalar y configurar etcd en los nodos maestros.
Instalación y configuración de etcd en los nodos maestros de Ubuntu
Etcd es un almacén consistente y de alta disponibilidad, destinado a almacenar claves, así como a hacer backup de todos los datos del clúster. El clúster de etcd debe configurarse antes de configurar el clúster de Kubernetes de alta disponibilidad (HA) con varios nodos maestros. Comencemos por configurar el 192.168.101.21 nodo maestro.
Installing and configuring etcd on the 192.168.101.21 machine.
Crea un directorio de configuración para etcd.
# mkdir /etc/etcd /var/lib/etcd
Ve al directorio al que se han copiado los certificados. Este es el directorio de inicio del usuario kubernetes, en este caso: /home/kubernetes-user/
Copia los certificados al directorio de configuración de etcd.
# cp ca.pem kubernetes.pem kubernetes-key.pem /etc/etcd
Verifica que los archivos se han copiado.
# ls -al /etc/etcd
Vuelve al directorio anterior
# cd -
Descarga los binarios de etcd desde el repositorio.
# wget https://github.com/coreos/etcd/releases/download/v3.3.9/etcd-v3.3.9-linux-amd64.tar.gz
Descomprime el archivo de etcd.
# tar xvzf etcd-v3.3.9-linux-amd64.tar.gz
Ahora mueve los archivos binarios de etcd a /usr/local/bin/
# mv etcd-v3.3.9-linux-amd64/etcd* /usr/local/bin/
Crea un archivo de unidad de systemd para etcd.
# vim /etc/systemd/system/etcd.service
Añade las cadenas que se muestran a continuación a este archivo.
[Unit]
Description=etcd
Documentation=https://github.com/coreos
[Service]
ExecStart=/usr/local/bin/etcd
--name 192.168.101.21
--cert-file=/etc/etcd/kubernetes.pem
--key-file=/etc/etcd/kubernetes-key.pem
--peer-cert-file=/etc/etcd/kubernetes.pem
--peer-key-file=/etc/etcd/kubernetes-key.pem
--trusted-ca-file=/etc/etcd/ca.pem
--peer-trusted-ca-file=/etc/etcd/ca.pem
--peer-client-cert-auth
--client-cert-auth
--initial-advertise-peer-urls https://192.168.101.21:2380
--listen-peer-urls https://192.168.101.21:2380
--listen-client-urls https://192.168.101.21:2379,http://127.0.0.1:2379
--advertise-client-urls https://192.168.101.21:2379
--initial-cluster-token etcd-cluster-0
--initial-cluster 192.168.101.21=https://192.168.101.21:2380,192.168.101.22=https://192.168.101.22:2380,192.168.101.23=https://192.168.101.23:2380
--initial-cluster-state new
--data-dir=/var/lib/etcd
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.target
Recarga la configuración del gestor de systemd para que recoja los cambios del sistema de archivos y regenere los árboles de dependencias.
# systemctl daemon-reload
Haz que etcd se inicie al arrancar el sistema.
# systemctl enable etcd
Inicia etcd. # systemctl start etcd
Realiza las mismas acciones en el segundo nodo maestro ( docker-nakivo22 – 192.168.101.21 y docker-nakivo23 – 192.168.101.22 ). La única diferencia en las acciones necesarias para estos nodos maestros radica en editar el etcd.service archivo de configuración. Define las direcciones IP correctas para cada uno de los demás nodos maestros. Por ejemplo, el etcd.service archivo de configuración debe ser el siguiente para el segundo nodo maestro ( 192.168.101.22 ) del laboratorio de pruebas de Kubernetes actual.
[Unit]
Description=etcd
Documentation=https://github.com/coreos
[Service]
ExecStart=/usr/local/bin/etcd
--name 192.168.101.22
--cert-file=/etc/etcd/kubernetes.pem
--key-file=/etc/etcd/kubernetes-key.pem
--peer-cert-file=/etc/etcd/kubernetes.pem
--peer-key-file=/etc/etcd/kubernetes-key.pem
--trusted-ca-file=/etc/etcd/ca.pem
--peer-trusted-ca-file=/etc/etcd/ca.pem
--peer-client-cert-auth
--client-cert-auth
--initial-advertise-peer-urls https://192.168.101.22:2380
--listen-peer-urls https://192.168.101.22:2380
--listen-client-urls https://192.168.101.22:2379,http://127.0.0.1:2379
--advertise-client-urls https://192.168.101.22:2379
--initial-cluster-token etcd-cluster-0
--initial-cluster 192.168.101.21=https://192.168.101.21:2380,192.168.101.22=https://192.168.101.22:2380,192.168.101.23=https://192.168.101.23:2380
--initial-cluster-state new
--data-dir=/var/lib/etcd
Restart=on-failure
RestartSec=5
[Install]
WantedBy=multi-user.target
Inicialización de los nodos maestros en el clúster de alta disponibilidad de Kubernetes
Ahora puede inicializar los nodos maestros de su clúster de alta disponibilidad de Kubernetes instalado en máquinas Ubuntu.
Inicialización del nodo maestro 192.168.101.21
En el primer nodo maestro, realice las operaciones que se explican a continuación.
Cree el archivo de configuración YAML para kubeadm.
# vim config.yaml
Añada los parámetros de configuración a este archivo:
apiVersion: kubeadm.k8s.io/v1alpha3
kind: ClusterConfiguration
kubernetesVersion: stable
apiServerCertSANs:
- 192.168.101.19
controlPlaneEndpoint: "192.168.101.19:6443"
etcd:
external:
endpoints:
- https://192.168.101.21:2379
- https://192.168.101.22:2379
- https://192.168.101.23:2379
caFile: /etc/etcd/ca.pem
certFile: /etc/etcd/kubernetes.pem
keyFile: /etc/etcd/kubernetes-key.pem
networking:
podSubnet: 10.244.0.0/16
apiServerExtraArgs:
apiserver-count: "3"
La red definida como podSubnet (10.244.0.0/16) debe ser la misma que la del archivo kube-flannel.yml
Inicialice la máquina Ubuntu como nodo maestro.
# kubeadm init --config=config.yaml
A veces puede aparecer una advertencia sobre la versión antigua de un archivo de configuración:
Su archivo de configuración utiliza una especificación de API obsoleta: «kubeadm.k8s.io/v1alpha3». Utilice «kubeadm config migrate –old-config old.yaml –new-config new.yaml», lo que generará una nueva especificación similar utilizando una versión más reciente de la API.
Actualice la versión del archivo de configuración con el comando:
# kubeadm config migrate --old-config config.yaml --new-config config1.yaml
Puede producirse otro error al inicializar un nodo de un clúster de Kubernetes multimaster si etcd no está ejecutándose:
[ERROR ExternalEtcdVersion]: Obtener https://192.168.101.21:2379/versión: dial tcp 192.168.101.21:2379: conexión rechazada
Comprueba si tu etcd está ejecutándose. Puede ejecutar etcd manualmente:
# systemctl start etcd
Después de la inicialización correcta del nodo maestro en el clúster de Kubernetes que se ejecuta en Ubuntu, aparecerá el siguiente mensaje, tal y como se muestra en la captura de pantalla. 
El resultado de la ejecución correcta de este comando incluye un consejo sobre cómo empezar a utilizar tu clúster, así como los comandos que contienen el token y el hash del certificado necesarios para añadir nodos al clúster. Guarda estas cadenas de caracteres importantes, ya que las necesitarás en breve. Están marcadas en amarillo en la captura de pantalla y se reproducen a continuación.
Ahora puede incorporar cualquier número de nodos del plano de control copiando las autoridades de certificación
y las claves de las cuentas de servicio en cada nodo, y a continuación ejecutando lo siguiente como usuario root:
kubeadm join 192.168.101.19:6443 --token sxm34y.p4rn4328vne0iihf
--discovery-token-ca-cert-hash sha256:bf3887f1565fcd48ff696da98a761ac1b70c6d38ba0ba3e4b1bf573000a302ca
--experimental-control-plane
A continuación, puede incorporar cualquier número de nodos de trabajo ejecutando lo siguiente en cada uno de ellos como usuario root:
kubeadm join 192.168.101.19:6443 --token sxm34y.p4rn4328vne0iihf
--discovery-token-ca-cert-hash sha256:bf3887f1565fcd48ff696da98a761ac1b70c6d38ba0ba3e4b1bf573000a302ca
Ejecute los comandos para empezar a utilizar el nodo inicializado en el clúster.
# mkdir -p $HOME/.kube
# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
# sudo chown $(id -u):$(id -g) $HOME/.kube/config
Compruebe los nodos añadidos al clúster.
# kubectl get nodes
Copia los certificados a los otros dos nodos maestros
# scp -r /etc/kubernetes/pki kubernetes-user@192.168.101.22:~
# scp -r /etc/kubernetes/pki kubernetes-user@192.168.101.23:~
Inicializando el nodo maestro 192.168.101.22
Ejecuta los comandos en el segundo nodo maestro (192.168.101.22).
Elimine los archivos apiserver.crt y apiserver.key que se encuentran en el directorio de inicio (~) del usuario kubernetes-user .
$ rm ~/pki/apiserver.*
Mueve los certificados almacenados en el directorio de inicio al directorio /etc/kubernetes/ .
$ sudo mv ~/pki /etc/kubernetes/
Crea el archivo YAML de configuración para kubeadm.
# vim config.yaml
El contenido de este archivo YAML es el mismo que el del primer nodo maestro ( 192.168.101.21 ). Consulta la configuración para la inicialización del primer nodo maestro más arriba. Puede copiar el archivo ya creado que se utilizó en el primer nodo maestro del clúster de alta disponibilidad (HA) de Kubernetes instalado en sus máquinas Ubuntu.
Inicialice el segundo nodo maestro.
# kubeadm config migrate --old-config config.yaml --new-config config1.yaml
# kubeadm init --config=config1.yaml
La salida es la misma que la que se mostró después de la inicialización del primer nodo maestro en el clúster de alta disponibilidad (HA) de Kubernetes:
Del mismo modo, ejecute los comandos para empezar a utilizar el nodo inicializado en el clúster.
# mkdir -p $HOME/.kube
# sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
# sudo chown $(id -u):$(id -g) $HOME/.kube/config
Compruebe los nodos añadidos al clúster.
# kubectl get nodes
Se han añadido al clúster dos de los tres nodos maestros. Queda por añadir un nodo maestro.
Inicializando el tercer nodo maestro (192.168.101.23)
Repite los mismos pasos que has seguido para inicializar el segundo nodo (192.168.101.22) del clúster. No olvides anotar los comandos con el token y los hash para añadir nodos al clúster que se muestran después de la inicialización del nodo maestro.
Comprueba que los tres nodos maestros se hayan añadido correctamente al clúster.
# kubectl get nodes
Instalación de Flannel para solucionar el estado «NotReady» de los nodos maestros en Kubernetes
Vamos a instalar Flannel. A diferencia del primer ejemplo, en el que aprendiste a instalar Kubernetes en Ubuntu para crear un clúster con un único nodo maestro, en este ejemplo se instalará Flannel utilizando el archivo YAML.
Ejecuta el comando para instalar Flannel y corregir el estado «NotReady» de los nodos que se muestra, ya que aún no hay ninguna red superpuesta configurada. Crea el kube-flannel.yaml archivo con el editor de texto vim, por ejemplo, en el primer nodo maestro.
# kubectl apply -f kube-flannel.yml
Recuerda la dirección de la podSubnet definida en el archivo config.yaml . La dirección de red debe ser la misma en el archivo kube-flannel.yaml .
Comprueba tus nodos y su estado.
# kubectl get nodes
Ahora todos los nodos maestros funcionan correctamente.
Añadir nodos de trabajo al clúster
Una vez que hayas inicializado todos los nodos maestros, puedes añadir nodos de trabajo a tu clúster de Kubernetes. Añadamos el primer nodo de trabajo ( 192.168.101.31 ) al clúster de Kubernetes de alta disponibilidad (HA) instalado en máquinas Ubuntu. Utiliza el comando que se mostró después de la inicialización de los nodos maestros (el comando que contiene el token y el hash) para que el nodo de trabajo se incorpore al clúster. Ejecuta el comando en la máquina 192.168.101.31 .
# kubeadm join 192.168.101.19:6443 --token kxl1gf.6ddalutd60n0ez45
--discovery-token-ca-cert-hash sha256:bf3887f1565fcd48ff696da98a761ac1b70c6d38ba0ba3e4b1bf573000a302ca
Comprueba los nodos del clúster de alta disponibilidad de Kubernetes para asegurarte de que se ha añadido el nodo de trabajo. Ahora también podrás ver la máquina del proxy de alta disponibilidad en la lista de nodos.
# kubectl get nodes
Del mismo modo, añade otros nodos de trabajo al clúster de alta disponibilidad de Kubernetes instalado en máquinas Ubuntu. Puedes añadir más nodos de trabajo en cualquier momento en función de tus necesidades. En este punto, el tutorial de hoy ha finalizado.
Conclusión
Instalar Kubernetes en Ubuntu no es tan difícil como puede parecer a primera vista. Hay que dedicar cierto esfuerzo a la instalación del clúster de Kubernetes, pero, a cambio, se obtienen numerosas ventajas, como una gestión centralizada más sencilla, una alta ampliabilidad y el equilibrio de carga. El tipo más sencillo de instalación de Kubernetes es la de un solo nodo maestro: debes instalar Kubernetes en los nodos de Ubuntu, incluidos los nodos maestros y de trabajo. Si necesitas una infraestructura más fiable para ejecutar aplicaciones en contenedores, plantéate instalar un Kubernetes multimaster, conocido como clúster de alta disponibilidad de Kubernetes. Este tipo de instalación de Kubernetes elimina los puntos únicos de fallo, y tu clúster podrá seguir funcionando aunque fallen algunos de los nodos maestros.
Para ambos tipos de instalación, debes configurar el acceso SSH, establecer direcciones IP estáticas y nombres de host, instalar Docker, desactivar el uso de la partición swap y, por último, instalar los componentes de Kubernetes, como kubeadm, kubectl y kubelet, así como configurar Flannel para las redes superpuestas. En el caso de instalar el clúster de Kubernetes de alta disponibilidad, también debes configurar el proxy de alta disponibilidad en una máquina independiente, generar certificados y configurar el clúster de etcd. La mayoría de las etapas de configuración de Kubernetes, la creación de instalaciones y la ejecución de pods pueden realizarse mediante dos métodos: ejecutando manualmente los comandos proporcionados por la interfaz de línea de comandos y utilizando archivos de configuración YAML. El uso de archivos YAML permite crear estructuras más complejas y facilita el proceso de administración.
Puede instalar Kubernetes en Ubuntu, tanto en máquinas físicas como en máquinas virtuales. Si su Kubernetes está instalado en máquinas virtuales que se ejecutan en vSphere, puede aplicar una protección adicional utilizando Clúster de alta disponibilidad de VMware con la función Fault Tolerance. La lógica de la instalación de Kubernetes que se analiza en esta entrada del blog también puede utilizarse para instalar Kubernetes en otras distribuciones de Linux.
