🥇Cómo utilizar kubectl de forma más eficaz: una guía detallada

Si trabaja con Kubernetes, kubectl es probablemente una de las utilidades que más utiliza. Y siempre que pases mucho tiempo trabajando con una herramienta en particular, vale la pena estudiarla bien y aprender a utilizarla de forma eficaz.

Equipo Kubernetes aaS de Mail.ru tradujo un artículo de Daniel Weibel en el que encontrará consejos y trucos para trabajar eficazmente con kubectl. También le ayudará a obtener una comprensión más profunda de Kubernetes.

Según el autor, el objetivo del artículo es hacer que su trabajo diario con Kubernetes no solo sea más eficiente, sino también más agradable.

Introducción: ¿Qué es kubectl?

Antes de poder aprender a utilizar kubectl de forma más eficaz, es necesario adquirir una comprensión básica de qué es y cómo funciona.

Desde la perspectiva del usuario, kubectl es un panel de control que le permite realizar operaciones de Kubernetes.

Técnicamente hablando, kubectl es un cliente API de Kubernetes.

La API de Kubernetes es una API REST HTTP. Esta API es la verdadera interfaz de usuario de Kubernetes, a través de la cual se controla completamente. Esto significa que cada operación de Kubernetes se expone como un punto final de API y se puede realizar con una solicitud HTTP a ese punto final.

Por lo tanto, el trabajo principal de kubectl es realizar solicitudes HTTP a la API de Kubernetes:

Kubernetes es un sistema completamente orientado a recursos. Esto significa que mantiene el estado interno de los recursos y todas las operaciones de Kubernetes son operaciones CRUD.

Usted tiene el control total de Kubernetes al administrar estos recursos, y Kubernetes determina qué hacer en función del estado actual de los recursos. Por este motivo, la referencia de la API de Kubernetes está organizada como una lista de tipos de recursos con sus operaciones asociadas.

Veamos un ejemplo.

Supongamos que desea crear un recurso ReplicaSet. Para hacer esto, describe el ReplicaSet en un archivo por nombre. replicaset.yaml, luego ejecute el comando:

$ kubectl create -f replicaset.yaml

Esto creará un recurso ReplicaSet. ¿Pero qué sucede detrás de escena?

Kubernetes tiene una operación de creación de ReplicaSet. Como cualquier otra operación, se expone como un punto final de API. El punto final API específico para esta operación tiene este aspecto:

POST /apis/apps/v1/namespaces/{namespace}/replicasets

Los puntos finales API para todas las operaciones de Kubernetes se pueden encontrar en Referencia API (incluyendo el punto final anterior). Para realizar una solicitud real a un punto final, primero debe agregar la URL del servidor API a las rutas de los puntos finales que se enumeran en la referencia de API.

Por lo tanto, cuando ejecuta el comando anterior, kubectl envía una solicitud HTTP POST al punto final API anterior. La definición de ReplicaSet que proporcionó en el archivo replicaset.yaml, se envía en el cuerpo de la solicitud.

Así es como funciona kubectl para todos los comandos que interactúan con el clúster de Kubernetes. En todos estos casos, kubectl simplemente realiza solicitudes HTTP a los puntos finales de la API de Kubernetes apropiados.

Tenga en cuenta que puede administrar Kubernetes completamente utilizando una utilidad como curlenviando manualmente solicitudes HTTP a la API de Kubernetes. Kubectl simplemente facilita el uso de la API de Kubernetes.

Estos son los conceptos básicos de qué es kubectl y cómo funciona. Pero hay algo más sobre la API de Kubernetes que todo usuario de kubectl debería saber. Echemos un vistazo rápido al mundo interior de Kubernetes.

El mundo interior de Kubernetes

Kubernetes consta de un conjunto de componentes independientes que se ejecutan como procesos separados en nodos del clúster. Algunos componentes se ejecutan en nodos maestros, otros en nodos trabajadores, y cada componente realiza su propia tarea específica.

Estos son los componentes más importantes de los nodos principales:

Almacenamiento - almacena definiciones de recursos (normalmente es etc.).
servidor API — proporciona una API y gestiona el almacenamiento.
Administrador del controlador — Garantiza que los estados de los recursos cumplan con las especificaciones.
Planificador — programa pods en nodos trabajadores.

Y aquí hay un componente más importante de los nodos trabajadores:

kubelet — gestiona el lanzamiento de contenedores en el nodo de trabajo.

Para comprender cómo funcionan juntos estos componentes, veamos un ejemplo.

Supongamos que acaba de completar kubectl create -f replicaset.yaml, después de lo cual kubectl realizó una solicitud HTTP POST a Punto final de la API ReplicaSet (pasando la definición de recurso ReplicaSet).

¿Qué está pasando en el grupo?

Después de hacer kubectl create -f replicaset.yaml El servidor API almacena su definición de recurso ReplicaSet en el almacenamiento:
A continuación, se inicia el controlador ReplicaSet en el administrador del controlador, que maneja la creación, modificación y eliminación de recursos ReplicaSet:
El controlador ReplicaSet crea una definición de pod para cada réplica de ReplicaSet (según la plantilla de pod en la definición de ReplicaSet) y las almacena en el almacenamiento:
Se inicia el programador, que rastrea los pods que aún no se han asignado a ningún nodo trabajador:
El programador selecciona un nodo trabajador adecuado para cada pod y agrega esta información a la definición del pod en la tienda:
En el nodo trabajador al que está asignado el pod, se inicia Kubelet, que realiza un seguimiento de los pods asignados a este nodo:
Kubelet lee la definición del pod desde el almacenamiento e indica a un tiempo de ejecución del contenedor, como Docker, que lance contenedores en el nodo:

