Kubernetes 1: Conceptos basicos

Kubernetes es una plataforma para administrar servicios. Uno de sus principales casos de uso es el de orquestar contenedores.

Es decir, si tienes una plataforma que requiere confiabilidad y escalabilidad (entre otras) y que se empaqueta como imágenes de Docker. Kubernetes te permite administrar tu plataforma mediante diversas herramientas.

Componentes

Tenemos tres grandes conceptos: los clusters, el Control Plane y los nodos ¹

El control plane se encarga de gestionar las tareas relacionadas al cluster, como guardar metadatos sobre los nodos, decidir en que nodo crear los nuevos pods, verificar la salud de los nodos, etc.

Generalmente, dado que se suelen usar servicios administrados como EKS, solemos interactuar poco de manera directa con el Control Plane

En los nodos tenemos el runtime de los contenedores (como containerd), kubelete que verifica y notifica al control plane mediante el kube-apiserver la salud de los pods, etc.

Finalmente los pods que se ejecutan dentro de los nodos donde cada nodo puede tener múltiples pods corriendo al mismo tiempo.

Objetos

Los objetos son entidades persistentes. Son utilizadas para representar el estado del clúster ². Estos son los pods, los deployments, los controllers, etc. Los objetos y los nodos son los elementos con los que más solemos interacturar.

Por otro lado, tenemos dos formas de gestionar los objetos: la primera es mediante la CLI kubectl (imperativa) y mediante archivos de configuración YML (declarativa).

Creando nuestro primer cluster

Para propósitos de aprendizaje vamos a utilizar la herramienta kind³, que nos permite crear clusters de manera local. Aunque hay otras como minikube⁴ o el mismo Docker Desktop⁵. Al igual que necesitamos instalar la herramienta kubectl⁶.

Ademas debemos tener instalado Docker⁶.

MacOS:

# kind
brew install kind

# kubectl
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/darwin/arm64/kubectl"

Ubuntu:

# kind
#!/bin/bash

# For AMD64 / x86_64
[ $(uname -m) = x86_64 ] && curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.20.0/kind-linux-amd64
chmod +x ./kind
sudo cp ./kind /usr/local/bin/kind
rm -rf kind

# kubectl
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"

Ahora podemos ejecutar el siguiente comando, lo que creara nuestro primer cluster con el nombre kind:

▶ kind create cluster
Creating cluster "kind" ...
 ✓ Ensuring node image (kindest/node:v1.31.2) 🖼
 ✓ Preparing nodes 📦
 ✓ Writing configuration 📜
 ✓ Starting control-plane 🕹️
 ✓ Installing CNI 🔌
 ✓ Installing StorageClass 💾
Set kubectl context to "kind-kind"
You can now use your cluster with:

kubectl cluster-info --context kind-kind

Have a question, bug, or feature request? Let us know! https://kind.sigs.k8s.io/#community 🙂

Si revisamos los contenedores que se están ejecutando veremos uno para el control plane del cluster, y cuando tengamos nodos veremos un contenedor por cada nodo o worker.

▶ docker ps | grep "kind"
695e351dd59d   kindest/node:v1.31.2    "/usr/local/bin/entr…"   About a minute ago   Up About a minute      127.0.0.1:58969->6443/tcp                                                kind-control-plane

Ahora podemos definir un objeto pod, mediante el enfoque declarativo en un archivo pod.yml:

apiversión: v1
kind: Pod
metadata:
  name: mypod
spec:
  containers:
  - name: nginx
    image: nginx:latest

Aquí tenemos la versión mínima para definir nuestro objeto pod:

• La versión del api
• kind para definir el tipo de objeto
• metadata donde definimos el nombre de nuestro pod
• spec donde definimos cosas como los contenedores que se van a ejecutar, si definimos volúmenes, etc.

Ahora aplicamos los cambios con kubectl:

▶ kubectl apply -f pod.yml
pod/mypod created

Por lo que si ahora obtenemos los pods de nuestro cluster veremos el nuevo pod creandose:

▶ kubectl get pods
NAME    READY   STATUS    RESTARTS   AGE
mypod   1/1     Running   0          14s

Por el momento no acceder al nginx del pod ya que no esta expuesto, para propósitos de debug podemos hacer port-forward a un puerto en nuestra maquina local para poder verificar que efectivamente hay un nginx ejecutandose:

▶ kubectl port-forward pod/mypod 8888:80
Forwarding from 127.0.0.1:8888 -> 80
Forwarding from [::1]:8888 -> 80

Ahora podemos visitar localhost:8080 y ver el mensaje de bienvenida de Nginx

▶ curl http://localhost:8888
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
html { color-scheme: light dark; }
body { width: 35em; margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif; }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>

Con esto vimos algunos conceptos básicos y creamos nuestro primer pod :D.