Universidad de El Salvador

Facultad de Ingeniería y Arquitectura

Escuela de Ingeniería de Sistemas Informáticos
Curso de Especialización Infraestructura Cloud

Guía Instalación Cluster Kubernetes

Ubuntu 20.4

Resultados de Aprendizaje
● Realizar un despliegue de Cluster de Kubernetes como plataforma para proveer
servicios de contenedores en infraestructura.
● Configurar los aspectos esenciales que harán funcional el Cluster Kubernetes
● Desplegar un entorno web para monitoreo y configuración de contenedores dentro del
cluster.

Contexto:
En infraestructura Cloud los contenedores desempeñan un rol importante y un componente
invaluable cuando se trata de hacer devops desde una perspectiva práctica y rápida. Aunque
los contenedores pueden funcionar de forma independiente, contar con un arquitectura de
infraestructura ayuda a organizar y desplegar de forma oportuna, según las necesidades, o los
entornos de desarrollo para los cuales resulten óptimos.
En la presente guía se muestra una forma más de como hacer un despliegue de cluster
Kubernetes, siguiendo ciertas pautas para llegar a un buen término.

I. Configuración del Cluster

1.1. Configuración del entorno

1.1.1 Configuración del servicio de NTP

Para un manejo adecuado de las fechas y horas, se recomienda hacer una instalación de
Crhony en todos los nodos, considerando que el nodo máster será el que sirva la hora al resto
de nodos.
Instalar crhony en todos los nodos
$ sudo apt install chrony

Configurar en el Nodo master:

/etc/chrony/[Link]

1
 server [Link] iburst

Configurar en los nodos Worker

/etc/chrony/[Link]

server k8-master iburst

1.1.2. Configuración de los hosts

Esta configuración deberá realizarse en todos los nodos

Configuración del hosname (master)

$ sudo hostnamectl set-hostname "k8-master"
$ exec bash

Configuración del hosname (worker)

$ sudo hostnamectl set-hostname "k8-worker1"

$ sudo hostnamectl set-hostname "k8-worker2"
$ exec bash

Modificar el archivo hosts en los 3 nodos (/etc/hosts)

[Link] k8-master
[Link] k8-worker1
[Link] k8-worker2

1.1.3. Deshabilitando Swap

Deshabilitando swap y configurando aspectos de kernel en todos los nodos

Deshabilitando Swap
$ sudo swapoff -a
$ sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab

1.1.4. Configurando módulos de kernel

2
Habilitando módulos de kernel en todos los nodos

$ sudo tee /etc/modules-load.d/[Link] <<EOF

overlay
br_netfilter
EOF

$ sudo modprobe overlay

$ sudo modprobe br_netfilter

Configurando en los archivos de módulos, en todos los nodos

$ sudo tee /etc/sysctl.d/[Link] <<EOF
[Link]-nf-call-ip6tables = 1
[Link]-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF

Poniéndolos en ejecución, en todos los nodos

$ sudo sysctl --system

1.2. Instalación del container runtime

Incluyendo la lista de paquetes en todos los nodos

$ sudo apt install -y curl gnupg2 software-properties-common

apt-transport-https ca-certificates

Activar el repositorio de docker, aunque no se utilice docker como container runtime debido
a que kubernetes lo ha descontinuado en su configuración de clúster, siempre es requerido
en la configuración.

$ curl -fsSL [Link] | sudo

apt-key add -

$ sudo add-apt-repository "deb [arch=amd64]

[Link] $(lsb_release -cs) stable"

Instalación de los paquetes de containerd en todos los nodos

$ sudo apt update

3
 $ sudo apt install -y [Link]

Configuración de containerd así como la incorporación al grupo de systemd cgroup para una
ejecución exitosa posterior, en todos los nodos

$ containerd config default | sudo tee /etc/containerd/[Link]

>/dev/null 2>&1

$ sudo sed -i 's/SystemdCgroup \= false/SystemdCgroup \= true/g'

/etc/containerd/[Link]

