Ejemplos de comandos kubectl que debe conocer como administrador del sistema

Kubernetes, también conocido como K8S, es una popular herramienta de orquestación de contenedores para gestionar y escalar infraestructuras en contenedores.

kubectl es la herramienta CLI común que utilizamos para consultar y gestionar un clúster Kubernetes. kubectl utiliza la interfaz API de Kubernetes para ver, controlar y gestionar el clúster. Es compatible con diferentes plataformas y se puede configurar fácilmente para gestionar un clúster.

En este artículo, vamos a cubrir algunos comandos kubectl comunes que ayudan en el día a día de la administración de Kubernetes.

Obtener kubectl

kubectl ya está instalado como parte de la configuración del clúster Kubernetes. En caso de que esté gestionando un clúster desde un sistema remoto, puede instalarlo fácilmente para que funcione con cualquier configuración de clúster.

En un Linux puede utilizar el siguiente comando para obtener la última versión de kubectl:

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

Asegúrese de colocar el binario descargado en una ubicación fija, añada la ubicación a su PATH y hacerlo ejecutable con chmod +x mando.

En un Windows puede descargar la última versión disponible de kubectl obteniendo primero la última versión estable de https://dl.k8s.io/release/stable.txt

Y, a continuación, descárguelo sustituyendo {version} con la última versión utilizando curl como:

$ curl -LO https://dl.k8s.io/release/{version}/bin/windows/amd64/kubectl.exe

Para v 1.20.0, aquí está el comando curl:

$ curl -LO https://dl.k8s.io/release/v1.20.0/bin/windows/amd64/kubectl.exe

Si no tienes curl en tu sistema, también puedes descargar el ejecutable kubectl usando tu navegador como cualquier otra descarga.

Para otros métodos y plataformas soportados, puedes encontrar la guía oficial para obtener kubectl aquí.

Verificar la configuración de kubectl

Para comprobar la configuración de kubectl, puede ejecutar el comando de versión como:

$ kubectl version --client

La sintaxis general para el uso de kubectl es:

$ kubectl [command] [TYPE] [NAME] [flags]

Establecer contexto y configuración

Antes de utilizar los comandos kubectl en un clúster Kubernetes, primero tenemos que establecer la configuración y el contexto. Se puede hacer con el propio comando kubectl.

Para ver la configuración actual de kubectl, utilice:

$ kubectl config view

Para listar todos los contextos disponibles:

$ kubectl config get-contexts

Para obtener el contexto actual para kubectl:

$ kubectl config current-context

Podemos cambiar el contexto en uso utilizando:

$ kubectl config use-context [cluster-name]

Para autorizar que se añada un nuevo usuario en kubeconf:

$ kubectl config set-credentials NAME [--client-certificate=path/to/certfile] [--client-key=path/to/keyfile] [--token=bearer_token] [--username=basic_user] [--password=basic_password]

Por ejemplo, para establecer sólo el campo "client-key" en el "cluster-admin" sin tocar otros valores, podemos utilizar:

$ kubectl config set-credentials cluster-admin --client-key=~/.kube/admin.key

O, como otro ejemplo, para establecer la autenticación básica para, digamos "cluster-admin" entrada, puede especificar el nombre de usuario y contraseña como:

$ kubectl config set-credentials cluster-admin --username=[username] --password=[password]

Si desea incrustar los datos del certificado de cliente en la entrada "cluster-admin", la sintaxis cambia a:

$ kubectl config set-credentials cluster-admin --client-certificate=~/.kube/admin.crt --embed-certs=true

Si quieres que kubectl utilice un espacio de nombres específico y lo guarde para todos los comandos kubectl posteriores en ese contexto:

$ kubectl config set-context --current --namespace=[NAMESPACE]

Creación de objetos

kubectl se utiliza para desplegar diferentes objetos soportados en un clúster Kubernetes. Su manifiesto se puede definir en un YAML o JSON archivo con extensión .yaml o .yml y .json respectivamente.

Usando el archivo de manifiesto dado, podemos crear recursos definidos usando el siguiente comando:

$ kubectl apply -f [manifest.yaml]

O para especificar varios archivos YAML, utilice:

$ kubectl apply -f [manifest1.yaml] [manifest2.yaml]

Para crear un(os) recurso(s) en todos los archivos de manifiesto presentes en un directorio:

$ kubectl apply -f ./dir

O para crear recursos a partir de una URL:

$ kubectl apply -f [URL]

O directamente desde el nombre de la imagen desde el repositorio como:

$ kubectl create deployment [deployment-name] --image=[image-name]

Por ejemplo, para desplegar una única instancia del servidor web Nginx:

