Pod
Introducció
Section titled “Introducció”De la mateixa manera que Compose ens permet executar un grup de contenidors estretament relacionats, kubernetes utilitza pods.
La majoria de pods només tenen un contenidor, però un contenidor sempre s’ha d’executar dins d’un pod.
Minikube
Section titled “Minikube”Minikube és una eina que et permet utilitzar Kubernetes en un únic node per realitzar proves o com a entorn de desenvolupament.
Crea una màquina Linux i instal·la Docker
connect-wsl k8s -newinstall-docker
Instal·la l’última versió estable de minikube utilitzant el paquet Debian:
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube_latest_amd64.debsudo dpkg -i minikube_latest_amd64.deb
Configura minikube perquè tingui més “potència”:
$ minikube config set cpus 8$ minikube config set memory 8096$ minikube config view- cpus: 8- memory: 8096
Inicia el clúster:
$ minikube start😄 minikube v1.35.0 on Ubuntu 24.04 (amd64)✨ Automatically selected the docker driver. Other choices: none, ssh
❌ Exiting due to MK_USAGE: Docker has only 7777MB memory but you specified 8096MB
Com t’has excedit amb la memòria (potser no 😅), modifica la configuració corresponent:
~$ minikube config set memory 6144❗ These changes will take effect upon a minikube delete and then a minikube start
Som-hi 🚀:
$ minikube start😄 minikube v1.35.0 on Ubuntu 24.04 (amd64)✨ Using the docker driver based on existing profile👍 Starting "minikube" primary control-plane node in "minikube" cluster...🏄 Done! kubectl is now configured to use "minikube" cluster and "default" namespace by default
Al principi, és possible que alguns serveis, com el proveïdor d’emmagatzematge, encara no estiguin en estat d’execució. Aquesta és una situació normal durant l’activació del clúster i es resoldrà per si sola en uns moments.
Comprova l’estat del clúster:
$ minikube statusminikubetype: Control Planehost: Runningkubelet: Runningapiserver: Runningkubeconfig: Configured
Pots comprovar que estem utilitzant el driver docker:
$ minikube profile list|----------|-----------|---------|--------------|------|---------|--------|-------|----------------|--------------------|| Profile | VM Driver | Runtime | IP | Port | Version | Status | Nodes | Active Profile | Active Kubecontext ||----------|-----------|---------|--------------|------|---------|--------|-------|----------------|--------------------|| minikube | docker | docker | 192.168.49.2 | 8443 | v1.32.0 | OK | 1 | * | * ||----------|-----------|---------|--------------|------|---------|--------|-------|----------------|--------------------|
Pots aturar el clúster amb la comanda stop
:
$ minikube stop✋ Stopping node "minikube" ...🛑 Powering off "minikube" via SSH ...🛑 1 node stopped.
I també, pots esborrar el clúster amb la comanda delete
(no cal que ho provis 🙄):
$ minikube delete🔥 Deleting "minikube" in docker ...🔥 Deleting container "minikube" ...🔥 Removing /home/box/.minikube/machines/minikube ...💀 Removed all traces of the "minikube" cluster.
I si ets una mica curiós, hauries de ser-ho 🧐, pots entrar dins de la màquina virtual Minikube:
$ minikube ssh
En aquest cas és “docker”, però podria ser una màquina virtual de veritat.
$ minikube sshdocker@minikube:~$ exitlogout
Com a administrador has de dominar el clúster des del shell, però a vegades és útil un entorn gràfic.
Obre un nou terminal, i executa:
$ minikube dashboard🤔 Verifying dashboard health ...🚀 Launching proxy ...🤔 Verifying proxy health ...🎉 Opening http://127.0.0.1:42919/api/v1/namespaces/kubernetes-dashboard/services/http:kubernetes-dashboard:/proxy/ in your default browser...👉 http://127.0.0.1:42919/api/v1/namespaces/kubernetes-dashboard/services/http:kubernetes-dashboard:/proxy/
Fes clic a l’enllaç que t’indica 👉.
Important El port és dinàmic, per tant, fes clic a l’enllaç del teu shell, no al de la documentació! 🫡
kubectl
Section titled “kubectl”Instal·la kubectl
:
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl
Habilita l’autocompletat de kubectl (et permet utilitzar la tecla tab per completar les comandes):
echo 'source <(kubectl completion bash)' >>~/.bashrcsource ~/.bashrc
Amb kubectl
pots controlar un clúster kubernetes mitjançant peticions REST al servidor API que s’executa al node “master”.
Per exemple, pots obtenir la informació del clúster:
$ kubectl cluster-infoKubernetes control plane is running at https://127.0.0.1:32781CoreDNS is running at https://127.0.0.1:32781/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy
To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.
Pots veure que el clúster està actiu i diferents URLs de diversos components de kubernetes.
A continuació mira quants nodes formen part del clúster:
$ kubectl get nodesNAME STATUS ROLES AGE VERSIONminikube Ready control-plane 28m v1.32.0
Com era d’esperar només hi ha un node, que és “minikube”.
Amb la comanda kubectl get
pots obtenir una llista de diferents tipus d’objectes “kubernetes” (en el nostre exemple has demanat una llista de tots els objectes de tipus “node”).
Si vols obtenir detalls addicionals d’un objecte pots utilitzar la comanda describe
amb el tipus d’objecte i nom de l’objecte.
Per exemple, obtén els detalls de l’objecte “minikube” de tipus “node”:
$ kubectl describe node minikubeName: minikubeRoles: control-plane...
La descripció mostra l’estat del node, les dades de CPU i memòria, informació del sistema, els contenidors que s’estan executant dins del node, i molta més informació.
La forma més habitual i senzilla és executar un pod amb un sol contenidor.
A continuació executa un pod amb un únic contenidor apache:
$ kubectl run apache --image=httpdpod/apache created
Amb la comanda get
pots veure tots els pods que estan desplegats al clúster:
$ kubectl get podsNAME READY STATUS RESTARTS AGEapache 1/1 Running 0 17s
Si vols pots obtenir una descripció d’un contenidor amb la comanda describe
:
$ kubectl describe pod apache...IP: 10.244.0.13IPs: IP: 10.244.0.13Containers: apache: Container ID: docker://ce53a65a3e96949e84ca92e7019eab5cbfdeff2ca0cfa7dff25c8718477b70b2 Image: httpd Image ID: docker-pullable://httpd@sha256:437b9f7d469dd606fa6d2a5f9a3be55fe3af7e0c66e0329da8c14b291ae0d31c Port: <none> Host Port: <none> State: Running Started: Sat, 01 Feb 2025 22:19:29 +0100 Ready: True...
Pots veure que el pod té la IP 10.244.0.13
i un contenidor “apache”.
També pots executar una comanda en un contenidor de la mateixa manera que ho fas amb docker:
$ kubectl exec apache -- ls htdocsindex.html
Com el pod només té un contenidor no cal especificar el contenidor, però si no fos així has d’especificar el contenidor amb l’argument : -c
$ kubectl exec apache -c apache -- ls htdocsindex.html
Executa bash al contenidor “apache” en un terminal interactiu:
$ kubectl exec -it apache -- bashroot@apache:/usr/local/apache2#
La IP d’un pod és interna al clúster, la comparteixen tots els contenidors del pod, i canvia cada cop que es crea el pod.
Elimina el pod “apache” i torna a crear el pod:
$ kubectl delete pod apachepod "apache" deleted$ kubectl run apache --image=httpdpod/apache created
Mira l’adreça IP del pod amb el flag : -o wide
$ kubectl get pods -o wideNAME READY STATUS RESTARTS AGE IP NODE NOMINATED NODE READINESS GATESapache 1/1 Running 0 5m28s 10.244.0.14 minikube <none> <none>
Si només vols l’adreça IP, pots utilitzar una “plantilla Go” per formatar la informació del Pod i retornar només l’adreça IP del Pod.
$ kubectl get pod nginx-w29j2 -o=jsonpath='{.status.podIP}'10.244.0.14
Si executes curl
pots veure que no tens accés a aquesta IP:
$ curl -m 2 10.244.0.14curl: (28) Connection timed out after 2037 milliseconds
Però si entres dins del clúster, tens accés al servidor “apache”:
$ minikube sshdocker@minikube:~$ curl 10.244.0.14<html><body><h1>It works!</h1></body></html>docker@minikube:~$ exitlogout
Com hem explicat al principi, la IP és interna del clúster, el que vol dir que qualsevol pod pot utilitzar aquesta IP perquè comparteixen la mateixa xarxa.
Crea un pod “nginx” i crea una sessió interactiva:
$ kubectl run nginx --image=nginxpod/nginx createdbox@k8s:~$ kubectl exec -it nginx -- bashroot@nginx:/#
Verifica que des del contenidor “nginx” tens accés al contenidor “apache”:
$ curl 10.244.0.14<html><body><h1>It works!</h1></body></html>
Una altra manera de connectar-se a un pod per fer proves, o per “debugging”, és mitjançant un port forwarding:
$ kubectl port-forward apache 8000:80Forwarding from 127.0.0.1:8000 -> 80Forwarding from [::1]:8000 -> 80
Ara et pots connectar directament des del navegador: http://localhost:8000/.
A Servei aprendràs com exposar un pod a l’exterior mitjançant la configuració de serveis.
Descriptor
Section titled “Descriptor”De la mateixa manera que a Compose utilitzes un fitxer yaml per definir una composició de contenidors, amb kubernetes també pots utilitzar un fitxer yaml per definir un pod.
A continuació mira la definició del pod que està en execució en format yaml:
$ kubectl get pod apache -o yamlapiVersion: v1kind: Podmetadata: creationTimestamp: "2025-02-01T21:19:23Z" labels: run: apache name: apache namespace: default resourceVersion: "3554" uid: c58a72ec-83c7-4d4e-b49e-3413a72a2a2cspec: containers: - image: httpd imagePullPolicy: Always name: apache resources: {} terminationMessagePath: /dev/termination-log terminationMessagePolicy: File volumeMounts: - mountPath: /var/run/secrets/kubernetes.io/serviceaccount name: kube-api-access-gjqjw readOnly: true...
Pot semblar molt complicat al principi, però a mesura que aprenguis els conceptes bàsics i aprenguis a distingir les parts importants del que són detalls menors veuràs que és molt fàcil d’entendre.
A més, per definir un pod no necessites escriure tot això.
A continuació desplegaràs un pod amb MongoDB
Crea un fitxer mongodb.yaml
apiVersion: v1kind: Podmetadata: name: mongodbspec: containers: - image: mongo name: mongodb ports: - containerPort: 27017 protocol: TCP
Pots veure que en la definició d’un pod:
-
metadata
inclou el nom, l’espai de noms, etiquetes i altra informació sobre el pod. -
spec
inclou la descripció dels continguts del pod, com són els contenidors, volums i altres dades. -
status
inclou la informació sobre l’execució del pod, per la qual cosa no forma part del fitxer de definició.
Pots consultar per a què serveix cada entrada del fitxer amb la comanda explain
.
Important! El port és només descriptiu, perquè tu o qualsevol altre sàpiga quins ports utilitza el contenidor.
Per exemple:
$ kubectl explain pod.specKIND: PodVERSION: v1
FIELD: spec <PodSpec>...
Utilitza la comanda create
per crear un pod a partir d’un fitxer yaml:
$ kubectl create -f mongodb.yamlpod/mongodb created
Pots veure que ara tens dos pods:
$ kubectl get podsNAME READY STATUS RESTARTS AGEapache 1/1 Running 0 41mmongodb 1/1 Running 0 54s
Connecta’t a la base de dades mongodb des de l’exterior amb mongosh
:
Obre un altre terminal i fes un port forward:
$ kubectl port-forward mongodb 27017:27017Forwarding from 127.0.0.1:27017 -> 27017Forwarding from [::1]:27017 -> 27017
Connecta’t amb mongosh
:
$ docker run --rm -it --network host mongo mongoshCurrent Mongosh Log ID: 679ea6b415ca11579ae94969Connecting to: mongodb://127.0.0.1:27017/?directConnection=true&serverSelectionTimeoutMS=2000&appName=mongosh+2.3.4Using MongoDB: 8.0.4Using Mongosh: 2.3.4...test>
Les aplicacions que s’executen en contenidors normalment no escriuen els “logs” en fitxers, sinó que els envien a la sortida estàndard, de tal manera que els usuaris poden accedir a aquesta informació d’una manera simple i estàndard.
D’aquesta forma, Docker redirigeix aquests “streams” a fitxers que et permeten accedir als “logs” dels contenidors a través de Docker de forma homogènia.
Pots utilitzar kubectl
per accedir a aquests logs, per exemple els d’Apache:
$ kubectl logs apacheAH00558: httpd: Could not reliably determine the server's fully qualified domain name, using 10.244.0.4. Set the 'ServerName' directive globally to suppress this messageAH00558: httpd: Could not reliably determine the server's fully qualified domain name, using 10.244.0.4. Set the 'ServerName' directive globally to suppress this message[Sat Feb 01 21:19:29.784649 2025] [mpm_event:notice] [pid 1:tid 1] AH00489: Apache/2.4.63 (Unix) configured -- resuming normal operations[Sat Feb 01 21:19:29.785020 2025] [core:notice] [pid 1:tid 1] AH00094: Command line: 'httpd -D FOREGROUND'10.244.0.1 - - [01/Feb/2025:21:22:34 +0000] "GET / HTTP/1.1" 200 45127.0.0.1 - - [01/Feb/2025:21:34:38 +0000] "GET / HTTP/1.1" 200 45127.0.0.1 - - [01/Feb/2025:21:34:38 +0000] "GET /favicon.ico HTTP/1.1" 404 196
Ten en cuenta que cuando borras un pod ya no tienes acceso a los logs de los contenedores de ese pod.
$ kubectl delete pod apachepod "apache" deleted$ kubectl logs apacheerror: error from server (NotFound): pods "apache" not found in namespace "default"
Si vols conservar els logs dels pods fins i tot després que siguin eliminats, has d’implementar un registre centralitzat que guardi els logs de tot el clúster.
Etiquetes
Section titled “Etiquetes”Un clúster kubernetes està pensat per desplegar centenars i milers de pods.
Per sort, pots posar etiquetes als pods per organitzar i posar ordre.
De fet, pots etiquetar qualsevol mena d’objecte kubernetes.
Crea un pod amb un contenidor nginx:
$ kubectl run nginx --image nginxpod/nginx created
A continuació anem a etiquetar els tres pods amb una etiqueta type
:
$ kubectl label pod apache type=webpod/apache labeled$ ...
Per defecte la comanda kubectl get pods
no mostra les etiquetes, però pots fer que es mostrin amb el paràmetre : --show-labels
$ kubectl get pods --show-labelsNAME READY STATUS RESTARTS AGE LABELSapache 1/1 Running 0 17m run=apache,type=webmongodb 1/1 Running 0 5m3s type=dbnginx 1/1 Running 0 8h run=nginx,type=web
Pots veure que a més de la nostra etiqueta, els pods apache
i nginx
tenen l’etiqueta run
perquè no els has creat a partir d’un fitxer sinó directament amb kubectl run
.
A més de l’etiqueta type
, afegeix l’etiqueta env
per indicar si un pod s’executa en entorn de producció o depuració:
$ kubectl label pod mongodb env=prodpod/mongodb labeled...
En lloc de veure totes les etiquetes amb , podem seleccionar les etiquetes que volem veure amb el flag , de manera que cada etiqueta es desplega en la seva pròpia columna: --show-labels``-L
$ kubectl get pods -L type,envNAME READY STATUS RESTARTS AGE TYPE ENVapache 1/1 Running 0 29m web prodmongodb 1/1 Running 0 16m db prodnginx 1/1 Running 0 8h web debug
Per modificar una etiqueta necessites utilitzar el flag , per evitar una modificació accidental: --overwrite
$ kubectl label pod nginx env=testerror: 'env' already has a value (debug), and --overwrite is false
$ kubectl label pod nginx env=test --overwritepod/nginx labeled
Pots veure que és fàcil afegir etiquetes als recursos i modificar-les.
A Replicació veuràs una de les utilitats més importants que tenen.
De moment ens limitarem a filtrar recursos mitjançant un selector d’etiquetes.
Per veure tots els pods que estan en entorn de producció (etiquetats amb env=prod
), fes el següent:
$ kubectl get pods -l env=prodNAME READY STATUS RESTARTS AGEapache 1/1 Running 0 41mmongodb 1/1 Running 0 28m
Per tenir una llista de tots els pods que tenen l’etiqueta run
, sense importar el valor de l’etiqueta:
$ kubectl get pods -l runNAME READY STATUS RESTARTS AGEapache 1/1 Running 0 43mnginx 1/1 Running 0 8h
I aquells que no tenen l’etiqueta run
:
$ kubectl get pods -l '!run'NAME READY STATUS RESTARTS AGEmongodb 1/1 Running 0 31m
Observació. Has d’utilitzar cometes simples al voltant de perquè el shell no avaluï el signe d’exclamació. !run
També pots incloure diversos criteris separats per coma:
$ kubectl get pods -l env=prod,type=webNAME READY STATUS RESTARTS AGEapache 1/1 Running 0 47m
Espai de noms
Section titled “Espai de noms”Kubernetes utilitza diferents espais de noms per agrupar i separar recursos.
En un espai de noms el nom del recurs ha de ser únic, però pot haver-hi recursos amb el mateix nom en diferents espais de noms.
Mira els espais de nom que hi ha al teu clúster:
$ kubectl get namespacesNAME STATUS AGEdefault Active 21hkube-node-lease Active 21hkube-public Active 21hkube-system Active 21h
Fins ara has utilitzat l’espai de noms default
, que és el que s’utilitza per defecte amb kubectl
.
Mira els pods que hi ha a l’espai de noms : kube-system
$ kubectl get pods --namespace kube-systemNAME READY STATUS RESTARTS AGEcoredns-668d6bf9bc-qbhmr 1/1 Running 1 (9h ago) 21hetcd-minikube 1/1 Running 1 (9h ago) 21hkube-apiserver-minikube 1/1 Running 1 (9h ago) 21hkube-controller-manager-minikube 1/1 Running 1 (9h ago) 21hkube-proxy-x7ghr 1/1 Running 1 (9h ago) 21hkube-scheduler-minikube 1/1 Running 1 (9h ago) 21hstorage-provisioner 1/1 Running 3 (9h ago) 21h
Consell. Pots utilitzar -n
en lloc de --namespace
.
En altres activitats aprendràs sobre aquests pods, però a partir del nom kube-system
pots intuir que es tracta de pods relacionats amb el sistema d’execució de kubernetes.
Un espai de noms és com qualsevol altre recurs, i el podem crear amb un fitxer yaml:
apiVersion: v1kind: Namespacemetadata: name: xtec
Utilitza kubectl
per enviar el fitxer al servidor API kubernetes:
$ kubectl create -f namespace.yamlnamespace/xtec created
Com pots haver endevinat també el pots crear directament per línia d’ordres:
$ kubectl create namespace kekonamespace/keko created
A continuació crea un servidor caddy amb el nom “caddy” a l’espai de noms xtec
:
$ kubectl run caddy --image=caddy -n xtecpod/caddy created
Pots veure que no apareix a l’espai de noms default
:
$ kubectl get podsNAME READY STATUS RESTARTS AGEapache 1/1 Running 0 72mmongodb 1/1 Running 0 59mnginx 1/1 Running 0 9h
Però sí a l’espai de noms xtec
:
$ kubectl get pods -n xtecNAME READY STATUS RESTARTS AGEcaddy 1/1 Running 0 76s
Fes un “port forward”:
$ kubectl port-forward caddy 3000:80 -n xtecForwarding from 127.0.0.1:3000 -> 80Forwarding from [::1]:3000 -> 80Handling connection for 3000
Pots veure el servidor caddy funcionant: http://localhost:3000/.
Encara que els pods s’executin en espais separats, es poden comunicar entre ells en funció del tipus de solució de xarxa que s’hagi desplegat al clúster.
El nostre “minikube” utilitza una solució simple com pots veure a continuació:
$ kubectl get pod -o wide | grep apacheapache 1/1 Running 0 84m 10.244.0.16 minikube <none> <none>
$ kubectl exec -it caddy -n xtec -- sh/srv $ apk add curlOK: 13 MiB in 30 packages/srv $ curl 10.244.0.16<html><body><h1>It works!</h1></body></html>
Gestionar pods
Section titled “Gestionar pods”A diferència de docker, amb kubernetes no pots aturar contenidors, només pots crear o eliminar pods.
Pots eliminar un pod pel seu nom:
$ kubectl delete pod mongodbpod "mongodb" deleted
O eliminar un conjunt de pods mitjançant un selector d’etiquetes:
$ kubectl delete pod -l type=webpod "apache" deletedpod "nginx" deleted
Fins i tot pots eliminar tot un espai de noms (incloent tots els recursos):
$ kubectl delete ns xtecnamespace "xtec" deleted
El contingut d'aquest lloc web té llicència CC BY-NC-ND 4.0.
©2022-2025 xtec.dev