Reinicio de servicios y activación del servicio de containerd, en todos los nodos.

$ sudo systemctl restart containerd

$ sudo systemctl enable containerd

1.3. Configuración de kubernetes a través del repositorio, en

todos los nodos

$ curl -s [Link] |
sudo apt-key add -
$ sudo apt-add-repository "deb [Link]
kubernetes-xenial main"

Al momento de realizar esta guía aunque ya está la versión de Ubuntu 22.04 jammy, de
momento no existe una rama de paquetes para esta versión de sistema operativo, es por
esto que se trabajará con la versión de rama más reciente existente en el repositorio.

Instalación de Kubernetes así como los componentes kubectl, kubelet y kubeadm, estas
instalaciones deberán hacerse en todos los nodos.

$ sudo apt update

$ sudo apt install -y kubelet kubeadm kubectl
$ sudo apt-mark hold kubelet kubeadm kubectl

Hasta este punto, se tienen configurados todos los aspectos asociados a Kubernetes, en
cuanto al entorno, paquetes, y todo lo necesario para empezar a desplegarlo.

4
1.4. Inicializando el cluster de kubernetes
Para llevar a cabo esta tarea se utilizará la herramienta kubeadm, debe de considerar que
existen otros métodos para el despliegue de este tipo de cluster.
Todo en cuenta que esto solo deberá hacerlo en el nodo master.

$ sudo kubeadm init --control-plane-endpoint=k8-master

Debe de tomar en cuenta que la configuración del endpoint debe de coincidir con el archivo
de hosts y los parámetros configurados.

Debería de darle una salida, como la que se le presenta a continuación:

.
.
.
[kubelet-finalize] Updating "/etc/kubernetes/[Link]" to point to a
rotatable kubelet client certificate and key
[addons] Applied essential addon: CoreDNS
[addons] Applied essential addon: kube-proxy

Your Kubernetes control-plane has initialized successfully!

To start using your cluster, you need to run the following as a regular user:

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/[Link] $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

Alternatively, if you are the root user, you can run:

export KUBECONFIG=/etc/kubernetes/[Link]

You should now deploy a pod network to the cluster.

Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
[Link]

You can now join any number of control-plane nodes by copying certificate
authorities
and service account keys on each node and then running the following as root:

kubeadm join k8-master:6443 --token mwk1fd.bwhhfdx3l3pxywkw \

--discovery-token-ca-cert-hash
sha256:be38c6a1d651632867df5b816a31b71e95a51eac4d446371b5181437dadaf77b \
--control-plane

Then you can join any number of worker nodes by running the following on each
as root:

5
 kubeadm join k8-master:6443 --token mwk1fd.bwhhfdx3l3pxywkw \
--discovery-token-ca-cert-hash
sha256:be38c6a1d651632867df5b816a31b71e95a51eac4d446371b5181437dadaf77b

Algunas partes de la salida se han omitido por fines didácticos; debe de tener en cuenta que
los aspectos resaltados, permitirán interactuar con el cluster para poder incluir nuevos
nodos worker. Esto debe de hacerse de forma cuidadosa, puesto que el token tiene un
período de vencimiento, el cual deberá de tomar en cuenta para ejecutar futuras órdenes a
través de kubeadm, como por ejemplo incorporar nuevos worker.

Para completar la configuración y el inicio del cluster deberá ejecutar en su orden los
aspectos resaltados, esto deberá ejecutarlo únicamente en el nodo máster:

$ mkdir -p $HOME/.kube
$ sudo cp -i /etc/kubernetes/[Link] $HOME/.kube/config
$ sudo chown $(id -u):$(id -g) $HOME/.kube/config

A este momento si todo ha salido bien, deberá tener un cluster operativo, para verificar
puede hacerlo con las siguientes órdenes:

$ kubectl cluster-info
$ kubectl get nodes

Debería de devolverle una salida como la siguiente:

damian@k8-master:~$ kubectl get nodes

NAME STATUS ROLES AGE VERSION
k8-master NotReady control-plane 29s v1.24.3

