Técnicas Avanzadas de kubectl get: Filtrado de Salida con Etiquetas y JSONPath

kubectl get se vuelve mucho más útil cuando puedes reducir la salida a los recursos y campos exactos que necesitas. En un namespace ocupado, la diferencia entre un muro de pods y una lista enfocada de nombres, nodos e imágenes puede ahorrar minutos durante un incidente.

Esta guía muestra cómo combinar selectores de etiquetas con salida JSONPath. También verás cuándo custom-columns o jq son una mejor opción que forzar todo en una sola expresión JSONPath.

Entendiendo las Etiquetas de Kubernetes: La Base de la Selección de Recursos

Antes de sumergirnos en el filtrado avanzado, es crucial entender las etiquetas de Kubernetes. Las etiquetas son pares clave-valor adjuntos a objetos de Kubernetes (como Pods, Servicios, Deployments, etc.) que se utilizan para identificar y organizar recursos. Son metadatos que los clientes y usuarios pueden usar para seleccionar subconjuntos de objetos.

Las etiquetas son distintas de las anotaciones; las etiquetas están destinadas a identificar características que son significativas y relevantes para que los usuarios consulten y seleccionen objetos, mientras que las anotaciones son para metadatos no identificativos. Las buenas prácticas de etiquetado son esenciales para una gestión eficaz de recursos y operaciones avanzadas de kubectl get.

Para ver las etiquetas asignadas actualmente a tus recursos, puedes usar el flag --show-labels:

kubectl get pods --show-labels

Esto agregará una columna LABELS a tu salida, mostrando todas las etiquetas asociadas con cada Pod.

Selectores de Etiquetas Avanzados con `kubectl get -l`

El flag -l o --selector es tu herramienta principal para filtrar la salida de kubectl get basada en etiquetas. Te permite especificar un conjunto de requisitos de etiquetas que los recursos deben cumplir para ser incluidos en la salida. Los selectores pueden ser pares clave-valor simples o expresiones basadas en conjuntos más complejas.

Selección Básica de Etiquetas

Coincidencia Exacta

Para seleccionar recursos que tienen una etiqueta específica con un valor exacto, usa la sintaxis clave=valor.

# Obtener todos los pods con la etiqueta 'app' establecida en 'nginx'
kubectl get pods -l app=nginx

# Obtener todos los servicios en el namespace 'default' con la etiqueta 'tier' establecida en 'frontend'
kubectl get services -n default -l tier=frontend

Coincidencia de Desigualdad

Para seleccionar recursos que tienen una etiqueta específica no establecida en un valor particular, usa la sintaxis clave!=valor.

# Obtener todos los pods donde la etiqueta 'app' no es 'nginx'
kubectl get pods -l app!=nginx

Existencia (Solo Clave)

Para seleccionar recursos que simplemente tienen una etiqueta particular, independientemente de su valor, solo especifica la clave.

# Obtener todos los pods que tienen la etiqueta 'environment', independientemente de su valor
kubectl get pods -l environment

No Existencia (Solo Clave)

Para seleccionar recursos que no tienen una etiqueta particular, prefija la clave con !.

# Obtener todos los pods que NO tienen la etiqueta 'component'
kubectl get pods -l !component

Combinando Múltiples Selectores de Etiquetas (Lógica AND)

Puedes combinar múltiples selectores de etiquetas separándolos con una coma. Esto implica una relación AND, lo que significa que un recurso debe satisfacer todas las condiciones de etiqueta especificadas para ser incluido.

# Obtener pods con 'app=nginx' Y 'env=production'
kubectl get pods -l app=nginx,env=production

# Obtener deployments con 'tier=backend' Y que NO tengan la etiqueta 'version'
kubectl get deployments -l tier=backend,!version

Selectores de Etiquetas Basados en Conjuntos

Kubernetes también admite selectores de etiquetas basados en conjuntos más potentes, que son particularmente útiles cuando se trata de múltiples valores posibles para una sola etiqueta.

`clave in (valor1, valor2, ...)`

Para seleccionar recursos donde el valor de una etiqueta es uno de una lista especificada de valores.

# Obtener pods donde la etiqueta 'app' es 'nginx' O 'redis'
kubectl get pods -l 'app in (nginx,redis)'

# Obtener servicios en el namespace 'kube-system' donde la etiqueta 'k8s-app' es 'kube-dns' O 'kubernetes-dashboard'
kubectl get services -n kube-system -l 'k8s-app in (kube-dns,kubernetes-dashboard)'

`clave notin (valor1, valor2, ...)`