A continuación se muestra una versión de texto de esta descripción.

El servidor API procesa la solicitud de API al punto final de creación de ReplicaSet. El servidor API autentica la solicitud y almacena la definición del recurso ReplicaSet en el almacenamiento.

Este evento inicia el controlador ReplicaSet, que es un subproceso del administrador del controlador. El controlador ReplicaSet monitorea la creación, actualización y eliminación de recursos ReplicaSet en el almacén y recibe una notificación de evento cuando esto ocurre.

El trabajo del controlador ReplicaSet es garantizar que exista la cantidad requerida de pods ReplicaSet. En nuestro ejemplo, todavía no existen pods, por lo que el controlador ReplicaSet crea estas definiciones de pod (de acuerdo con la plantilla de pod en la definición de ReplicaSet) y las almacena en el almacenamiento.

La creación de nuevos pods la activa un programador que realiza un seguimiento de las definiciones de pods que aún no están programadas para los nodos trabajadores. El programador selecciona un nodo trabajador adecuado para cada pod y actualiza las definiciones de pod en el repositorio.

Tenga en cuenta que hasta este momento, no se estaba ejecutando ningún código de carga de trabajo en ninguna parte del clúster. Todo lo que se ha hecho hasta ahora - esta es la creación y actualización de recursos en el repositorio del nodo maestro.

El último evento activa Kubelets, que monitorean los pods programados para sus nodos trabajadores. El Kubelet del nodo trabajador en el que están instalados los pods de ReplicaSet debe indicarle al tiempo de ejecución del contenedor, como Docker, que descargue las imágenes del contenedor requeridas y las ejecute.

¡En este punto, su aplicación ReplicaSet finalmente se está ejecutando!

Papel de la API de Kubernetes

Como vio en el ejemplo anterior, los componentes de Kubernetes (excepto el servidor API y el almacenamiento) vigilan los cambios en los recursos almacenados y cambian la información sobre los recursos almacenados.

Por supuesto, estos componentes no interactúan directamente con el almacenamiento, sino solo a través de la API de Kubernetes.

Considere los siguientes ejemplos:

El controlador ReplicaSet utiliza el punto final API lista de conjuntos de réplicas con parámetro watch para monitorear los cambios en los recursos de ReplicaSet.
El controlador ReplicaSet utiliza el punto final API crear pod (crear pod) para crear pods.
El programador utiliza el punto final API vaina de parche (editar pod) para actualizar los pods con información sobre el nodo trabajador seleccionado.

Como puede ver, esta es la misma API a la que accede kubectl. Usar la misma API para componentes internos y usuarios externos es un concepto fundamental en el diseño de Kubernetes.

Ahora podemos resumir cómo funciona Kubernetes:

Los almacenes de almacenamiento indican, es decir, los recursos de Kubernetes.
El servidor API proporciona una interfaz para el almacenamiento en forma de API de Kubernetes.
Todos los demás componentes y usuarios de Kubernetes leen, observan y manipulan el estado (recursos) de Kubernetes a través de la API.

Conocer estos conceptos te ayudará a comprender mejor kubectl y aprovecharlo al máximo.

Ahora veamos algunos consejos y trucos específicos que le ayudarán a mejorar su productividad con kubectl.

1. Acelere la entrada mediante la finalización de comandos

Una de las técnicas más útiles, pero a menudo pasada por alto, para mejorar el rendimiento con kubectl es la finalización de comandos.

La finalización de comandos le permite completar automáticamente partes de los comandos de kubectl usando la tecla Tab. Esto funciona para subcomandos, opciones y argumentos, incluido algo tan complejo como los nombres de recursos.

Vea cómo funciona la finalización del comando kubectl:

La finalización de comandos funciona para shells Bash y Zsh.

Guía oficial contiene instrucciones detalladas para configurar el autocompletado, pero a continuación proporcionaremos un breve extracto.

Cómo funciona la finalización de comandos

La finalización de comandos es una característica del shell que funciona mediante un script de finalización. Un script de extensión es un script de shell que define el comportamiento de una extensión para un comando específico.

Kubectl genera y genera automáticamente scripts de extensión para Bash y Zsh usando los siguientes comandos:

$ kubectl completion bash

Или:

$ kubectl completion zsh

En teoría, es suficiente conectar la salida de estos comandos al shell de comandos apropiado para que kubectl pueda complementar los comandos.

En la práctica, el método de conexión es diferente para Bash (incluidas las diferencias entre Linux y MacOS) y Zsh. A continuación veremos todas estas opciones.

bash en linux

El script de finalización de Bash depende del paquete de finalización de bash, por lo que primero debe instalarlo:

$ sudo apt-get install bash-completion

Или:

$ yum install bash-completion

Puede probar que el paquete se haya instalado correctamente utilizando el siguiente comando:

$ type _init_completion

Si esto genera un código de función de shell, entonces bash-completion está instalado correctamente. Si el comando muestra el error "No encontrado", debe agregar la siguiente línea a su archivo ~ / .bashrc:

$ source /usr/share/bash-completion/bash_completion

¿Es necesario agregar esta línea al archivo? ~ / .bashrc Depende o no del administrador de paquetes que utilizó para instalar bash-completion. Esto es necesario para APT, pero no para YUM.

Después de instalar bash-completion, debe configurar todo para que el script de finalización de kubectl esté habilitado en todas las sesiones de shell.

Una forma de hacer esto es agregar la siguiente línea al archivo ~ / .bashrc:

source <(kubectl completion bash)

Otra forma es agregar el script de extensión kubectl al directorio /etc/bash_completion.d (créelo si no existe):

$ kubectl completion bash >/etc/bash_completion.d/kubectl

Todos los scripts complementarios del catálogo /etc/bash_completion.d se incluyen automáticamente en bash-completion.

Ambas opciones son igualmente aplicables.

Después de reiniciar el shell, la finalización del comando kubectl funcionará.

Explosión en MacOS

En MacOS la configuración es un poco más complicada. El hecho es que, de forma predeterminada, MacOS usa la versión 3.2 de Bash y el script de autocompletado de kubectl requiere una versión de Bash de al menos 4.1 y no funciona en Bash 3.2.

Existen problemas de licencia asociados con el uso de una versión desactualizada de Bash en MacOS. La versión 4 de Bash tiene licencia GPLv3, que no es compatible con Apple.

Para configurar el autocompletado de kubectl en MacOS, debe instalar una versión más reciente de Bash. También puedes configurar el Bash actualizado como tu shell predeterminado, lo que te ahorrará muchos problemas en el futuro. No es difícil, los detalles se dan en el artículo "Actualización de Bash en MacOS".

Antes de continuar, asegúrese de estar utilizando una versión reciente de Bash (verifique el resultado bash --version).

El script de finalización de Bash varía según el proyecto finalización de bash, por lo que primero debes instalarlo.

Puedes instalar bash-completion usando Homebrew:

$ brew install bash-completion@2

es @2 significa bash-completion versión 2. El autocompletado de kubectl requiere bash-completion v2, y bash-completion v2 requiere un mínimo de Bash versión 4.1.

Salida del comando brew-install contiene una sección de Advertencias, que especifica lo que se debe agregar al archivo ~/.bash_profile:

export BASH_COMPLETION_COMPAT_DIR=/usr/local/etc/bash_completion.d
[[ -r "/usr/local/etc/profile.d/bash_completion.sh" ]] && . 
"/usr/local/etc/profile.d/bash_completion.sh"

Sin embargo, recomiendo agregar estas líneas para no ~/.bash_profile, Y en ~/.bashrc. En este caso, el autocompletado estará disponible no solo en el shell de comando principal, sino también en el secundario.

Después de reiniciar el shell de comandos, puede verificar que la instalación sea correcta usando el siguiente comando:

$ type _init_completion

Si ve una función de Shell en la salida, entonces todo está configurado correctamente.

Ahora debemos asegurarnos de que el autocompletado de kubectl esté habilitado en todas las sesiones.

Una forma es agregar la siguiente línea a su ~/.bashrc:

source <(kubectl completion bash)

La segunda forma es agregar un script de autocompletar a la carpeta. /usr/local/etc/bash_completion.d:

$ kubectl completion bash
>/usr/local/etc/bash_completion.d/kubectl

Este método solo funcionará si instaló bash-completion usando Homebrew. En este caso, bash-completion carga todos los scripts de este directorio.

Si instalaste kubectl usando Homebrew, entonces no es necesario realizar el paso anterior, ya que el script de autocompletado se colocará automáticamente en la carpeta /usr/local/etc/bash_completion.d durante la instalación. En este caso, el autocompletado de kubectl comenzará a funcionar tan pronto como instale bash-completion.

Como resultado, todas estas opciones son equivalentes.

Zsh

Los scripts de autocompletar para Zsh no requieren ninguna dependencia. Todo lo que necesitas hacer es habilitarlos cuando cargas el shell de comandos.

Puedes hacer esto agregando una línea a tu ~/.zshrc archivo:

source <(kubectl completion zsh)

Si recibe un error not found: compdef después de reiniciar su shell, necesita habilitar la función incorporada compdef. Puede habilitarlo agregándolo al principio de su archivo. ~/.zshrc следующее:

autoload -Uz compinit
compinit

2. Ver rápidamente las especificaciones de recursos

Cuando crea definiciones de recursos YAML, necesita conocer los campos y su significado para esos recursos. Un lugar para buscar esta información es la referencia de API, que contiene especificaciones completas para todos los recursos.

Sin embargo, cambiar al navegador web cada vez que necesita buscar algo es un inconveniente. Por lo tanto kubectl proporciona el comando kubectl explain, que muestra las especificaciones de todos los recursos directamente en tu terminal.

El formato del comando es el siguiente:

$ kubectl explain resource[.field]...

El comando generará la especificación del recurso o campo solicitado. La información mostrada es idéntica a la contenida en el manual de API.

Por defecto kubectl explain muestra solo el primer nivel de anidamiento de campos.

Mira como se ve A continuación, puede.

Puede mostrar el árbol completo si agrega la opción --recursive:

$ kubectl explain deployment.spec --recursive