Note que el nodo k8-master en su estado aparece como no listo; esto es debido a que
requiere los servicios de red, para poder operar. Para cambiar su estado, instalado el addon
Calico que dará aspectos de uso de red a su nodo máster.

Para instalar calico, ahora nos apoyaremos de kubectl, aplicando las siguientes órdenes:
$ curl [Link]
-O
$ kubectl apply -f [Link]

6
Debería de darle una salida como la siguiente

configmap/calico-config created
[Link]/[Link]
created
[Link]/[Link] created
[Link]/[Link] created
[Link]/[Link]
created
[Link]/[Link]
created
[Link]/[Link]
created
[Link]/[Link]
created
[Link]/[Link]
created
[Link]/[Link] created
[Link]/[Link] created
[Link]/[Link] created
[Link]/[Link] created
[Link]/[Link] created
[Link]/[Link] created
[Link]/[Link]
[Link] created
[Link]/[Link] created
[Link]/[Link] created
[Link]/calico-kube-controllers created
[Link]/calico-kube-controllers created
[Link]/calico-node created
[Link]/calico-node created
[Link]/calico-node created
serviceaccount/calico-node created
[Link]/calico-kube-controllers created
serviceaccount/calico-kube-controllers created
[Link]/calico-kube-controllers created

Para verificar que los contenedores del addon han sido cargados de manera correcta, se
deberá ejecutar la siguiente orden:
$ kubectl get pods -n kube-system

La cual debería de darnos una salida como la siguiente:

NAME READY STATUS RESTARTS AGE

calico-kube-controllers-555bc4b957-9vbdw 0/1 Pending 0 29s
calico-node-ncknl 0/1 Running 0 29s
coredns-6d4b75cb6d-5wglr 0/1 ContainerCreating 0 3m34s
coredns-6d4b75cb6d-xt92v 0/1 ContainerCreating 0 3m34s
etcd-k8-master 1/1 Running 0 3m40s
kube-apiserver-k8-master 1/1 Running 0 3m39s
kube-controller-manager-k8-master 1/1 Running 0 3m39s
kube-proxy-gfcfb 1/1 Running 0 3m34s
kube-scheduler-k8-master 1/1 Running 0 3m40s

Los contenedores resaltados, nos indican que se ha realizado una carga exitosa.

7
Ahora podemos revisar nuevamente la salud del cluster para revisar el estado de los nodos
agregados:

damian@k8-master:~$ kubectl get nodes

NAME STATUS ROLES AGE VERSION
k8-master Ready control-plane 3m50s v1.24.3

Nótese que el estado ha cambiado.

1.5. Incluyendo Woker al Cluster

Puesto que el nodo máster lleva tareas más de gestión en el Cluster de Kubernetes, para
poder desplegar servicios y aplicaciones en contenedores, será necesario incorporar nodos
Worker, los cuales serán el músculo del Cluster ya en producción.

Para llevar a cabo esta tarea, es necesario que considere, los aspectos resaltados cuando se
inicializó el Cluster, así como la vigencia del token, para poder ejecutar la orden.

Revisión en el nodo máster de la lista de token creados, así como su vencimiento

$ kubeadm token list

Esto debiera retornar una lista de token

TOKEN TTL EXPIRES USAGES DESCRIPTION

mwk1fd.bwhhfdx3l3pxywkw 23h 2022-08-12T[Link]Z authentication,signing The default bootstrap token generated by
'kubeadm init'.

Debe considerar la fecha actual del nodo máster, para verificar que el token esté vigente
aún, y puedan consumirse los servicios del endpoint a través de él, puede verificar la fecha y
hora con la siguiente orden:

$ date

Si el token estuviera vigente, usted podrá incorporar los nuevos Worker, ejecutando la
orden siguiente en el Nodo Worker según sea la necesidad.