Para seleccionar recursos donde el valor de una etiqueta no es ninguno de una lista especificada de valores.

# Obtener pods donde la etiqueta 'env' NO es 'dev' NI 'test'
kubectl get pods -l 'env notin (dev,test)'

Consejo: Al usar selectores basados en conjuntos o selectores con caracteres especiales, siempre encierra toda la expresión del selector entre comillas simples ('...') para evitar problemas de interpretación del shell.

Mejores Prácticas para el Etiquetado

Consistencia: Establece un esquema de etiquetado claro y mantenlo en todo tu clúster. Esto hace que el filtrado sea predecible y confiable.
Nombres Significativos: Usa etiquetas que describan claramente las características del recurso (por ejemplo, app, tier, environment, version).
Granularidad: Las etiquetas deben ser lo suficientemente específicas para permitir una selección precisa, pero no tan granulares que se vuelvan inmanejables.
Inmutabilidad: Evita usar etiquetas para datos que cambian con frecuencia. Las etiquetas son más adecuadas para propiedades de identificación estáticas.
Etiquetas Comunes: Usa etiquetas ampliamente adoptadas como app.kubernetes.io/name, app.kubernetes.io/instance, app.kubernetes.io/version, etc., para una mejor interoperabilidad con herramientas.

Extrayendo Datos Personalizados con JSONPath

Mientras que los selectores de etiquetas te ayudan a identificar qué recursos quieres, JSONPath te ayuda a definir qué información quieres extraer de esos recursos y cómo debe formatearse. kubectl get te permite mostrar detalles de recursos en varios formatos como yaml, json y wide; -o jsonpath es útil cuando necesitas una salida personalizada compacta.

kubectl tiene su propia implementación de JSONPath para navegar por la estructura JSON de los objetos de Kubernetes. Admite texto de plantilla útil y bucles range, pero no es lo mismo que las plantillas Go o jq.

Para usar JSONPath, especifica el formato de salida con -o jsonpath='<plantilla>'.

Conceptos Básicos de JSONPath y Casos de Uso Comunes

Primero, a menudo es útil ver la salida JSON completa de un recurso para entender su estructura antes de escribir una expresión JSONPath:

# Obtener la estructura JSON completa de un pod
kubectl get pod <nombre-del-pod> -o json

Esto te dará un mapa claro para construir tus consultas JSONPath.

Accediendo a un Solo Campo

Usa {.campo.subcampo} para acceder a valores específicos. Por ejemplo, para obtener el nombre de un Pod:

# Obtener el nombre de un pod específico
kubectl get pod my-nginx-pod-12345 -o jsonpath='{.metadata.name}'

# Obtener el nombre del nodo donde se está ejecutando un pod
kubectl get pod my-nginx-pod-12345 -o jsonpath='{.spec.nodeName}'

Accediendo a Elementos de un Array

Para acceder a elementos dentro de un array, puedes usar [*] para iterar a través de todos los elementos o [índice] para uno específico.

# Obtener los nombres de todos los contenedores en un pod específico
kubectl get pod my-nginx-pod-12345 -o jsonpath='{.spec.containers[*].name}'

# Obtener la imagen del primer contenedor en un pod específico
kubectl get pod my-nginx-pod-12345 -o jsonpath='{.spec.containers[0].image}'

Iterando Sobre una Lista de Recursos (usando `range`)

Cuando kubectl get devuelve múltiples recursos (por ejemplo, todos los pods), la salida suele ser un objeto que contiene un array items. Necesitarás la función range de la plantilla Go para iterar a través de ellos.

# Listar todos los nombres de pods y sus IPs, cada uno en una nueva línea
kubectl get pods -o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.status.podIP}{"\n"}{end}'

# Listar todos los nombres de deployments y el número de réplicas listas
kubectl get deployments -o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.status.readyReplicas}{"\n"}{end}'

{range .items[*]}: Inicia una iteración sobre cada elemento en el array .items.
{.metadata.name}: Dentro del bucle, . se refiere al elemento actual (por ejemplo, un objeto Pod individual).
{"\t"}: Inserta un carácter de tabulación para formatear.
{"\n"}: Inserta un carácter de nueva línea.
{end}: Cierra el bucle range.

Salida Condicional: Usa Plantillas Go en su Lugar

kubectl -o jsonpath no admite bloques if, with o else de plantillas Go. Si necesitas renderizado condicional, cambia a -o go-template:

# Listar nombres de pods e imprimir N/A cuando podIP está vacío
kubectl get pods -o go-template='{{range .items}}{{.metadata.name}}{{"\t"}}{{if .status.podIP}}{{.status.podIP}}{{else}}N/A{{end}}{{"\n"}}{{end}}'