Si no sabe exactamente qué recursos se necesitan, puede mostrarlos todos con el siguiente comando:

$ kubectl api-resources

Este comando muestra los nombres de los recursos en plural, p. deployments en lugar de deployment. También muestra el nombre corto, por ejemplo deploy, para aquellos recursos que lo tienen. No te preocupes por estas diferencias. Todas estas opciones de nombres son equivalentes para kubectl. Es decir, puedes utilizar cualquiera de ellos para kubectl explain.

Todos los siguientes comandos son equivalentes:

$ kubectl explain deployments.spec
# или
$ kubectl explain deployment.spec
# или        
$ kubectl explain deploy.spec

3. Utilice un formato de salida de columna personalizado

Formato de salida de comando predeterminado kubectl get:

$ kubectl get pods
NAME                     READY    STATUS    RESTARTS  AGE
engine-544b6b6467-22qr6   1/1     Running     0       78d
engine-544b6b6467-lw5t8   1/1     Running     0       78d
engine-544b6b6467-tvgmg   1/1     Running     0       78d
web-ui-6db964458-8pdw4    1/1     Running     0       78d

Este formato es conveniente, pero contiene una cantidad limitada de información. En comparación con el formato de definición de recursos completo, aquí solo se muestran unos pocos campos.

En este caso, puede utilizar un formato de salida de columna personalizado. Le permite determinar qué datos generar. Puede mostrar cualquier campo de recurso como una columna separada.

El uso de un formato personalizado se determina mediante las opciones:

-o custom-columns=<header>:<jsonpath>[,<header>:<jsonpath>]...

Puede definir cada columna de salida como un par <header>:<jsonpath>Donde <header> es el nombre de la columna, y <jsonpath> — una expresión que define un campo de recurso.

Veamos un ejemplo sencillo:

$ kubectl get pods -o custom-columns='NAME:metadata.name'

NAME
engine-544b6b6467-22qr6
engine-544b6b6467-lw5t8
engine-544b6b6467-tvgmg
web-ui-6db964458-8pdw4

La salida contiene una columna con los nombres de los pods.

La expresión de opción selecciona los nombres de los pods del campo. metadata.name. Esto se debe a que el nombre del pod está definido en el campo de nombre del niño. metadata en la descripción del recurso del pod. Más detalles se pueden encontrar en Guía API o escribe el comando kubectl explain pod.metadata.name.

Ahora digamos que desea agregar una columna adicional a la salida, por ejemplo, mostrando el nodo en el que se ejecuta cada pod. Para hacer esto, simplemente puede agregar la especificación de columna adecuada a la opción de columnas personalizadas:

$ kubectl get pods 
  -o custom-columns='NAME:metadata.name,NODE:spec.nodeName'

NAME                       NODE
engine-544b6b6467-22qr6    ip-10-0-80-67.ec2.internal
engine-544b6b6467-lw5t8    ip-10-0-36-80.ec2.internal
engine-544b6b6467-tvgmg    ip-10-0-118-34.ec2.internal
web-ui-6db964458-8pdw4     ip-10-0-118-34.ec2.internal

La expresión selecciona el nombre del nodo de spec.nodeName — cuando un pod se asigna a un nodo, su nombre se escribe en el campo spec.nodeName especificación de recursos del pod. Puede encontrar información más detallada en la salida. kubectl explain pod.spec.nodeName.

Tenga en cuenta que los campos de recursos de Kubernetes distinguen entre mayúsculas y minúsculas.

Puede ver cualquier campo de recurso como una columna. Simplemente revise la especificación del recurso y pruébelo con los campos que desee.

Pero primero, echemos un vistazo más de cerca a las expresiones de selección de campos.

Expresiones JSONPath

Las expresiones para seleccionar campos de recursos se basan en Ruta JSON.

JSONPath es un lenguaje para recuperar datos de documentos JSON. Seleccionar un solo campo es el caso de uso más simple para JSONPath. el tiene mucho más posibilidades, incluidos selectores, filtros, etc.

La explicación de Kubectl admite una cantidad limitada de funciones JSONPath. Las posibilidades y ejemplos de su uso se describen a continuación:

# Выбрать все элементы списка
$ kubectl get pods -o custom-columns='DATA:spec.containers[*].image'
# Выбрать специфический элемент списка
$ kubectl get pods -o custom-columns='DATA:spec.containers[0].image'
# Выбрать элементы списка, попадающие под фильтр
$ kubectl get pods -o custom-columns='DATA:spec.containers[?(@.image!="nginx")].image'
# Выбрать все поля по указанному пути, независимо от их имени
$ kubectl get pods -o custom-columns='DATA:metadata.*'
# Выбрать все поля с указанным именем, вне зависимости от их расположения
$ kubectl get pods -o custom-columns='DATA:..image'

El operador [] es especialmente importante. Muchos campos de recursos de Kubernetes son listas y este operador le permite seleccionar miembros de esas listas. A menudo se utiliza con un comodín como [*] para seleccionar todos los elementos de una lista.

Ejemplos de aplicación

Las posibilidades de utilizar un formato de salida de columna personalizado son infinitas, ya que puede mostrar cualquier campo o combinación de campos de recursos en la salida. A continuación se muestran algunas aplicaciones de muestra, pero siéntase libre de explorarlas usted mismo y encontrar aplicaciones que funcionen para usted.

