• ¡Obtenga la seguridad de la aplicación de la manera correcta! Detectar, proteger, monitorear, acelerar y más ...
  • Kubernetes, también conocido como K8S, es una popular herramienta de orquestación de contenedores para administrar y escalar la infraestructura en contenedores.

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

    En este artículo, cubriremos algunos comandos comunes de kubectl que ayudan en la administración diaria de Kubernetes.

    Obteniendo kubectl

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

    En un Linux system, puede usar 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, agregue la ubicación a su PATH variable y hacerlo ejecutable con chmod +x mando.

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

    Y luego descárgalo reemplazando {version} con la última versión usando curl como:

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

    Para la versión 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 tiene curl en su sistema, también puede descargar el ejecutable kubectl usando su navegador como cualquier otra descarga.

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

    Verificar la configuración de kubectl

    Para verificar su 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 usar los comandos de kubectl en un clúster de Kubernetes, primero debemos establecer la configuración y el contexto. Se puede hacer con el propio comando kubectl.

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

    $ kubectl config view

    Para enumerar todos los contextos disponibles:

    $ kubectl config get-contexts

    Para obtener el contexto actual de kubectl:

    $ kubectl config current-context

    Podemos cambiar el contexto en uso usando:

    $ kubectl config use-context [cluster-name]

    Para autorizar que se agregue 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 solo el campo "client-key" en el "cluster-admin" sin tocar otros valores, podemos usar:

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

    O, como otro ejemplo, para configurar la autenticación básica para, digamos, la entrada "cluster-admin", puede especificar el nombre de usuario y la 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 desea que kubectl use un espacio de nombres específico y lo guarde para todos los comandos de kubectl posteriores en ese contexto:

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

    Creando Objetos

    kubectl se usa para implementar diferentes objetos admitidos en un clúster de Kubernetes. Su manifiesto se puede definir en un YAML or JSON archivo con extensión .yaml or .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, use:

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

    Para crear un 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 del repositorio como:

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

    Por ejemplo, para implementar una sola instancia del servidor web Nginx:

    $ kubectl create deployment nginx --image=nginx

    Finalmente, para implementar recursos directamente escribiendo el Ñame contenido en CLI sin hacer referencia a un archivo de manifiesto guardado real, 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 comando para enumerar los recursos implementados, obtener sus detalles y obtener más información sobre ellos.

    Para enumerar todos los servicios en el espacio de nombres predeterminado, use:

    $ kubectl get services

    De manera similar, para enumerar pods en todos los espacios de nombres, la sintaxis será:

    $ kubectl get pods --all-namespaces

    Si necesitamos enumerar más detalles de los pods implementados, use -o wide marcar como:

    $ kubectl get pods -o wide

    La sintaxis para obtener los detalles de la implementación es la siguiente:

    $ kubectl get deployment [deployment-name]

    Para obtener el contenido YAML de un pod, podemos usar -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 de manera similar para las vainas como:

    $ kubectl describe pods [pod-name]

    kubectl permite ordenar la salida según un campo en particular. Para enumerar los servicios ordenados por nombre de servicio, use:

    $ 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 solo las direcciones IP externas de todos los nodos, si están asignados, podemos usar -o jsonpath bandera con la siguiente sintaxis:

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

    Para obtener etiquetas adjuntas a un recurso, digamos pods, intente:

    $ kubectl get pods --show-labels

    Para obtener una lista de eventos, pero que está ordenada por marca de tiempo, podemos usar -sort-by marcar como:

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

    Si queremos comparar el estado actual del clúster con el estado en el que estaría el clúster si se aplicara el manifiesto, usamos diff comando como:

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

    Modificar recursos

    Los recursos implementados a menudo se modificarían para cualquier cambio de configuración.

    Para realizar una actualización continua de, digamos "www" contenedores de, digamos implementación de "frontend" actualizando su imagen, podemos usar:

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

    Podemos verificar el historial de implementaciones, incluida la revisión, como:

    $ kubectl rollout history deployment/frontend

    O para revertir a una implementación anterior, use:

    $ kubectl rollout undo deployment/frontend

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

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

    Y para verificar el estado de actualización continua, usamos:

    $ kubectl rollout status -w deployment/frontend

    Para reiniciar el despliegue de, diga "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, eliminar 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 se puede hacer usando:

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

    De manera similar, la anotación se puede agregar a un recurso usando:

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

    El ajuste de escala automático de una implementación es posible con:

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

    Aquí, dep-name es el nombre de la implementación que se va a escalar automáticamente y min-val y max-val indica el valor mínimo y máximo que se utilizará para el escalado automático.

    Editando recursos

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

    $ kubectl edit [api-resource-name]

    O para usar su propio editor alternativo, especifique KUBE_EDITOR me gusta:

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

    Escalar recursos

    El recurso de escalado es una de las funciones admitidas por Kubernetes y kubectl facilita hacerlo.

    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 escalará como:

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

    Además, podemos realizar un escalado en función del estado actual de implementación como:

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

    Eliminando recursos

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

    Para eliminar un pod usando la especificación del archivo JSON, usamos:

    $ 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-name, nosotros podemos usar:

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

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

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

    Interactuar con pods en ejecución

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

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

    $ kubectl logs [pod-name]

    O para volcar registros de pod con una etiqueta específica:

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

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

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

    También podemos transmitir registros como lo hacemos con Linux tail -f comando con kubectl's -f bandera también:

    $ kubectl logs -f [pod-name]

    La ejecución de 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 uso específico del espacio de nombres:

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

    Puede adjuntarlo a un contenedor en funcionamiento con attach mando:

    $ kubectl attach [pod-name] -i

    El reenvío de puertos se puede realizar 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 pod y obtener el uso de salida:

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

    El comando anterior funciona si el pod contiene un solo contenedor. Para cápsulas de varios contenedores, use:

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

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

    $ 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

    Interactuar con nodos y clústeres

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

    Para marcar un nodo como no programable, use:

    $ kubectl cordon [node-name]

    Para 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 usar:

    $ 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 usando:

    $ kubectl cluster-info dump

    O para volcar a un uso de archivo:

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

    Conclusión

    Kubernetes es la palabra de moda en la industria y saber cómo administrarla con eficacia siempre impulsará su carrera. kubectl es la interfaz principal para interactuar con un clúster de Kubernetes y este artículo demostró cuán poderosa es esta herramienta en manos de un usuario experimentado.

    Aún así, podemos cubrir solo una vista resumida de lo que más puede hacer kubectl. Para explorarlo con más detalle y ver qué es todo lo que admite, consulte su documentación oficial. aquí.