Para salida no condicional, JSONPath es más corto:

kubectl get pods -o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.status.podIP}{"\n"}{end}'

Formato Personalizado y Encabezado

Puedes agregar tu propio texto estático y crear un encabezado para tu salida tipo tabla.

# Salida personalizada para nombres de pods, imágenes y nodo, con un encabezado
kubectl get pods -o=jsonpath='{"NAME\tIMAGE\tNODE\n"}{range .items[*]}{.metadata.name}{"\t"}{.spec.containers[*].image}{"\t"}{.spec.nodeName}{"\n"}{end}'

Advertencia: kubectl tiene su propia implementación de JSONPath. Es útil para la extracción de campos y bucles range, pero no es lo mismo que jq y no admite todas las características de JSONPath que puedas conocer de otras herramientas.

Consejos para JSONPath

Empieza Simple: Comienza con una ruta básica, luego agrega más complejidad.
Inspecciona JSON: Siempre usa kubectl get <recurso> <nombre> -o json para entender la estructura exacta que estás consultando.
Escapa Caracteres: Recuerda escapar caracteres especiales como nuevas líneas (\n) y tabulaciones (\t) dentro de tu cadena de plantilla JSONPath si deseas que se rendericen como literales en la salida.
Guarda Plantillas: Para expresiones JSONPath complejas o de uso frecuente, guárdalas en un archivo y usa -o jsonpath-file=/ruta/a/plantilla.jsonpath.

Combinando Etiquetas y JSONPath

El verdadero poder proviene de combinar estas técnicas. Primero, usa selectores de etiquetas para reducir los recursos, y luego aplica JSONPath para extraer y formatear datos específicos de ese conjunto filtrado.

# Obtener los nombres y las imágenes de contenedores de todos los pods con 'app=my-app' y 'env=production'
kubectl get pods -l 'app=my-app,env=production' -o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.spec.containers[*].image}{"\n"}{end}'

# Obtener los nombres y las IPs de clúster de todos los servicios que tienen la etiqueta 'tier' establecida en 'backend'
kubectl get services -l tier=backend -o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.spec.clusterIP}{"\n"}{end}'

# Encontrar todos los pods que se ejecutan en un nodo específico 'worker-node-1' y listar sus nombres y estados
kubectl get pods --field-selector spec.nodeName=worker-node-1 -o jsonpath='{range .items[*]}{.metadata.name}{"\t"}{.status.phase}{"\n"}{end}'

Nota: Mientras que los selectores de etiquetas (-l) son para pares clave-valor arbitrarios, kubectl también ofrece --field-selector para filtrar basado en campos de recursos (por ejemplo, status.phase=Running, metadata.namespace=default). Esto proporciona otra capa poderosa de filtrado que se puede combinar tanto con etiquetas como con JSONPath.

Solución de Problemas y Errores Comunes

Errores de Sintaxis JSONPath: Incluso un pequeño error tipográfico puede romper la plantilla. Verifica dos veces llaves, puntos y acceso a arrays.
Campos Faltantes: Si un campo no existe para un recurso particular, JSONPath podría generar <no value> o una cadena vacía. Usa construcciones de plantilla Go if o with para manejar esto con elegancia.
Escapado del Shell: Las comillas simples alrededor de la expresión JSONPath son cruciales. Si tu expresión contiene comillas internas o caracteres especiales, podrías necesitar escapado adicional del shell.
Plantilla Go vs. JSONPath Puro: Recuerda que kubectl usa plantillas Go, no un motor JSONPath universal. Características como el filtrado avanzado (?()) son típicamente parte de jq u otros procesadores JSON dedicados, no soportados directamente en -o jsonpath de kubectl.
Array items Vacío: Si tu selector de etiquetas no coincide con ningún recurso, items estará vacío, y tu bucle range no producirá ninguna salida.

Conclusión

Dominar las técnicas avanzadas de kubectl get con selectores de etiquetas y JSONPath es una habilidad invaluable para cualquier usuario de Kubernetes. Estas potentes opciones de filtrado y formateo transforman kubectl get de una simple herramienta de listado a una utilidad sofisticada de extracción de datos. Puedes identificar rápidamente recursos problemáticos, generar informes personalizados o alimentar datos precisos en scripts de automatización.

Usa etiquetas para elegir los recursos, luego elige el formato de salida más simple que te proporcione los campos que necesitas. JSONPath es excelente para extracción compacta, custom-columns es más fácil para tablas rápidas, y jq o las plantillas Go son mejores cuando la salida necesita lógica real.