$ kubectl create deployment nginx --image=nginx

Por último, para desplegar recursos directamente escribiendo el comando YAML en CLI sin hacer referencia a un archivo de manifiesto real guardado, intente algo como:

# Create multiple YAML objects from stdin
cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
name: busybox-sleep
spec:
containers:
- name: busybox
image: busybox
args:
- sleep
- "1000000"
---
apiVersion: v1
kind: Pod
metadata:
name: busybox-sleep-less
spec:
containers:
- name: busybox
image: busybox
args:
- sleep
- "1000"
EOF

Ver/encontrar recursos

kubectl proporciona get para enumerar los recursos desplegados, obtener sus datos y saber más sobre ellos.

Para listar todos los servicios en el espacio de nombres por defecto, utilice:

$ kubectl get services

Del mismo modo, para listar pods en todos los espacios de nombres, la sintaxis será:

$ kubectl get pods --all-namespaces

Si necesitamos listar más detalles de los pods desplegados, utilice -o wide bandera como:

$ kubectl get pods -o wide

La sintaxis para obtener los detalles del despliegue es la siguiente:

$ kubectl get deployment [deployment-name]

Para obtener el contenido YAML de un pod, podemos utilizar -o yaml bandera como:

$ kubectl get pod [pod-name] -o yaml

A menudo necesitamos obtener detalles sobre los recursos de Kubernetes. El comando describe de kubectl ayuda a obtener esos detalles.

Podemos obtener más detalles sobre un nodo como:

$ kubectl describe nodes [node-name]

O similarmente para vainas como:

$ kubectl describe pods [pod-name]

kubectl permite ordenar la salida en función de un campo concreto. Para listar los servicios ordenados por nombre de servicio, utilice:

$ kubectl get services --sort-by=.metadata.name

O para obtener todos los pods en ejecución en el espacio de nombres, podemos intentar:

$ kubectl get pods --field-selector=status.phase=Running

Para obtener sólo las IP externas de todos los nodos, si están asignadas, podemos utilizar -o jsonpath con la siguiente sintaxis:

$ kubectl get nodes -o jsonpath='{.items[*].status.addresses[?(@.type=="ExternalIP")].address}'

Para obtener etiquetas adjuntas a un recurso, por ejemplo, pods, pruebe:

$ kubectl get pods --show-labels

Para obtener una lista de eventos ordenada por fecha y hora, podemos utilizar -sort-by bandera como:

$ kubectl get events --sort-by=.metadata.creationTimestamp

Si queremos comparar el estado actual del cluster con el estado en el que estaría el cluster si se aplicara el manifiesto, utilizamos diff comando como:

$ kubectl diff -f ./manifest-file.yaml

Modificación de recursos

Los recursos desplegados se modifican a menudo por cualquier cambio de configuración.

Para realizar una actualización continua de, digamos "www" contenedores de, digamos "frontend" despliegue mediante la actualización de su imagen, podemos utilizar:

$ kubectl set image deployment/frontend www=image:v2

Podemos comprobar el historial de despliegues incluyendo la revisión como:

$ kubectl rollout history deployment/frontend

O para volver a un despliegue anterior, utilice:

$ kubectl rollout undo deployment/frontend

También podemos retroceder a una revisión específica especificando --to-revision bandera como:

$ kubectl rollout undo deployment/frontend --to-revision=2

Y para comprobar el estado de la actualización rodante, utilizamos:

$ kubectl rollout status -w deployment/frontend

Para reiniciar, por ejemplo, el despliegue del "frontend", utilice:

$ kubectl rollout restart deployment/frontend

Podemos especificar un manifiesto JSON para reemplazar un pod pasándolo a la entrada estándar como se muestra a continuación:

$ cat pod.json | kubectl replace -f -

Puede suceder que necesite forzar el reemplazo, borrar y luego volver a crear un recurso (NOTA: esto también causará una interrupción del servicio) que se puede hacer como:

$ kubectl replace --force -f [manifest-file]

Etiquetar un recurso (que admite etiquetas) es fácil y puede hacerse utilizando:

$ kubectl label pods [pod-name] new-label=[label]

Del mismo modo, se puede añadir una anotación a un recurso utilizando:

$ kubectl annotate pods [pod-name] icon-url=[url]

Autoescalar un despliegue es posible con:

$ kubectl autoscale deployment [dep-name] --min=[min-val] --max=[max-val]

Toma, dep-name es el nombre de la implantación que se va a autoescalar y min-val y max-val indica el valor mínimo y máximo que se utilizará para el autoescalado.

Recursos de edición