Visualización de imágenes de contenedores para pods:

$ kubectl get pods 
  -o custom-columns='NAME:metadata.name,IMAGES:spec.containers[*].image'

NAME                        IMAGES
engine-544b6b6467-22qr6     rabbitmq:3.7.8-management,nginx
engine-544b6b6467-lw5t8     rabbitmq:3.7.8-management,nginx
engine-544b6b6467-tvgmg     rabbitmq:3.7.8-management,nginx
web-ui-6db964458-8pdw4      wordpress

Este comando muestra los nombres de las imágenes del contenedor para cada pod.

Recuerde que un pod puede contener varios contenedores, luego los nombres de las imágenes se mostrarán en una línea, separados por comas.

Visualización de zonas de disponibilidad de nodos:
```
$ kubectl get nodes 
  -o 
custom-columns='NAME:metadata.name,ZONE:metadata.labels.failure-domain.beta.kubernetes.io/zone'

NAME                          ZONE
ip-10-0-118-34.ec2.internal   us-east-1b
ip-10-0-36-80.ec2.internal    us-east-1a
ip-10-0-80-67.ec2.internal    us-east-1b
```
Este comando es útil si su clúster está alojado en una nube pública. Muestra la zona de disponibilidad para cada nodo.

La zona de disponibilidad es un concepto de nube que limita la zona de replicación a una región geográfica.

Las zonas de disponibilidad para cada nodo se obtienen a través de una etiqueta especial: failure-domain.beta.kubernetes.io/zone. Si el clúster se ejecuta en una nube pública, esta etiqueta se crea automáticamente y se completa con los nombres de las zonas de disponibilidad para cada nodo.

Las etiquetas no forman parte de la especificación de recursos de Kubernetes, por lo que no encontrará información sobre ellas en Guía API. Sin embargo, se pueden ver (como cualquier otra etiqueta) si solicitas información sobre los nodos en formato YAML o JSON:
```
$ kubectl get nodes -o yaml
# или
$ kubectl get nodes -o json
```
Esta es una excelente manera de aprender más sobre los recursos, además de aprender las especificaciones de los recursos.

4. Cambie fácilmente entre clústeres y espacios de nombres

Cuando kubectl realiza una solicitud a la API de Kubernetes, primero lee el archivo kubeconfig para obtener todos los parámetros necesarios para la conexión.

Por defecto el archivo kubeconfig es ~/.kube/config. Normalmente, este archivo se crea o actualiza mediante un comando especial.

Cuando trabaja con varios clústeres, su archivo kubeconfig contiene configuraciones para conectarse a todos esos clústeres. Necesita una forma de indicarle al comando kubectl con qué clúster está trabajando.

Dentro de un clúster, puede crear varios espacios de nombres: un tipo de clúster virtual dentro de un clúster físico. Kubectl también determina qué espacio de nombres usar según el archivo kubeconfig. Esto significa que también necesita una forma de indicarle al comando kubectl con qué espacio de nombres trabajar.

En este capítulo explicaremos cómo funciona y cómo hacer que funcione de manera efectiva.

Tenga en cuenta que es posible que tenga varios archivos kubeconfig enumerados en la variable de entorno KUBECONFIG. En este caso, todos estos archivos se combinarán en una configuración común en tiempo de ejecución. También puede cambiar el archivo kubeconfig predeterminado ejecutando kubectl con el parámetro --kubeconfig. Ver documentación oficial.

archivos kubeconfig

Veamos qué contiene exactamente el archivo kubeconfig:

Como puede ver, el archivo kubeconfig contiene un conjunto de contextos. El contexto consta de tres elementos:

Clúster: URL de API del servidor del clúster.
Usuario: credenciales de autenticación de usuario en el clúster.
Espacio de nombres: el espacio de nombres utilizado al unirse al clúster.

En la práctica, suelen utilizar un contexto por clúster en su kubeconfig. Sin embargo, puede tener múltiples contextos por clúster, diferenciados por usuario o espacio de nombres. Sin embargo, esta configuración multicontexto es poco común, por lo que suele haber un mapeo uno a uno entre clústeres y contextos.

En un momento dado, uno de los contextos está vigente:

Cuando kubectl lee un archivo de configuración, siempre toma información del contexto actual. En el ejemplo anterior, kubectl se conectará al clúster Hare.

En consecuencia, para cambiar a otro clúster, debe cambiar el contexto actual en el archivo kubeconfig:

Ahora kubectl se conectará al clúster de Fox.

Para cambiar a un espacio de nombres diferente en el mismo clúster, debe cambiar el valor del elemento del espacio de nombres para el contexto actual:

En el ejemplo anterior, kubectl utilizará el espacio de nombres Prod del clúster de Fox (anteriormente se configuró el espacio de nombres Test).

Tenga en cuenta que kubectl también proporciona opciones --cluster, --user, --namespace и --context, que le permiten sobrescribir elementos individuales y el contexto actual en sí, independientemente de lo que esté configurado en kubeconfig. Mirar kubectl options.

En teoría, puedes cambiar manualmente la configuración en kubeconfig. Pero es un inconveniente. Para simplificar estas operaciones, existen varias utilidades que le permiten cambiar los parámetros automáticamente.

Usar kubectx

Una utilidad muy popular para cambiar entre clústeres y espacios de nombres.