8
Agregando nuevos nodos worker, esto debe de ejecutarse en el nodo Worker que se quiere
agregar
$sudo kubeadm join k8-master:6443 --token mwk1fd.bwhhfdx3l3pxywkw
--discovery-token-ca-cert-hash
sha256:be38c6a1d651632867df5b816a31b71e95a51eac4d446371b5181437dada
f77b

Debe de verificar que el certificado corresponda con el que se creó en el momento de

inicializar el cluster.

En caso de que el token esté vencido, usted podrá crear uno nuevo con la orden siguiente:

$ sudo kubeadm token create

$ kubeadm token list
Y listar nuevamente para verificar la lista y sus periodos de expiración

II. Testing del Cluster

Para probar que el cluster está funcionando de manera correcta, lo haremos desplegando un
contenedor que implemente nginx como servicio. Para ello lo hacemos a través de la
siguiente orden en el nodo máster:
$ kubectl create deployment nginx-app --image=nginx --replicas=2

Verificamos que la creación se haya llevado con éxito, se la siguiente forma:

$ kubectl get deployment nginx-app

NAME READY UP-TO-DATE AVAILABLE AGE
nginx-app 2/2 2 2 17s

Exponemos el servicio para que pueda ser accedido desde una red externa a través del
máster:

$ kubectl expose deployment nginx-app --type=NodePort --port=80

Verificamos el estado de los servicios:

9
 $ kubectl get svc nginx-app
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
nginx-app NodePort [Link] <none> 80:31396/TCP 71s

$ kubectl describe svc nginx-app

Name: nginx-app
Namespace: default
Labels: app=nginx-app
Annotations: <none>
Selector: app=nginx-app
Type: NodePort
IP Family Policy: SingleStack
IP Families: IPv4
IP: [Link]
IPs: [Link]
Port: <unset> 80/TCP
TargetPort: 80/TCP
NodePort: <unset> 31396/TCP
Endpoints: [Link]:80,[Link]:80
Session Affinity: None
External Traffic Policy: Cluster
Events: <none>

Note que el servicio está expuesto a través del máster, más adelante veremos cómo parchar
el puerto, por si se quiere modificarlo y redireccionarlo a otro valor. Al verificar el
funcionamiento en el navegador web, nos muestra los siguiente:

10
III. Dashboard del Cluster
Para hacer el despliegue del dashboard, se realizará utilizando la herramienta kubectl así
como la exposición de puertos de red a través de nodeport

3.1. Desplegando el dashboard

Por default el contenedor del dashboard utiliza una configuración mínima de privilegios
preconfigurados rbac por lo tanto será necesario crear un usuario admin así como su
conjunto de privilegios para poder acceder al dashboard.
En su orden desplegamos la versión más reciente del dashboard a través de la siguiente
orden, ejecutadas en el nodo máster:

$ kubectl apply -f
[Link]
[Link]

Para disponer de la versión más reciente del dashboard, puede acceder al url:
[Link]

11
3.2. Configurando el servicio de NodePort
Este servicio posibilitará acceder al dashboard desde el host, desde donde se han
desplegados las máquinas virtuales que corren el cluster, existen otros métodos que son
menos prácticos.

$ kubectl apply -f
[Link]
[Link]

Verificando el estado de los contenedores del dashboard y su acceso via red:

$ kubectl get svc -n kubernetes-dashboard

Esto debería de devolver la siguiente salida:

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE

dashboard-metrics-scraper ClusterIP [Link] <none> 8000/TCP 3m17s
kubernetes-dashboard ClusterIP [Link] <none> 443/TCP 3m17s

Véase que los servicios son prácticamente inaccesibles desde una red externa, por lo tanto
habrá que parchar, para poder exponerlos a través de un puerto.

$ kubectl --namespace kubernetes-dashboard patch svc kubernetes-dashboard -p

'{"spec": {"type": "NodePort"}}'

Verificamos que el parchado está efectuado de manera correcta:

$kubectl get svc -n kubernetes-dashboard kubernetes-dashboard -o yaml

apiVersion: v1
kind: Service
metadata:
annotations:
[Link]/last-applied-configuration: |

