Cómo instalar Kubernetes en Ubuntu
El despliegue manual de contenedores Docker en múltiples servidores puede consumir mucho tiempo, monopolizando la agenda de cualquier administrador de sistemas encargado de la tarea. En la industria moderna de TI, la popularidad de las nubes, los microservicios y los contenedores sigue creciendo, y por esta razón se desarrollaron soluciones como Kubernetes.
Kubernetes es una solución de gestión y orquestación de contenedores de código abierto que permite crear un clúster para facilitar el despliegue de contenedores en entornos distribuidos y proporcionar alta disponibilidad a las aplicaciones en contenedores. El objetivo de esta entrada de blog es explorar 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 Kubernetes consta de nodos maestros y nodos trabajadores. La configuración del hardware depende de sus necesidades y de las aplicaciones que tenga previsto ejecutar en contenedores Docker. Los requisitos mínimos de hardware para instalar Kubernetes en Ubuntu son:
- Al menos una CPU x86/x64 de 2 núcleos (unidad central de procesamiento)
- 2 GB de RAM (memoria de acceso aleatorio) o más
- Acceso a Internet
Puertos que deben abrirse para instalar Kubernetes en Ubuntu:
| Protocolo & rango de puertos | Fuente | Propósito | Dirección |
| TCP 443 | Nodos de trabajo, usuarios finales, solicitudes API | Servidor API Kubernetes | Nodo maestro entrante |
| TCP 10250 | Nodos maestros | Nodo trabajador Puerto de comprobación de salud de Kubelet | Nodo trabajador entrante |
| TCP 30000-32767 | Clientes de aplicaciones externas | Rango de puertos por defecto para proporcionar servicios externos | |
| UDP 8285 | Nodos de trabajo | UDP backend de la red superpuesta Flannel | |
| UDP 8472 | Nodos de trabajo | VXLAN backend de la red superpuesta Flannel | |
| TCP 179 | Nodos de trabajo | Requerido sólo si se utiliza la red Calico BGP | |
| TCP 2379-2380 | Nodos maestros | API de cliente de servidor etcd | nodo etcd de entrada |
| TCP 2379-2380 | Nodos de trabajo | API de cliente de servidor etcd necesaria si se utiliza Flannel de Calico |
Por defecto, el cortafuegos iptables está instalado en Ubuntu, pero no hay ninguna regla de bloqueo «out of the box». Por lo tanto, si está instalando Ubuntu para probar Kubernetes, no necesita editar las reglas del cortafuegos. Kube-proxy coloca sus cadenas iptables primero, y luego inserta dos reglas iptables. Estas reglas son KUBE-EXTERNAL-SERVICES y KUBE-FIREWALL que se insertan en la parte superior de la cadena INPUT.
La instalación de Kubernetes en Ubuntu puede realizarse tanto en máquinas físicas como virtuales. La recomendación general es utilizar la última versión de Ubuntu Linux de 64 bits. La entrada del blog de hoy explica la instalación de Kubernetes en Ubuntu 18.04 LTS que se ejecuta en VMware VMs. El primer tipo de despliegue de Kubernetes explicado es con un nodo maestro, y se utilizan dos nodos trabajadores para el clúster de Kubernetes. Consulte la tabla siguiente para ver los números condicionales de los nodos, los roles de los nodos, los nombres de host y las direcciones IP de las máquinas utilizadas en el ejemplo considerado.
| № | Nodo Rol | 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 |
Puede utilizar VMs que se ejecuten en hosts ESXi si utiliza VMware vSphere, o puede ejecutar VMs en VMware Workstation instalada en su ordenador personal con Linux o Windows. En el ejemplo de hoy utilizaremos máquinas virtuales que se ejecutan en VMware Workstation. Las máquinas virtuales utilizan la red NAT con acceso a Internet, y si prefieres VirtualBox a VMware, puedes utilizarlo.
La dirección IP de la máquina anfitriona: 10.10.10. 53
La dirección IP de la pasarela virtual para la red NAT (VMNet8): 192.168.101.2
El mismo usuario Linux existe en todas las máquinas Ubuntu: kubernetes-user
Configuración de la VM: 2CPU, 4GB RAM, 20-GB disco virtual
Puede cambiar las direcciones IP de la VMnet8 yendo a Edit > Virtual Network Editor en VMware Workstation.
Para una mejor comprensión, todos los componentes se instalarán en Linux manualmente sin herramientas de automatización como Ansible en el ejemplo de hoy.
Despliegue de la máquina virtual de Ubuntu
Cree una nueva VM llamada docker-nakivo21.
Instale Ubuntu 64-bit en la primera máquina, y establezca el nombre de host y el nombre de usuario.
Nombre de la máquina virtual: docker-nakivo21
Nombre de usuario: kubernetes-user
Instale VMware Tools después del primer inicio de sesión en el sistema operativo instalado. Si utiliza máquinas físicas, no necesita utilizar VMware Tools y puede omitir este paso.
Nota: El carácter $ al principio significa que un comando se ejecuta como un usuario normal(kubernetes-user en este caso). Si la cadena comienza con el carácter #, el comando debe ejecutarse como root. El comando sudo (usuario sustituto do o superusuario do) le permite ejecutar comandos como otro usuario, incluido root. Puede escribir sudo -i para obtener los privilegios de root en la consola. Pulsa Ctrl+D para salir del modo raíz.
Puede instalar VMware Tools desde la imagen ISO suministrada con el hipervisor VMware o desde repositorios Linux (se explica más adelante).
$ sudo apt-get install open-vm-tools
Si necesita una experiencia de escritorio avanzada como portapapeles compartido, drug & drop files etc., ejecute:
$ sudo apt-get install open-vm-tools-desktop
Reinicia la máquina virtual.
$ init 6
Configure su máquina Ubuntu antes de instalar Kubernetes
Es necesario realizar algunos preparativos antes de instalar Kubernetes en máquinas Ubuntu. En primer lugar, debe configurar la dirección IP estática y el nombre de host para cualquier servidor habitual.
Configurar la dirección IP estática
Como para cualquier otro tipo de clúster, es muy recomendable utilizar direcciones IP estáticas en los nodos.
Instale las herramientas de red de Linux antes de configurar la dirección IP.
$ sudo apt-get install net-tools
Escriba ifconfig para comprobar la dirección IP actual de tu Ubuntu VM.
Puede ver que la dirección IP se obtiene automáticamente mediante DHCP. Recuerde 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 para las máquinas físicas.
Necesita un editor de texto para editar los archivos de configuración. Instale vim como editor de texto.
$ sudo apt-get install vim
En las últimas versiones de Ubuntu, la configuración de red se establece en el archivo yaml. Abra el archivo yaml de configuración de red en vim.
$ sudo vim /etc/netplan/01-network-manager-all.yaml
La vista por defecto del fichero de configuración es:
Edite este archivo de configuración de red 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]
Guarde los cambios y salga.
:wq
$ sudo netplan try
Pulse ENTER para aceptar la nueva configuración.
Comprueba si se ha modificado la configuración de tu 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 para la primera VM que es docker-nakivo21 ya ha sido configurado durante la instalación. Para cambiar el nombre de host, haga lo siguiente (esto será necesario para configurar la segunda y tercera máquinas virtuales después de la clonación. Esas dos VMs están pensadas para ser configuradas como nodos trabajadores):
Por ejemplo, si necesita cambiar el nombre de host a docker-nakivo21 en la primera VM, ejecute:
$ sudo hostnamectl set-hostname docker-nakivo21
Compruebe que se aplica un nuevo nombre de host.
$ less /etc/hostname
Edite el archivo hosts.
$ sudo vim /etc/hosts
El contenido del archivo del host debe tener este aspecto
127.0.0.1 localhost
127.0.1.1 docker-nakivo21
Reinicie la máquina.
$ init 6
Desactivar un archivo swap
El uso de un archivo de intercambio (partición de intercambio) no es compatible con Kubernetes y la desactivación de swappiness es necesario instalar Kubernetes en Ubuntu con éxito.
Desactivar un archivo de intercambio para evitar que kubelet alto uso de la CPU.
$ sudo swapoff -a
Edite /etc/fstab y comente la cadena 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
Desactivar swap en sysctl.conf
$ sudo echo "vm.swappiness=0" | sudo tee --append /etc/sysctl.conf
Donde 0 es el porcentaje de swap. En este caso, la swap sólo se puede utilizar si te quedas sin RAM (por defecto, la swap se utiliza cuando más del 60% de la RAM está llena).
Aplicar los cambios de configuración sin reiniciar.
$ sudo sysctl -p
Nota: Si la partición de intercambio no está deshabilitada, el proceso kswapd0 de Ubuntu Linux que ejecuta Kubernetes puede consumir una gran cantidad de recursos de CPU en su máquina, provocando que las aplicaciones no respondan y que el sistema se cuelgue. Esto ocurre cuando el sistema operativo se queda sin memoria, y las páginas de memoria antiguas son movidas a swap por un proceso del sistema del núcleo de Linux. Por extrañas razones, a veces las cosas salen mal y se produce un bucle interminable que consume todos los recursos de la CPU. En la siguiente captura de pantalla, se observa un alto consumo de CPU por parte del proceso kswapd0 cuando Kubernetes está instalado en Ubuntu. El valor medio de la carga es excesivamente alto.
Si kswapd0 sigue sobrecargando su CPU, ejecute el siguiente comando para invalidar todos los casquillos de memoria y detener kswapd0 (ejecútelo como root).
# echo 1 > /proc/sys/vm/drop_caches
Apague la máquina virtual.
$ init 0
Esta máquina virtual parcialmente configurada(docker-nakivo21) está a punto de ser utilizada como nodo maestro. Cree dos máquinas que se utilizarán como nodos de trabajo. Si utiliza máquinas físicas, repita los pasos anteriores manualmente (o utilice herramientas de automatización como Ansible para configurar varias máquinas Linux simultáneamente mediante SSH). Como en el ejemplo actual se utilizan máquinas virtuales, se pueden clonar para ahorrar tiempo durante la preparación del entorno para la instalación de Kubernetes en máquinas Ubuntu.
Clonar la máquina virtual
Clona tu primera máquina virtual. Si utiliza VMware ESXi, puede utilizar la función de clonación incorporada. Puede obtener más información sobre este tema leyendo nuestra entrada de blog sobre la clonación de máquinas virtuales mediante plantillas de máquinas virtuales. Si utiliza VMware Workstation, también puede clonar VMs utilizando dos métodos (herramienta de clonación integrada y manualmente). Puede hacer clic en VM > Manage > Clone para crear un clon vinculado. Vamos a crear un clon completo de la primera VM y copiar manualmente los archivos de la VM. En este caso, los archivos se copian del directorio docker-nakivo21 a docker-nakivo31. Los directorios deben crearse manualmente antes de copiar los archivos VM.
Edite el archivo VMX, ya que el nombre de la VM y la ruta al archivo del disco virtual se han modificado.
displayName = "docker-nakivo31"
scsi0:0.fileName = "C:\Virtual\KUBERNETES\docker-nakivo31\docker-nakivo31.vmdk"
nvram = "docker-nakivo31.nvram"
La máquina virtual que se utilizará como primer nodo trabajador ya está creada. Clone la primera VM una vez más, para preparar el segundo nodo trabajador del clúster Kubernetes.
Edite el archivo VMX para la tercera VM (el segundo nodo trabajador), como ha hecho anteriormente.
displayName = "docker-nakivo32"
scsi0:0.fileName = "C:\Virtual\KUBERNETES\docker-nakivo31\docker-nakivo32.vmdk"
nvram = "docker-nakivo32.nvram"
Abra los clones de la VM en VMware Workstation (File> Open y seleccione el archivo VMX de la VM), o simplemente haga doble clic en el archivo VMX de la VM. Encienda tres máquinas virtuales (su VM de origen y dos clones de VM). 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 clonación de VM una vez que se hayan clonado las VM. Si utiliza máquinas físicas, siga todos los pasos anteriores según las direcciones IP y los nombres de host de cada máquina.
Configuración de direcciones IP y nombres de host en máquinas virtuales
Cambie la dirección IP y el nombre de host en las máquinas virtuales docker-nakivo31 y docker-nakivo32 (como se muestra arriba).
Repita 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 según corresponda en los nodos trabajadores.
Todas las máquinas deben estar configuradas para resolver los nombres de host de los nodos en direcciones IP. Puede configurar un servidor DNS o editar manualmente el archivo hosts de cada máquina. Vamos a editar anfitriones.
Añada las siguientes cadenas al archivo hosts de cada máquina(docker-nakivo21, docker-nakivo31, docker-nakivo32).
$ sudo vim /etc/hosts
Añada estas líneas al archivo hosts:
192.168.101.21 docker-nakivo21
192.168.101.31 docker-nakivo31
192.168.101.32 docker-nakivo32
Haga ping a otros hosts desde cada uno de ellos para asegurarse de que los nombres de host están resueltos:
$ ping docker-nakivo21
$ ping docker-nakivo31
$ ping docker-nakivo32
Configurar el acceso SSH en todos los hosts (máquinas virtuales)
Configure el acceso SSH en todos los hosts. Instale el servidor OpenSSH ejecutando los comandos en cada máquina.
$ sudo apt-get install openssh-server
Vaya al directorio principal de kubernetes-user y genere 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 pueden utilizarse para acceder a la consola Linux remota a través de SSH sin utilizar contraseñas. La clave pública puede copiarse en una máquina desde la que necesites conectarte remotamente, mientras que la clave privada es altamente secreta y debe almacenarse en la máquina a la que necesites conectarte.
$ ssh-keygen
No es necesario introducir la contraseña para generar la clave (la contraseña es opcional).
Copiar las claves a otras máquinas Ubuntu:
$ ssh-copy-id kubernetes-user@192.168.101.31
$ ssh-copy-id kubernetes-user@192.168.101.32
Introduzca su contraseña de usuario para confirmar la copia de las claves.
Intente conectarse a la segunda máquina(docker-nakivo31) como kubernetes-user (es decir, un usuario normal).
$ ssh 'kubernetes-user@192.168.101.31'
A continuación, pruebe la conexión con la tercera máquina(docker-nakivo32).
$ ssh 'kubernetes-user@192.168.101.32'
Verá el nombre de la máquina remota en el símbolo del sistema de su consola después de una conexión exitosa.
Pulse Ctrl+D para salir de la consola remota.
¿Cómo copio la clave para conectarme por SSH como usuario root?
Como necesitará privilegios de root en Kubernetes, vamos a crear claves para configurar el acceso SSH para root. Ejecute los siguientes comandos en todas las máquinas (docker-nakivo21, docker-nakivo31 y docker-nakivo32) a las que necesite acceder a través de SSH como usuario root.
$ sudo -i
Edite el archivo de configuración del servidor SSH.
# vim /etc/ssh/sshd_config
Añade/edita la siguiente cadena a este archivo.
PermitRootLogin yes
Reinicie el demonio del servidor SSH.
# /etc/init.d/ssh stop
# /etc/init.d/ssh start
Establezca la contraseña root (contraseña para el usuario root).
# passwd
$ cd /home/kubernetes-user/
$ sudo ssh-keygen -t rsa
Copie 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 home del usuario habitual 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 su clave está guardada en el directorio personal del usuario root, copie la clave con este comando:
# ssh-copy-id -i /root/.ssh/id_rsa.pub 127.0.0.1
Confirme esta operación e introduzca su clave.
Repita la acción, copiando la clave de cada máquina a otras máquinas. Por ejemplo, en la máquina docker-nakivo21 ejecute:
# 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
Autorizar la clave pública.
# cat /root/.ssh/id_rsa.pub >> /root/.ssh/authorized_keys
Compruebe si puede iniciar sesión como root a través de SSH en la máquina local.
$ sudo ssh root@127.0.0.1
Intenta conectarte desde/a la máquina remota sin introducir 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 ser inseguro. No se conecte como root si no es necesario; es mejor conectarse por SSH como un usuario normal y utilizar el comando sudo comando.
Instalación de Docker
Docker es la plataforma de contenedores de aplicaciones empresariales más popular compatible con Kubernetes. Instale 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, puedes instalar Docker simplemente utilizando el comando habitual:
$ sudo apt-get install -y docker.io
Aún así, en este caso, la versión de Docker utilizada puede no ser la última. Vamos a remediarlo instalando la última versión de Docker.
En primer lugar, instale los paquetes necesarios.
$ sudo apt-get install apt-transport-https ca-certificates curl software-properties-common
Curl es una herramienta universal compacta diseñada para transferir datos desde/a un host sin interacció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 para el 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 tu base de datos del gestor de paquetes después de haber realizado los cambios manuales con el comando anterior.
$ sudo apt-get update
Comprueba la versión del paquete Docker disponible en el repositorio oficial.
$ apt-cache policy docker-ce
Instalar Docker.
$ sudo apt-get install docker-ce
Puede comprobar la versión de Docker después de la instalación.
$ docker --version
En este caso la salida es: Docker versión 18.09.6, build 481bc77.
Inicie Docker y haga que su demonio se cargue automáticamente al arrancar el sistema.
$ sudo systemctl start docker
$ sudo systemctl enable docker
Una vez que haya instalado Docker en todas las máquinas, puede ir directamente al paso de instalación de Kubernetes en Ubuntu.
Instalación de Kubernetes en Ubuntu e inicialización del clúster
Ahora, nada le impide instalar los componentes principales de Kubernetes.
Ejecute los comandos como root en todas las máquinas que se incluirán 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, puede 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.
Actualice la lista de paquetes de los repositorios disponibles en su sistema Ubuntu.
# apt-get update
Instalar kubectl, kubeadm y kubectl es crucial para instalar Kubernetes en Ubuntu.
# apt-get install -y kubelet kubeadm kubectl
Instalar keepalived.
# apt-get install keepalived
# systemctl enable keepalived && systemctl start keepalived
Verificar si el valor es 1 para el correcto funcionamiento de Kubernetes instalado en Ubuntu.
# sysctl net.bridge.bridge-nf-call-iptables
Para establecer este valor en 1 ejecute el comando:
sysctl net.bridge.bridge-nf-call-iptables=1
Edite el archivo de configuración kubeadm.
# vim /etc/systemd/system/kubelet.service.d/10-kubeadm.conf
Añade la cadena después de la cadena de Entorno existente:
Environment=”cgroup-driver=systemd/cgroup-driver=cgroupfs”
Los Cgroups son los grupos de control que aíslan el uso de recursos como procesador, memoria, entrada/salida de disco, red.
En el nodo maestro(docker-nakivo21) ejecute el comando para inicializar el clúster 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 requerido por el controlador Flannel. CIDR (Classless Inter-Domain Routing) define la dirección de su 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 la misma.
–apiserver-advertise-address=192.168.101.21 define la dirección IP que será anunciada por Kubernetes como su servidor API.
Lea la salida y guarde los comandos que aparecen al final del texto. Este es un punto importante. El token generado es necesario para añadir nodos trabajadores al clúster Kubernetes.
Ejecute los siguientes comandos como un usuario que ha ejecutado kubeadm init. En este caso, los comandos se ejecutan como 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 ejecuta estos comandos, Kubernetes devolverá el error: La conexión al servidor localhost:8080 fue rechazada – ¿especificó el host o puerto correcto?
Kubernetes no copia este archivo de configuración en el directorio de usuario automáticamente. Deberá realizar esta operación manualmente.
Compruebe los nodos añadidos al clúster
# kubectl get nodes
Puede ver un nodo maestro que tiene el estado NotReady en el clúster Kubernetes que se está instalando en Ubuntu. Esto se debe a que no se ha configurado la red superpuesta. Configure Flannel para corregir el estado NotReady del nodo maestro de Kubernetes. Cree el directorio para almacenar los archivos yaml para Docker y Kunernetes, por ejemplo /home/kubernetes-user/kubernetes/
YAML (Yet Another Markup Language) le ofrece una mayor comodidad a la hora de crear pods y despliegues en Kubernetes. Puede definir todos los parámetros de los contenedores que deben desplegarse 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.
Cree el archivo de configuración yaml con el siguiente contenido:
Ejecute el comando
# kubectl apply -f ./kube-flannel.yml
Como alternativa, puede encontrar ejemplos gratuitos preparados de configuraciones de despliegue 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 Kubernetes que estás desplegando en Ubuntu:
# kubectl get nodes
El estado del nodo maestro ahora es Listo.
Asegúrese de que Flannel se ha configurado correctamente:
# kubectl get pods --all-namespaces
Puede ver que la vaina de franela está funcionando. Este pod consta de dos contenedores – el demonio Flannel, y initContainer utilizado para desplegar la configuración CNI a una ubicación legible para Kubernetes.
A veces, al instalar Kubernetes en Ubuntu, puede producirse el siguiente error:
No se puede conectar con el servidor: net/http: TLS handshake timeout.
¿Cómo se puede solucionar este problema? Espere unos segundos e inténtelo de nuevo, suele ser suficiente.
Los espacios de nombres son entidades lógicas en el clúster Kubernetes que representan recursos de 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. Puede obtener la lista de espacios de nombres:
# kubectl get namespaces
Como recordarás, la unidad básica de despliegue en Kubernetes es un pod, que es una colección de contenedores que comparten red y espacio de nombres de montaje. Todos los contenedores del pod se programan en el mismo nodo Kubernetes. Comprueba los pods disponibles:
# kubectl -n kube-system get pods
Si desea reiniciar/parar el cluster, ejecute:
# kubeadm reset
Todo es OK en el nodo maestro. Esto significa que ahora puede seguir instalando Kubernetes en Ubuntu y pasar a añadir nodos trabajadores al clúster.
En los nodos trabajadores( 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 tras la inicialización del clúster con el comando kubeadm init como recordarás.
En el nodo maestro, compruebe de nuevo el estado del clúster.
# kubectl get nodes
Ahora puedes ver un nodo maestro y dos nodos trabajadores en el clúster Kubernetes ejecutándose en máquinas Ubuntu.
Puede comprobar la configuración de Kubernetes:
# kubectl cluster-info
Instalación de un Pod en Kubernetes
Ahora puede desplegar un pod con contenedores en su clúster Kubernetes. Como recordarás, los contenedores se incluyen en pods en Kubernetes. Si utiliza archivos yaml, cree un directorio para almacenar esos archivos para mayor comodidad. Vaya a ese directorio y ejecute los comandos como kubectl apply -f test.yaml
Dicho directorio ya ha sido creado al configurar Flannel – /home/kubernetes-user/kubernetes/
Es hora de desplegar un nuevo pod. Primero tienes que crear una instalación. La instalación es un concepto de controlador utilizado para proporcionar actualizaciones declarativas a pods y conjuntos de réplica. Puede crear la instalación con un solo comando o utilizando archivos yaml.
Ejemplo 1 – Instalación de MySQL
Vamos a crear un archivo yaml en este ejemplo. El nombre del archivo es mysql-deployment.yaml
Vea el archivo adjunto para ver la configuración.
# vim mysql-deployment.yaml
Hay dos enfoques populares para la gestión de recursos con kubectl. ¿Cuál es la diferencia entre kubectl create y kubectl apply? Cuando se utiliza kubectl create, se indica a Kubernetes lo que se desea crear, sustituir o eliminar; este comando sobrescribe todos los cambios. Alternativamente, kubectl apply realiza 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 su instalación.
# kubectl describe deployment mysql
Comprueba las vainas:
# kubectl get po
o
# kubectl get pods
o
# kubectl get pods -l app=mysql
Si ve el estado pendiente para el pod, puede significar que no hay suficientes recursos de computación. Intente añadir algo de CPU y capacidad de memoria para arreglar el estado pendiente del pod en Kubernetes.
Puede eliminar el servicio si es necesario:
# kubectl delete service <service_name>
También puede eliminar un pod:
# kubectl delete pod mysql-7b9b7999d8-nz5tm
Ejemplo 2 – Instalación de nginx
Vamos a desplegar nginx usando otro método sin archivos yaml.
Cree una instalación.
# kubectl create deployment nginx --image=nginx
Compruebe que se ha creado la instalación.
# kubectl get deployments
Crear 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 rango 30000-32767 para acceder a los servicios proporcionados. El tráfico que se envía a este puerto se reenvía al servicio necesario.
Compruebe que el servicio se ha creado y está a la escucha en el puerto definido.
# kubectl get svc
Recuerde el número de puerto (31453 en este caso).
Compruebe si su servicio está desplegado y disponible (en este ejemplo, el comando se ejecuta en el nodo maestro). Utilice el nombre de host del nodo y el puerto que ha recordado del paso anterior.
# curl docker-nakivo31:31453
También puedes comprobar que el servicio es accesible en el navegador de cualquier nodo. En la barra de direcciones del navegador web, intente visitar las páginas:
http:// 10.101.235.90
o
http://docker-nakivo31:31453
http://docker-nakivo32:31453
Si todo es OK, verá 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 Kubernetes(192.168.101.0/24) en este caso. Por ejemplo, puede visitar las páginas web con su navegador:
http://192.168.101.21:31453/
http://192.168.101.31:31453/
http://192.168.101.32:31453/
Configuración de la interfaz web para la supervisión de Kubernetes
La instalación de Kubernetes en Ubuntu es casi completa, pero también puede instalar Kubernetes dashboard para mayor comodidad. Kubernetes dashboard es una interfaz web para la gestión y supervisión de Kubernetes. Para instalar el dashboard, cree el archivo kubernetes-dashboard.yaml de la misma manera que lo ha hecho anteriormente antes de ejecutar los comandos.
# kubectl create -f ./kubernetes-dashboard.yaml
# kubectl apply -f ./kubernetes-dashboard.yaml
Comprobar vainas.
# kubectl get pods -o wide --all-namespaces
Inicie el proxy al servidor API de Kubernetes.
# kubectl proxy
Para introducir los siguientes comandos en la consola, abra otra ventana de consola. En caso contrario, el proceso se daría por finalizado.
En su navegador web en el nodo maestro, vaya a la página:
http://localhost:8001
Puede ver la página de prueba.
Introduzca 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/
Cree un cuadro de mandos 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:
Copie el código generado y péguelo en la sección de códigos de la interfaz web para iniciar sesión en el panel de control.
En la siguiente captura de pantalla, puede ver la interfaz web del panel de control de Kubernetes. Puede ver el estado de los nodos, las instalaciones y los pods, así como comprobar las funciones, las clases de almacenamiento y otros componentes.
Configurar Heapster la herramienta de supervisión
Instale Heapster para ampliar las opciones de supervisión del panel de control de Kubernetes añadiendo CPU, memoria y otros parámetros de supervisión. Cree un archivo de manifiesto cuyo nombre sea heapster.yaml.
# vim heapster.yaml
En la siguiente acción, despliegue 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
Compruebe que las métricas de CPU y memoria se pueden medir en la consola.
# kubectl top node
Ahora puede abrir la interfaz web de Kubernetes Dashboard y ver que se han añadido algunas secciones, incluidos los gráficos de uso de CPU y uso de memoria.
Su clúster Kubernetes ya está configurado y listo para funcionar.
Instalación de un clúster Kubernetes de alta disponibilidad con varios maestros en Ubuntu
Tener un clúster Kubernetes con un nodo maestro y un par de nodos trabajadores es una buena opción, pero a veces el único nodo maestro puede fallar por razones como problemas de hardware o pérdida de energía. Para una mayor tolerancia a fallos del clúster Kubernetes desplegado en nodos Ubuntu, es mejor considerar el despliegue del clúster Kubernetes de Alta Disponibilidad con múltiples nodos maestros. El uso de este modelo de instalación de clústeres 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 pueden proporcionar tolerancia a fallos es tres. Si utiliza 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 valor de la tolerancia a fallos en función del número de nodos maestros del clúster Kubernetes. Por ejemplo, si tienes un clúster con 5 nodos maestros, el clúster puede sobrevivir a un fallo de 2 nodos maestros porque tres nodos maestros siguen funcionando (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 del clúster.
| Tamaño del grupo | 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 |
Esta sección de la entrada del blog de hoy explora cómo instalar Kubernetes en nodos Ubuntu en el marco de la implementación de Kubernetes clúster de alta disponibilidad , HA proxy y algunos nodos de trabajo. En la siguiente tabla, puede ver las direcciones IP, los nombres de host y los roles de los hosts utilizados para instalar el clúster Kubernetes HA en nodos Ubuntu en el laboratorio de pruebas explicado en este ejemplo.
| № | Nodo Rol | 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 | Proxy HA | 192.168.101.19 | ha-proxy19 |
| 5 | Trabajador | 192.168.101.31 | docker-nakivo31 |
| 6 | Trabajador | 192.168.101.32 | docker-nakivo32 |
Algunos comandos son los mismos que para la instalación de Kubernetes en Ubuntu utilizando el modelo de un nodo maestro. Por este motivo, no se repiten los comentarios de algunos comandos. Puede desplazarse hacia arriba en esta página para recordar la explicación de los comandos.
Prepare todas las máquinas (proxy de HA, nodos maestros y nodos trabajadores) para instalar Kubernetes haciendo lo siguiente:
- Configurar direcciones IP estáticas.
- Configure los nombres de host. Los nombres de todos los hosts deben resolverse en direcciones IP.
- El acceso SSH debe habilitarse y configurarse mediante certificados.
- El intercambio debe estar desactivado.
Estos pasos deben llevarse a cabo antes de iniciar la instalación de Docker en cada máquina, muy parecido a lo que leíste en la sección anterior cuando se explicó la instalación de Kubernetes en Ubuntu utilizando un nodo maestro. Una vez que haya preparado todas las máquinas, vaya a(192.168.101.19).
Configuración del balanceador de carga proxy de HA
El balanceador de carga HA Proxy se utiliza para distribuir el tráfico de entrada entre los nodos Kubernetes. El equilibrador de carga se despliega delante de los nodos maestros. Abra la consola de la máquina ha-proxy19 y realice las acciones que se muestran a continuación.
Instalar cfssl
Cfssl (Cloud Flare SSL) es un conjunto de herramientas utilizado para generar diferentes certificados, incluidas las 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
Hacer ejecutables los archivos binarios descargados.
# 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
Verifique la instalación comprobando la versión del cfssl instalado.
# cfssl version
Actualizar el árbol de repositorios.
# apt-get update
Instalar proxy HA.
# apt-get install haproxy
Cree y edite el archivo haproxy.cfg.
# vim /etc/haproxy/haproxy.cfg
Añada 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
Generar certificados TSL
Puede seguir utilizando la consola del equipo proxy de HA. Cree el archivo de configuración de la autoridad de certificación, llamado ca-config.json.
# vim ca-config.json
Añada 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"
}
}
}
}
Crear el archivo de configuración de solicitud de firma de autoridad de certificación.
# vim ca-csr.json
Añada el contenido a este archivo como se muestra a continuación:
{
«CN»: «Kubernetes»,
«key»: {
«algo»: «rsa»,
«size»: 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 ciudad o pueblo.
O – organización.
OU – unidad de organización (por ejemplo, un departamento definido como propietario de claves).
ST – el estado o la provincia.
Ahora genere la clave privada.
# cfssl gencert -initca ca-csr.json | cfssljson -bare ca
Compruebe que se han generado las claves ca-key.pem y ca.pem.
# ls -al
Creación del certificado para el cluster Etcd
Etcd admite la comunicación de servidor a servidor/cluster mediante autenticación a través de certificados de cliente. Deberías tener un certificado CA y un par de claves firmadas para un miembro del cluster.
Cree 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"
}
]
}
A continuación, genere 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
Enumere los archivos de su directorio para comprobar que se han generado los archivos kubernetes-key.pem y kubernetes.pem.
# ls -al
Copie 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 un directorio de inicio de kubernetes-user en hosts Ubuntu.
Preparación de los nodos Ubuntu para la instalación de Kubernetes
Ejecute los comandos mostrados en esta sección en todos los nodos maestros y nodos trabajadores. Instale Docker y, a continuación, instale Kubernetes en los equipos Ubuntu que se incluirán en el clúster de Kubernetes. Empecemos por preparar el nodo maestro 192.168.101.21.
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. Cubeadm, kublet y cubectl son los componentes de Kubernetes necesarios para instalar Kubernetes en Ubuntu.
Instale los componentes de Kubernetes: kubeadm, kublet 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 haya preparado todos los nodos e instalado Docker, kubelet, kubeadm y kubectl, debe instalar y configurar etcd en los nodos maestros.
Instalación y configuración de etcd en nodos maestros de Ubuntu
Etcd es un almacén consistente y altamente disponible, pensado para almacenar claves así como para hacer backup de todos los datos del cluster. El clúster etcd debe configurarse antes de configurar el clúster Kubernetes HA con múltiples nodos maestros. Empecemos por configurar el nodo maestro 192.168.101.21.
Installing and configuring etcd on the 192.168.101.21 machine.
Crear un directorio de configuración para etcd.
# mkdir /etc/etcd /var/lib/etcd
Vaya al directorio en el que se han copiado los certificados. Este es el directorio raíz del usuario kubernetes, en este caso – /home/kubernetes-user/
Copie los certificados al directorio de configuración etcd.
# cp ca.pem kubernetes.pem kubernetes-key.pem /etc/etcd
Compruebe que los archivos se han copiado.
# ls -al /etc/etcd
Vuelva a su directorio anterior
# cd -
Descargue los binarios etcd del repositorio.
# wget https://github.com/coreos/etcd/releases/download/v3.3.9/etcd-v3.3.9-linux-amd64.tar.gz
Extraer el archivo etcd.
# tar xvzf etcd-v3.3.9-linux-amd64.tar.gz
Ahora mueve los archivos binarios etcd a /usr/local/bin/
# mv etcd-v3.3.9-linux-amd64/etcd* /usr/local/bin/
Crea un archivo de unidad systemd etcd.
# vim /etc/systemd/system/etcd.service
Añada a este archivo las cadenas que se muestran a continuación.
[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 systemd para tomar las configuraciones modificadas del sistema de archivos y regenerar los árboles de dependencias.
# systemctl daemon-reload
Hacer que etcd se inicie en el arranque.
# systemctl enable etcd
Iniciar etcd.
# systemctl start etcd
Realice 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 es en la edición del archivo de configuración etcd.service. Defina las direcciones IP correctas para cada otro nodo maestro. Por ejemplo, el archivo de configuración etcd. service 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 Kubernetes HA
Ahora puede inicializar los nodos maestros en su clúster Kubernetes HA instalado en máquinas Ubuntu.
Inicializando el nodo maestro 192.168.101.21
En el primer nodo maestro, realice las operaciones que se explican a continuación.
Crear el archivo de configuración yaml para kubeadm.
# vim config.yaml
Añade 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 en el archivo kube-flannel.yml.
Inicializa 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 fichero de configuración:
Su archivo de configuración utiliza una especificación de API obsoleta: «kubeadm.k8s.io/v1alpha3». Por favor, utilice ‘kubeadm config migrate –old-config old.yaml –new-config new.yaml’, que escribirá la 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 Kubernetes multimaestro si etcd no se está ejecutando:
[ERROR ExternalEtcdVersion]: Get https://192.168.101.21:2379/version: dial tcp 192.168.101.21:2379: connect: connection refused
Compruebe si su etcd está funcionando. Puede ejecutar etcd manualmente:
# systemctl start etcd
Después de la inicialización exitosa del nodo maestro en el clúster Kubernetes que se ejecuta en Ubuntu, se obtiene el siguiente mensaje como se muestra en la captura de pantalla.
La salida de la ejecución correcta de este comando contiene un consejo sobre cómo empezar a utilizar su clúster, así como comandos que contienen un token y un hash de certificado necesarios para unir nodos al clúster. Guarde estos importantes hilos porque los necesitará pronto. Están marcados con el color amarillo en la captura de pantalla y se duplican a continuación.
Ahora puede unir cualquier número de nodos del plano de control copiando las autoridades de certificación
y las claves de cuenta de servicio en cada nodo, y luego ejecutar lo siguiente como 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 unirse a cualquier número de nodos trabajadores ejecutando lo siguiente en cada uno como 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
Ejecute los comandos en el segundo nodo maestro (192.168.101.22).
Elimine apiserver.crt y apiserver. key que se encuentran en el directorio principal(~) del usuario de kubernetes.
$ rm ~/pki/apiserver.*
Mueva los certificados almacenados en el directorio home al directorio /etc/kubernetes/.
$ sudo mv ~/pki /etc/kubernetes/
Cree el archivo yaml de configuración para kubeadm.
# vim config.yaml
El contenido de este archivo yaml es el mismo que para el primer nodo maestro(192.168.101.21). Véase más arriba la configuración para la inicialización del primer nodo maestro. Puede copiar el archivo ya creado utilizado en el primer nodo maestro del clúster Kubernetes HA instalado en sus máquinas Ubuntu.
Inicializa 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 mostrada tras la primera inicialización del nodo maestro en el clúster Kubernetes HA:
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 nodos maestros de un total de tres. Queda un nodo maestro por añadir.
Inicializando el tercer nodo maestro (192.168.101.23)
Repita los mismos pasos que ha seguido para inicializar el segundo nodo (192.168.101.22) del clúster.
No olvide anotar los comandos con token y hashes para añadir nodos al cluster que se muestran tras la inicialización del nodo maestro.
Compruebe que los tres nodos maestros se han añadido correctamente al clúster.
# kubectl get nodes
Instalación de Flannel para corregir el estado NotReady de los nodos maestros en Kubernetes
Vamos a instalar Franela. A diferencia del primer ejemplo en el que aprendió a instalar Kubernetes en Ubuntu para crear un clúster maestro único, en este ejemplo Flannel se instalará utilizando el archivo yaml.
Ejecute el comando para instalar Flannel y corregir el estado NotReady de los nodos que se muestra, ya que no hay red de superposición configurada todavía. Crear el archivo kube-flannel.yaml con el editor de texto vim, por ejemplo, en el primer nodo maestro.
# kubectl apply -f kube-flannel.yml
Recuerde 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 bien.
Añadir nodos trabajadores al clúster
Una vez que haya inicializado todos los nodos maestros, puede añadir nodos trabajadores a su clúster Kubernetes. Vamos a añadir el primer nodo trabajador(192.168.101.31) al clúster Kubernetes HA desplegado en máquinas Ubuntu. Utilice el comando que se mostró después de la inicialización de los nodos maestros (el comando que contiene token y hash) para hacer que el nodo trabajador se una al clúster. Ejecute 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
Compruebe los nodos del clúster de Kubernetes HA para asegurarse de que se ha añadido el nodo trabajador. Ahora también puede ver la máquina proxy de HA en la lista de nodos.
# kubectl get nodes
Del mismo modo, añada otros nodos trabajadores al clúster de alta disponibilidad de Kubernetes instalado en equipos Ubuntu. Puede añadir más nodos trabajadores en cualquier momento en función de sus necesidades. Llegados a este punto, el tutorial de hoy ha terminado.
Conclusión
Instalar Kubernetes en Ubuntu no es tan difícil como puede parecer a primera vista. Hay que invertir algo de esfuerzo para desplegar el clúster Kubernetes, pero, como resultado, se obtienen muchas ventajas, como una gestión centralizada más sencilla, alta escalabilidad y equilibrio de carga. El tipo más sencillo de instalación de Kubernetes es una instalación de un maestro: debe instalar Kubernetes en nodos Ubuntu, incluidos los nodos maestro y trabajador.
Si necesita una infraestructura más fiable para ejecutar aplicaciones en contenedores, considere la posibilidad de desplegar un Kubernetes multimaestro, conocido como clúster de alta disponibilidad de Kubernetes. Este tipo de instalación de Kubernetes excluye un único punto de fallo, y su clúster puede sobrevivir si algunos de los nodos maestros fallan.
Para ambos tipos de instalación, debe configurar el acceso SSH, establecer direcciones IP y nombres de host estáticos, instalar Docker, deshabilitar el uso de la partición de intercambio y, por último, instalar componentes de Kubernetes como kubeadm, kubectl, kubelet y configurar Flannel para la red superpuesta. En el caso de desplegar el clúster Kubernetes HA, también es necesario configurar el proxy HA en una máquina independiente, generar certificados y configurar el clúster etcd. La mayoría de las etapas de configuración de Kubernetes, la creación de despliegues, así como la ejecución de pods se puede hacer con dos métodos: la ejecución de comandos proporcionados por la interfaz de línea de comandos de forma manual, y el uso de archivos de configuración yaml. El uso de archivos yaml permite crear una estructura más compleja y hace que el proceso de administración sea más cómodo.
Puede instalar Kubernetes en Ubuntu, tanto en máquinas físicas como virtuales. Si su Kubernetes está instalado en máquinas virtuales que se ejecutan en vSphere, puede realizar una protección adicional utilizando el clúster VMware High Availability con la función Fault Tolerance. La lógica de instalación de Kubernetes explorada en esta entrada del blog también se puede utilizar para instalar Kubernetes en otras distribuciones de Linux.