La utilidad proporciona comandos. kubectx и kubens para cambiar el contexto actual y el espacio de nombres respectivamente.

Como se mencionó, cambiar el contexto actual significa cambiar el clúster si solo tiene un contexto por clúster.

A continuación se muestra un ejemplo de cómo ejecutar estos comandos:

Básicamente, estos comandos simplemente editan el archivo kubeconfig como se describe anteriormente.

instalar kubectx, siga las instrucciones en Github.

Ambos comandos admiten el autocompletado de nombres de contexto y espacio de nombres, lo que elimina la necesidad de escribirlos por completo. Instrucciones para configurar el autocompletado aquí.

Otra característica útil kubectx es modo interactivo. Funciona en conjunto con la utilidad. fzf, que debe instalarse por separado. La instalación de fzf hace que el modo interactivo esté disponible automáticamente en kubectx. De forma interactiva, puede seleccionar contexto y espacio de nombres a través de la interfaz de búsqueda interactiva gratuita proporcionada por fzf.

Usando alias de shell

No necesita herramientas independientes para cambiar el contexto y el espacio de nombres actuales porque kubectl también proporciona comandos para esto. si, equipo kubectl config proporciona subcomandos para editar archivos kubeconfig.

Éstos son algunos de ellos:

kubectl config get-contexts: muestra todos los contextos;
kubectl config current-context: obtener el contexto actual;
kubectl config use-context: cambiar el contexto actual;
kubectl config set-context: cambia el elemento de contexto.

Sin embargo, utilizar estos comandos directamente no es muy conveniente porque son largos. Puede crear alias de shell para ellos que sean fáciles de ejecutar.

Creé un conjunto de alias basados en estos comandos que brindan una funcionalidad similar a kubectx. Aquí puedes verlos en acción:

Tenga en cuenta que los alias utilizan fzf para proporcionar una interfaz de búsqueda interactiva gratuita (como el modo interactivo de kubectx). Esto significa que necesitas instalar fzfpara utilizar estos alias.

Aquí están las definiciones de los alias mismos:

# Получить текущий контекст
alias krc='kubectl config current-context'
# Список всех контекстов
alias klc='kubectl config get-contexts -o name | sed "s/^/  /;|^  $(krc)$|s/ /*/"'
# Изменить текущий контекст
alias kcc='kubectl config use-context "$(klc | fzf -e | sed "s/^..//")"'

# Получить текущее пространство имен
alias krn='kubectl config get-contexts --no-headers "$(krc)" | awk "{print $5}" | sed "s/^$/default/"'
# Список всех пространств имен
alias kln='kubectl get -o name ns | sed "s|^.*/|  |;|^  $(krn)$|s/ /*/"'
# Изменить текущее пространство имен
alias kcn='kubectl config set-context --current --namespace "$(kln | fzf -e | sed "s/^..//")"'

Para establecer estos alias, debe agregar las definiciones anteriores a su archivo ~/.bashrc o ~/.zshrc y reinicia tu shell.

Uso de complementos

Kubectl le permite cargar complementos que se ejecutan de la misma manera que los comandos básicos. Puede, por ejemplo, instalar el complemento kubectl-foo y ejecutarlo ejecutando el comando kubectl foo.

Sería conveniente cambiar el contexto y el espacio de nombres de esta manera, por ejemplo ejecutando kubectl ctx cambiar el contexto y kubectl ns para cambiar el espacio de nombres.

He escrito dos complementos que hacen esto:

El trabajo de los complementos se basa en los alias de la sección anterior.

Así es como funcionan:

Tenga en cuenta que los complementos utilizan fzf para proporcionar una interfaz de búsqueda gratuita e interactiva (como el modo interactivo de kubectx). Esto significa que necesitas instalar fzfpara utilizar estos alias.

Para instalar complementos, necesita descargar scripts de shell llamados kubectl-ctx и kubectl-ns a cualquier directorio en su variable PATH y hacerlos ejecutables con, por ejemplo. chmod +x. Inmediatamente después de esto podrás utilizar kubectl ctx и kubectl ns.

5. Reducir la entrada con alias automáticos

Los alias de Shell son una buena manera de acelerar la escritura. Proyecto alias-kubectl contiene alrededor de 800 atajos para comandos básicos de kubectl.

Quizás te preguntes: ¿cómo recuerdas 800 alias? Pero no es necesario que los recuerdes todos, porque están construidos según un esquema simple, que se detalla a continuación:

Por ejemplo:

kgpooyaml - kubectl obtiene vainas oyaml
ksysgsvcw — kubectl -n kube-system obtiene svc w
ksysrmcm -kubectl -n kube-system rm cm
kgdepallsl - kubectl obtiene el despliegue de todos los sl

Como puede ver, los alias se componen de componentes, cada uno de los cuales representa un elemento específico del comando kubectl. Cada alias puede tener un componente para el comando, la operación y el recurso base, y varios componentes para los parámetros. Simplemente "rellene" estos componentes de izquierda a derecha según el diagrama anterior.

El diagrama detallado actual está en GitHub. Allí también podrás encontrar lista completa de alias.

Por ejemplo, el alias kgpooyamlall es equivalente al comando kubectl get pods -o yaml --all-namespaces.

El orden relativo de las opciones no es importante: comando kgpooyamlall es equivalente al comando kgpoalloyaml.