Es posible editar un recurso API en su editor preferido con edit mando.

$ kubectl edit [api-resource-name]

O para utilizar su propio editor alternativo, especifique KUBE_EDITOR como:

KUBE_EDITOR="nano" kubectl edit [api-resource-name]

Ampliación de recursos

El escalado de recursos es una de las características soportadas por Kubernetes y kubectl facilita esta tarea.

Para escalar un conjunto de réplicas llamado, digamos foo a 3, usamos:

$ kubectl scale --replicas=3 rs/foo

O en su lugar, podemos hacer referencia a un archivo YAML de manifiesto para especificar el recurso que se va a escalar como:

$ kubectl scale --replicas=3 -f foo.yaml

Además, podemos realizar un escalado basado en el estado actual del despliegue como:

$ kubectl scale --current-replicas=2 --replicas=3 deployment/nginx

Eliminación de recursos

Los recursos creados necesitarán eventualmente algunas modificaciones o su eliminación. Con kubectl, podemos eliminar los recursos existentes de varias maneras.

Para eliminar un pod utilizando la especificación del archivo JSON, utilizamos:

$ kubectl delete -f ./pod.json

Podemos eliminar pods y servicios con los mismos nombres pod-name y service-name como:

$ kubectl delete pod,service [pod-name] [service-name]

Si los recursos están etiquetados y necesitamos eliminar recursos con una etiqueta específica, digamos label-namepodemos usar:

$ kubectl delete pods,services -l name=[label-name]

Para eliminar todos los pods y servicios contenidos en un espacio de nombres, utilice:

$ kubectl -n [namespace] delete pod,svc --all

Interacción con Pods en ejecución

Podemos usar kubectl para obtener detalles sobre pods en ejecución que nos ayuden a administrar un clúster Kubernetes.

Uno de los comandos comunes es obtener los registros de un pod que se puede hacer como:

$ kubectl logs [pod-name]

O para volcar pod logs con una etiqueta específica:

$ kubectl logs -l name=[label-name]

O para obtener los registros de un contenedor específico como:

$ kubectl logs -l name=[label-name] -c [container-name]

También podemos transmitir registros como hacemos con Linux tail -f con el comando -f bandera también:

$ kubectl logs -f [pod-name]

Ejecutar un pod de forma interactiva se puede hacer con kubectl como:

$ kubectl run -i --tty busybox --image=busybox -- sh

O para ejecutar un pod en un espacio de nombres específico:

$ kubectl run nginx --image=nginx -n [namespace]

Puede adjuntarlo a un contenedor en ejecución con attach mando:

$ kubectl attach [pod-name] -i

El reenvío de puertos se puede hacer para un pod en tiempo de ejecución con el siguiente comando:

$ kubectl port-forward [pod-name] [local-machine-port]:[pod-port]

Para ejecutar algo directamente en un inicio de sesión pod y obtener el uso de salida:

$ kubectl exec [pod-name] -- [command]

El comando anterior funciona si el pod contiene un único contenedor. Para pods con varios contenedores, utilice:

$ kubectl exec [pod-name] -c [container-name] -- [command]

Para mostrar las métricas de rendimiento de un pod determinado y sus contenedores, podemos utilizar:

$ kubectl top pod [pod-name] --containers

O para ordenarlo por una medida digamos CPU o memoria, podemos lograrlo usando:

$ kubectl top pod [pod-name] --sort-by=cpu

Interacción con los nodos y el clúster

kubectl puede interactuar con los nodos y el clúster. Estos son algunos de los comandos que kubectl utiliza para lo mismo.

Para marcar un nodo como no programable, utilice:

$ kubectl cordon [node-name]

Drenar un nodo como parte de la preparación para el mantenimiento:

$ kubectl drain [node-name]

Para volver a marcar el nodo como programable, utilice:

$ kubectl uncordon [node-name]

Para obtener métricas de rendimiento relacionadas con un nodo, podemos utilizar:

$ kubectl top node [node-name]

Para obtener detalles sobre el clúster actual:

$ kubectl cluster-info

Además, podemos volcar el estado del clúster a la salida estándar utilizando:

$ kubectl cluster-info dump

O para volcar a un archivo de uso:

$ kubectl cluster-info dump --output-directory=/path/to/cluster-state

Conclusión

Kubernetes kubectl es la interfaz principal para interactuar con un clúster Kubernetes y este artículo ha demostrado lo potente que es esta herramienta en manos de un usuario experimentado.

Aún así, sólo podemos cubrir una visión resumida de lo que kubectl puede hacer. Para conocerlo con más detalle y comprobar todo lo que admite, consulte su documentación oficial aquí.