12
 {"apiVersion":"v1","kind":"Service","metadata":{"annotations":{},"labels":{"k8
s-app":"kubernetes-dashboard"},"name":"kubernetes-dashboard","namespace":"kube
rnetes-dashboard"},"spec":{"ports":[{"port":443,"targetPort":8443}],"selector"
:{"k8s-app":"kubernetes-dashboard"}}}
creationTimestamp: "2022-08-11T[Link]Z"
labels:
k8s-app: kubernetes-dashboard
name: kubernetes-dashboard
namespace: kubernetes-dashboard
resourceVersion: "8244"
uid: f683a6b2-06c6-42c9-90b0-a6f105f9b4a9
spec:
clusterIP: [Link]
clusterIPs:
- [Link]
externalTrafficPolicy: Cluster
internalTrafficPolicy: Cluster
ipFamilies:
- IPv4
ipFamilyPolicy: SingleStack
ports:
- nodePort: 31034
port: 443
protocol: TCP
targetPort: 8443
selector:
k8s-app: kubernetes-dashboard
sessionAffinity: None
type: NodePort
status:
loadBalancer: {}

El puerto disponible está resaltado, el cual se va a modificar para establecer el puerto que
nosotros queremos exponer, a través del siguiente perfil.

$ nano nodeport_dashboard_patch.yaml

13
 spec:
ports:
- nodePort: 32000
port: 443
protocol: TCP
targetPort: 8443

Hemos establecido el puerto al valor 32000, ahora debemos aplicar el cambio

$ kubectl -n kubernetes-dashboard patch svc kubernetes-dashboard --patch

"$(cat nodeport_dashboard_patch.yaml)"

Revisamos nuevamente el estado los contenedores del dashboard:

$ kubectl get deployments -n kubernetes-dashboard

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
dashboard-metrics-scraper ClusterIP [Link] <none> 8000/TCP 5m58s
kubernetes-dashboard NodePort [Link] <none> 443:32000/TCP 5m58s

Véase que el puerto ha sido asociado y expuesto para poder acceder al contenedor.
Hagamos una nueva verificación para asegurar que el contenedor esté corriendo.

$ kubectl get pods -n kubernetes-dashboard

NAME READY STATUS RESTARTS AGE
dashboard-metrics-scraper-8c47d4b5d-cfdnk 1/1 Running 0 5m50s
kubernetes-dashboard-5676d8b865-b4s96 1/1 Running 0 5m50s

Ahora podrá escribir con toda confianza en su navegador web de su equipo host, la
dirección ip externa del nodo máster, la cual para mi caso es:

[Link]

Lo cual le devolverá una salida como la siguiente:

14
3.4 Creando el usuario y aplicando los permisos asociados
Para fines del laboratorio se creará el usuario admin-user en el namespace
kubernestes-dashboard, esto lo haremos a través del perfil siguiente:

Creamos el perfil del usuario

$ sudo nano [Link]
apiVersion: v1
kind: ServiceAccount
metadata:
name: admin-user
namespace: kubernetes-dashboard

Creamos el perfil para el ClusterRoleBinding

$ sudo nano [Link]

apiVersion: [Link]/v1
kind: ClusterRoleBinding

15
 metadata:
name: admin-user
roleRef:
apiGroup: [Link]
kind: ClusterRole
name: cluster-admin
subjects:
- kind: ServiceAccount
name: admin-user
namespace: kubernetes-dashboard

Una vez tenemos los perfiles los aplicamos al cluster para crear los objetos:

Para el usuario
$ kubectl apply -f [Link]

Para los roles

$ kubectl apply -f [Link]

Ahora creamos el token que utilizaremos en la interfaz web para acceder a los servicios del
dashboard, a través de la siguiente orden:

$ kubectl -n kubernetes-dashboard create token admin-user

Una vez tenemos el token en pantalla, lo copiamos y lo pegamos en el campo de la interfaz

web, para acceder. En caso que el token expire, si vamos a entrar nuevamente a la interfaz
tendremos que crear un nuevo.

16