No es necesario utilizar todos los componentes como alias. Por ejemplo k, kg, klo, ksys, kgpo también puede ser usado. Además, puede combinar alias y comandos u opciones normales en la línea de comando:

Por ejemplo:

En lugar de kubectl proxy puede escribir k proxy.
En lugar de kubectl get roles puede escribir kg roles (Actualmente no existe ningún alias para el recurso Roles).
Para obtener datos para un pod específico, puede usar el comando kgpo my-pod — kubectl get pod my-pod.

Tenga en cuenta que algunos alias requieren un argumento de línea de comando. Por ejemplo, alias kgpol medio kubectl get pods -l. Opción -l requiere un argumento: una especificación de etiqueta. Si usas un alias se verá así kgpol app=ui.

Debido a que algunos alias requieren argumentos, los alias a, f y l deben usarse al final.

En general, una vez que domine este esquema, podrá derivar intuitivamente alias de los comandos que desea ejecutar y ahorrar mucho tiempo de escritura.

Instalacion

Para instalar kubectl-aliases, necesita descargar el archivo .kubectl_aliases desde GitHub e incluirlo en el archivo ~/.bashrc o ~/.zshrc:

source ~/.kubectl_aliases

Autocompletar

Como dijimos antes, a menudo agregas palabras adicionales a un alias en la línea de comando. Por ejemplo:

$ kgpooyaml test-pod-d4b77b989

Si utiliza la finalización del comando kubectl, probablemente haya utilizado la función de autocompletar para cosas como nombres de recursos. ¿Pero se puede hacer esto cuando se utilizan alias?

Esta es una pregunta muy importante porque si la función de autocompletar no funciona, perderá algunos de los beneficios de los alias.

La respuesta depende del shell que estés usando:

Para Zsh, la finalización de alias funciona de forma inmediata.
Desafortunadamente, para Bash, se requiere algo de trabajo para que funcione el autocompletado.

Habilitar el autocompletado para alias en Bash

El problema con Bash es que intenta completar (cada vez que presiona Tab) el alias, no el comando al que se refiere el alias (como lo hace Zsh, por ejemplo). Como no tiene secuencias de comandos de finalización para los 800 alias, la función de autocompletar no funciona.

proyecto alias completo proporciona una solución general a este problema. Se conecta al mecanismo de finalización de alias, expande internamente el alias a un comando y devuelve opciones de finalización para el comando completado. Esto significa que el relleno de un alias se comporta exactamente igual que el de un comando completo.

A continuación, primero explicaré cómo instalar complete-alias y luego cómo configurarlo para permitir la finalización de todos los alias de kubectl.

Instalación de alias completo

En primer lugar, el alias completo depende de finalización de bash. Por lo tanto, antes de instalar complete-alias, debe asegurarse de que bash-completion esté instalado. Las instrucciones de instalación se han proporcionado anteriormente para Linux y MacOS.

Nota importante para usuarios de MacOS: Al igual que el script de autocompletado de kubectl, el alias completo no funciona con Bash 3.2, que es el valor predeterminado en MacOS. En particular, el alias completo depende de bash-completion v2 (brew install bash-completion@2), que requiere al menos Bash 4.1. Esto significa que para usar alias completo en MacOS necesitas instalar una versión más reciente de Bash.

Necesitas descargar el script. bash_completion.sh de repositorio de GitHub e inclúyelo en tu archivo ~/.bashrc:

source ~/bash_completion.sh

Después de reiniciar el shell, el alias completo estará completamente instalado.

Habilitar el autocompletado para alias de kubectl

Técnicamente, el alias completo proporciona una función contenedora _complete_alias. Esta función verifica el alias y devuelve sugerencias de finalización para el comando de alias.

Para asociar una función con un alias específico, debe utilizar el mecanismo Bash integrado completar, instalar _complete_alias como función de finalización de alias.

Como ejemplo, tomemos el alias k, que representa el comando kubectl. instalar _complete_alias Como función complementaria para este alias, debes ejecutar el siguiente comando:

$ complete -F _complete_alias k

El resultado de esto es que cada vez que autocompleta un alias k, se llama a la función _complete_alias, que comprueba el alias y devuelve sugerencias de finalización para el comando kubectl.

Como segundo ejemplo, tomemos el alias kg, que denota kubectl get:

$ complete -F _complete_alias kg

Al igual que en el ejemplo anterior, cuando completa automáticamente kg, obtiene las mismas sugerencias de finalización que obtendría para kubectl get.

Tenga en cuenta que puede utilizar alias completo para cualquier alias en su sistema.

Por lo tanto, para habilitar el autocompletado para todos los alias de kubectl, debe ejecutar el comando anterior para cada uno de ellos. El siguiente fragmento hace exactamente esto, siempre que haya configurado kubectl-aliases en ~/.kubectl-aliases:

for _a in $(sed '/^alias /!d;s/^alias //;s/=.*$//' ~/.kubectl_aliases); 
do
  complete -F _complete_alias "$_a"
done

Este fragmento de código debe colocarse en su ~/.bashrc, reinicie el shell de comandos y la función de autocompletar estará disponible para los 800 alias de kubectl.

6. Ampliar kubectl con complementos

Desde versión 1.12, soportes kubectl mecanismo de complemento, que te permiten ampliar sus funciones con comandos adicionales.

Si está familiarizado con Mecanismos de complementos de Git, los complementos de kubectl se basan en el mismo principio.

En este capítulo, cubriremos cómo instalar complementos, dónde encontrarlos y cómo crear sus propios complementos.

Instalación de complementos

Los complementos de Kubectl se distribuyen como archivos ejecutables simples con el nombre como kubectl-x. Prefijo kubectl- es obligatorio, seguido de un nuevo subcomando kubectl que le permite llamar al complemento.

Por ejemplo, el complemento hello se distribuirá como un archivo llamado kubectl-hello.

Para instalar el complemento, debe copiar el archivo. kubectl-x a cualquier directorio en su RUTA y hacerlo ejecutable, por ejemplo con chmod +x. Inmediatamente después de esto puedes llamar al complemento con kubectl x.

Puede utilizar el siguiente comando para enumerar todos los complementos que están actualmente instalados en su sistema:

$ kubectl plugin list

Este comando también mostrará advertencias si tiene varios complementos con el mismo nombre o si hay un archivo de complementos que no es ejecutable.

Encontrar e instalar complementos usando Krew

Los complementos de Kubectl se pueden compartir o reutilizar como paquetes de software. Pero, ¿dónde puedes encontrar complementos que otros hayan compartido?

equipo del proyecto tiene como objetivo proporcionar una solución unificada para compartir, buscar, instalar y administrar complementos de kubectl. El proyecto se autodenomina "administrador de paquetes para complementos de kubectl" (Krew es similar a Elaborar cerveza).

Krew es una lista de complementos de kubectl que puede seleccionar e instalar. Al mismo tiempo, Krew también es un complemento para kubectl.

Esto significa que instalar Krew funciona esencialmente como instalar cualquier otro complemento de kubectl. Puede encontrar instrucciones detalladas en página de GitHub.

Los comandos más importantes de Krew son:

# Поиск в списке плагинов
$ kubectl krew search [<query>]
# Посмотреть информацию о плагине
$ kubectl krew info <plugin>
# Установить плагин
$ kubectl krew install <plugin>
# Обновить все плагины до последней версии
$ kubectl krew upgrade
# Посмотреть все плагины, установленные через Krew
$ kubectl krew list
# Деинсталлировать плагин
$ kubectl krew remove <plugin>

Tenga en cuenta que la instalación de complementos utilizando Krew no interfiere con la instalación de complementos utilizando el método estándar descrito anteriormente.

Tenga en cuenta que el comando kubectl krew list solo muestra complementos que se instalaron usando Krew, mientras que el comando kubectl plugin list enumera todos los complementos, es decir, los instalados con Krew y los instalados mediante otros métodos.

Encontrar complementos en otros lugares

Krew es un proyecto joven, actualmente en su lista de Sólo unos 30 complementos. Si no puede encontrar lo que necesita, puede encontrar complementos en otros lugares, como GitHub.

Recomiendo mirar la sección de GitHub. complementos de kubectl. Allí encontrará docenas de complementos disponibles que vale la pena consultar.

Escribiendo tus propios complementos

tu mismo puedes crear complementos - No es dificil. Necesitas crear un ejecutable que haga lo que necesitas, asígnale el nombre kubectl-x e instálelo como se describe arriba.

El archivo podría ser un script bash, un script python o una aplicación GO compilada; no importa. La única condición es que se pueda ejecutar directamente en el sistema operativo.

Creemos un complemento de ejemplo ahora mismo. En la sección anterior, utilizó el comando kubectl para enumerar los contenedores de cada pod. Es fácil convertir este comando en un complemento al que puede llamar, por ejemplo. kubectl img.

Crear un archivo kubectl-img el siguiente contenido:

#!/bin/bash
kubectl get pods -o custom-columns='NAME:metadata.name,IMAGES:spec.containers[*].image'

Ahora haga el archivo ejecutable con chmod +x kubectl-img y muévalo a cualquier directorio en su RUTA. Inmediatamente después de esto puedes usar el complemento. kubectl img.

Como se mencionó, los complementos de kubectl se pueden escribir en cualquier lenguaje de programación o scripting. Si está utilizando scripts de shell, la ventaja es poder llamar fácilmente a kubectl desde el complemento. Sin embargo, puedes escribir complementos más complejos en lenguajes de programación reales usando Biblioteca cliente de Kubernetes. Si estás usando Go, también puedes usar biblioteca cli-runtime, que existe específicamente para escribir complementos de kubectl.

Cómo compartir tus complementos

Si cree que sus complementos podrían ser útiles para otros, no dude en compartirlos en GitHub. Asegúrate de agregarlos al tema. complementos de kubectl.

También puede solicitar que se agregue su complemento a lista de tripulación. Las instrucciones sobre cómo hacer esto están en repositorios de GitHub.

Finalización del comando

Actualmente, los complementos no admiten el autocompletado. Es decir, debes ingresar el nombre completo del complemento y los nombres completos de los argumentos.

El repositorio GitHub kubectl para esta función tiene solicitud abierta. Por lo tanto, es posible que esta característica se implemente en algún momento en el futuro.

¡Buena suerte!

¿Qué más leer sobre el tema?:

Fuente: habr.com

Cómo utilizar kubectl de forma más eficaz: una guía detallada