Como usar kubectl de forma mais eficaz: um guia detalhado

Vamos ver um exemplo simples:

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

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

A saída contém uma coluna com os nomes dos pods.

A expressão na opção seleciona os nomes dos pods do campo metadata.name. Isso porque o nome do pod é definido no campo filho name do campo metadata na descrição do recurso do pod. Para mais detalhes, consulte o guia da API ou digite o comando kubectl explain pod.metadata.name.

Agora, suponha que você queira adicionar uma coluna extra à saída, por exemplo, mostrando o nó em que cada pod está sendo executado. Para isso, você pode simplesmente adicionar a especificação de coluna correspondente na opção de colunas 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

A expressão seleciona o nome do nó de spec.nodeName — quando o pod é atribuído a um nó, seu nome é escrito no campo spec.nodeName da especificação de recursos do pod. Você pode encontrar mais informações na saída de kubectl explain pod.spec.nodeName.

Observe que os campos de recursos do Kubernetes são sensíveis a maiúsculas e minúsculas.

Você pode visualizar qualquer campo de recurso como uma coluna. Basta revisar a especificação do recurso e experimentá-la com quaisquer campos que você desejar.

Mas primeiro, vamos explorar mais detalhadamente as expressões de seleção de campos.

Expressões JSONPath

As expressões para seleção de campos de recursos são baseadas em JSONPath.

JSONPath é uma linguagem para extrair dados de documentos JSON. Selecionar um único campo é o caso de uso mais simples do JSONPath. Ele possui muitas mais funcionalidades, incluindo seletores, filtros e assim por diante.

O kubectl explain suporta um número limitado de funcionalidades do JSONPath. Abaixo estão descritas as funcionalidades e exemplos de como usá-las:

# Выбрать все элементы списка
$ 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'

Um operador especial é o []. Muitos campos de recursos do Kubernetes são listas, e esse operador permite selecionar elementos dessas listas. Ele é frequentemente usado com o caractere curinga como [*] para selecionar todos os elementos da lista.

Exemplos de aplicação.

As possibilidades de usar o formato de saída personalizado de colunas são ilimitadas, já que você pode exibir qualquer campo ou combinação de campos de recurso na saída. Aqui estão alguns exemplos de aplicações, mas sinta-se à vontade para explorá-las você mesmo e encontrar usos que sejam úteis para você.

1. Exibindo imagens de contêineres 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

   Esse comando exibe os nomes das imagens dos contêineres para cada pod.

   Lembre-se de que um pod pode conter vários contêineres, e os nomes das imagens serão exibidos em uma única linha, separados por vírgulas.

2. Exibição das zonas de disponibilidade dos nós:

   $ 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 é útil se seu cluster estiver hospedado na nuvem pública. Ele exibe a zona de disponibilidade para cada nó.

   Uma zona de disponibilidade é um conceito de nuvem que restrige a zona de replicação a uma região geográfica.

   As zonas de disponibilidade para cada nó são obtidas através de um rótulo especial — failure-domain.beta.kubernetes.io/zone. Se o cluster estiver em execução em uma nuvem pública, esse rótulo é criado automaticamente e preenchido com os nomes das zonas de disponibilidade para cada nó.

   Os rótulos não são parte da especificação de recursos do Kubernetes, então você não encontrará informações sobre eles em guia da API. No entanto, eles podem ser vistos (como qualquer outro rótulo) se você solicitar informações sobre os nós no formato YAML ou JSON:

   $ kubectl get nodes -o yaml
   # ou
   $ kubectl get nodes -o json

   Essa é uma ótima maneira de aprender mais sobre os recursos, além de estudar as especificações de recursos.

4. Alternância fácil entre clusters e namespaces

Quando o kubectl faz uma solicitação à API do Kubernetes, ele lê o arquivo kubeconfig para obter todos os parâmetros necessários para a conexão.

Por padrão, o arquivo kubeconfig é ~/.kube/config. Normalmente, esse arquivo é criado ou atualizado por um comando específico.

Quando você trabalha com vários clusters, seu arquivo kubeconfig contém parâmetros de conexão para todos esses clusters. Você precisa de uma maneira de informar ao kubectl qual cluster você está usando.

Dentro de um cluster, você pode criar vários namespaces — uma espécie de cluster virtual dentro de um cluster físico. O kubectl também determina qual namespace usar com base nas informações do arquivo kubeconfig. Portanto, você também precisa de uma maneira de informar ao kubectl qual namespace trabalhar.

Nesta seção, vamos explicar como isso funciona e como atingir uma operação eficaz.

Observe que você pode ter vários arquivos kubeconfig listados na variável de ambiente KUBECONFIG. Nesse caso, todos esses arquivos serão combinados em uma única configuração geral durante a execução. Você também pode alterar o arquivo kubeconfig padrão, executando kubectl com o parâmetro --kubeconfig. Veja a documentação oficial.

Arquivos kubeconfig

Vamos examinar o que exatamente contém o arquivo kubeconfig:

Como você pode ver, o arquivo kubeconfig contém um conjunto de contextos. Um contexto consiste em três elementos:

• Cluster — URL da API do servidor do cluster.
• User — credenciais de autenticação do usuário no cluster.
• Namespace — espaço de nomes usado ao se conectar ao cluster.

Na prática, é comum usar um único contexto por cluster em seu arquivo kubeconfig. No entanto, você pode ter vários contextos por cluster, diferenciados por usuário ou espaço de nomes. Entretanto, essa configuração com múltiplos contextos é rara, portanto, geralmente há um mapeamento um-para-um entre clusters e contextos.

A qualquer momento, um dos contextos é o atual:

Quando o kubectl lê o arquivo de configuração, ele sempre usa as informações do contexto atual. No exemplo acima, o kubectl se conectará ao cluster Hare.

Assim, para mudar para outro cluster, você precisa alterar o contexto atual no arquivo kubeconfig:

Agora, o kubectl se conectará ao cluster Fox.

Para mudar para outro espaço de nomes no mesmo cluster, você deve alterar o valor do elemento namespace para o contexto atual:

No exemplo acima, o kubectl usará o espaço de nomes Prod do cluster Fox (anteriormente estava definido para o espaço de nomes Test).

Observe que o kubectl também fornece os parâmetros --cluster, --user, --namespace e --context, que permitem sobrescrever elementos específicos e o próprio contexto atual, independentemente do que está configurado no arquivo kubeconfig. Veja opções do kubectl.

Teoricamente, você pode alterar manualmente os parâmetros no arquivo kubeconfig. Mas isso é inconveniente. Para simplificar essas operações, existem várias ferramentas que permitem mudar os parâmetros automaticamente.

Use kubectx

Uma ferramenta muito popular para alternar entre clusters e espaços de nomes.

A utilidade fornece comandos kubectx e kubens para alterar o contexto atual e o namespace, respectivamente.

Como mencionado anteriormente, mudar o contexto atual significa alterar o cluster, se você tiver apenas um contexto por cluster.

Aqui está um exemplo de execução desses comandos:

Essencialmente, esses comandos apenas editam o arquivo kubeconfig, como descrito acima.

Para instalar kubectx, siga as instruções em Github.

Ambos os comandos suportam a autocompletação de nomes de contextos e namespaces, permitindo que você não precise digitá-los completamente. As instruções para configurar a autocompletação aqui.

Outra função útil kubectx é modo interativo. Ele funciona em conjunto com a utilidade fzf, que deve ser instalada separadamente. A instalação do fzf torna o modo interativo automaticamente disponível em kubectx. No modo interativo, você pode escolher o contexto e o namespace através de uma interface de busca livre interativa fornecida pelo fzf.

Uso de aliases de shell

Você não precisa de ferramentas separadas para mudar o contexto atual e o namespace, pois o kubectl também fornece comandos para isso. Assim, o comando kubectl config fornece subcomandos para editar arquivos kubeconfig.

Aqui estão algumas delas:

• kubectl config get-contexts: listar todos os contextos;
• kubectl config current-context: obter o contexto atual;
• kubectl config use-context: mudar o contexto atual;
• kubectl config set-context: modificar o item de contexto.

No entanto, usar esses comandos diretamente não é muito conveniente, pois são longos. É possível criar aliases de shell para eles, que são fáceis de executar.

Eu criei um conjunto de aliases com base nesses comandos, que fornecem funcionalidade semelhante ao kubectx. Aqui você pode ver sua ação:

Observe que os aliases usam fzf para fornecer uma interface de busca livre interativa (como no modo interativo do kubectx). Isso significa que você precisa instalar o fzf, para usar esses aliases.

Aqui estão as definições dos aliases:

# Получить текущий контекст
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 instalar esses aliases, você deve adicionar as definições acima ao seu arquivo ~/.bashrc ou ~/.zshrc e reiniciar seu shell.

Uso de plugins

O Kubectl permite carregar plugins, que são executados da mesma forma que os comandos principais. Você pode, por exemplo, instalar o plugin kubectl-foo e executá-lo fazendo o comando kubectl foo.

Seria conveniente alternar o contexto e o namespace dessa forma, por exemplo, executando kubectl ctx para mudar o contexto e kubectl ns para mudar o namespace.

Eu escrevi dois plugins que fazem isso:

• kubectl-ctx
• kubectl-ns

O funcionamento dos plugins baseia-se nos aliases da seção anterior.

Aqui está como eles funcionam:

Observe que os plugins usam fzf para fornecer uma interface interativa de busca livre (como no modo interativo kubectx). Isso significa que você precisa instalar o fzf, para usar esses aliases.

Para instalar os plugins, você precisa baixar os scripts de shell com os nomes kubectl-ctx e kubectl-ns em qualquer diretório na sua variável PATH e torná-los executáveis, por exemplo, com chmod +x. Após isso, você poderá usar kubectl ctx e kubectl ns.

5. Redução de entrada com auto-aliases

Os aliases de shell são uma ótima maneira de acelerar a entrada. O projeto kubectl-aliases contém cerca de 800 abreviações para os principais comandos kubectl.

Você pode se perguntar — como lembrar 800 aliases? Mas não é necessário lembrar todos, pois eles são construídos de acordo com um esquema simples, que está detalhado abaixo:

Por exemplo:

1. kgpooyaml — kubectl get pods oyaml
2. ksysgsvcw — kubectl -n kube-system get svc w
3. ksysrmcm — kubectl -n kube-system rm cm
4. kgdepallsl — kubectl get deployment all sl

Como você pode ver, os aliases são compostos por componentes, cada um representando um elemento específico do comando kubectl. Cada alias pode ter um componente para o comando base, operação e recurso, e vários componentes para parâmetros. Você simplesmente 'preenche' esses componentes da esquerda para a direita, de acordo com o esquema apresentado acima.

A lista detalhada atual está em GitHub. Lá você também pode encontrar a lista completa de pseudônimos.

Por exemplo, o alias kgpooyamlall é equivalente ao comando kubectl get pods -o yaml --all-namespaces.

A ordem relativa das opções não importa: o comando kgpooyamlall é equivalente ao comando kgpoalloyaml.

Você não precisa usar todos os componentes como aliases. Por exemplo, k, kg, klo, ksys, kgpo também podem ser usados. Além disso, na linha de comando, você pode combinar aliases e comandos ou opções normais:

Por exemplo:

1. Em vez de kubectl proxy você pode escrever k proxy.
2. Em vez de kubectl get roles você pode escrever kg roles (atualmente não existe um alias para o recurso Roles).
3. Para obter dados de um pod específico, você pode usar o comando kgpo my-pod — kubectl get pod my-pod.

Observe que alguns aliases exigem um argumento na linha de comando. Por exemplo, o alias kgpol significa kubectl get pods -l. Opção --selector exige um argumento - uma especificação de etiqueta. Se você usar um alias, ele deve parecer como kgpol app=ui.

Devido a parte dos aliases exigir argumentos, os aliases a, f e l devem ser usados por último.

No geral, assim que você dominar esse esquema, poderá intuitivamente derivar aliases dos comandos que deseja executar, economizando muito tempo na digitação.

Instalação

Para instalar o kubectl-aliases, você precisa baixar o arquivo .kubectl_aliases do GitHub e incluí-lo no arquivo ~/.bashrc ou ~/.zshrc:

source ~/.kubectl_aliases

Autocompletar

Como já mencionamos, você frequentemente adiciona palavras adicionais ao alias na linha de comando. Por exemplo:

$ kgpooyaml test-pod-d4b77b989

Se você usa a autocompletação do comando kubectl, provavelmente utilizou a autocompletação para coisas como nomes de recursos. Mas é possível fazer isso quando se usam aliases?

Essa é uma questão muito importante, pois, se a autocompletação não funcionar, você perderá parte das vantagens dos aliases.

A resposta depende do shell que você está usando:

1. Para Zsh, a autocompletação para aliases funciona ‘pronto para uso’.
2. Para Bash, infelizmente, são necessárias algumas etapas para fazer a autocompletação funcionar.

Habilitando a autocompletação para aliases no Bash

O problema com o Bash é que ele tenta completar (toda vez que você pressiona Tab) o alias, não o comando ao qual o alias se refere (como o Zsh faz). Como você não tem scripts de autocompletação para todos os 800 aliases, a autocompletação não funciona.

Projeto complete-alias oferece uma solução geral para esse problema. Ele se conecta ao mecanismo de autocompletação para aliases, completa o alias para o comando e retorna opções de autocompletação para o comando complementado. Isso significa que a autocompletação para o alias se comporta exatamente como para um comando completo.

A seguir, explicarei primeiro como instalar o complete-alias e depois como configurá-lo para habilitar a autocompletação para todos os aliases do kubectl.

Instalando o complete-alias

Antes de tudo, o complete-alias depende de bash-completion. Portanto, antes de instalar o complete-alias, você deve garantir que o bash-completion esteja instalado. As instruções de instalação foram dadas anteriormente para Linux e MacOS.

Nota importante para usuários de MacOS: assim como o script de autocompletação do kubectl, o complete-alias não funciona com o Bash 3.2, que é o padrão usado no MacOS. Em particular, o complete-alias depende do bash-completion v2 (brew install bash-completion@2), que requer pelo menos o Bash 4.1. Isso significa que para usar complete-alias no MacOS, você precisa instalar uma versão mais recente do Bash.

Você precisa baixar o script bash_completion.sh do do repositório GitHub e incluí-lo no seu arquivo ~/.bashrc:

source ~/bash_completion.sh

Após reiniciar o shell, o complete-alias estará completamente instalado.

Ativando o autocompletar para aliases kubectl

Tecnicamente, o complete-alias fornece uma função de shell _complete_alias. Essa função verifica o alias e retorna sugestões de complementação para o comando do alias.

Para vincular a função a um alias específico, você deve usar o mecanismo embutido do Bash complete, para definir _complete_alias como uma função de complemento do alias.

Por exemplo, vamos considerar o alias k, que representa o comando kubectl. Para definir _complete_alias como função de complemento para esse alias, você deve executar o seguinte comando:

$ complete -F _complete_alias k

O resultado disso é que sempre que você usar a autocompletação para o alias k, a função _complete_alias, que verifica o alias e retorna sugestões de complementação para o comando será chamada. kubectl.

Como segundo exemplo, vamos considerar o alias kg, que representa kubectl get:

$ complete -F _complete_alias kg

Da mesma forma que no exemplo anterior, ao autocompletar kg, você recebe as mesmas sugestões de complementação que receberia para kubectl get.

Observe que você pode usar o complete-alias para qualquer alias no seu sistema.

Portanto, para ativar a autocompletação para todos os aliases kubectl, você precisa executar o comando mencionado acima para cada um deles. O fragmento a seguir faz exatamente isso, assumindo que você instalou kubectl-aliases em ~/ .kubectl-aliases:

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

Esse código deve ser colocado no seu ~/.bashrc, reinicie o shell e a autocompletação estará disponível para todos os 800 aliases kubectl.

6. Expandindo kubectl com plugins

Começando com a versão 1.12, kubectl suporta um mecanismo de plugins, que permite expandir suas funções com comandos adicionais.

Se você está familiarizado com mecanismos de plugins do Git, os plugins do kubectl são construídos de maneira semelhante.

Nesta seção, vamos mostrar como instalar plugins, onde encontrá-los e como criar seus próprios plugins.

Instalação de plugins

Os plugins kubectl são distribuídos como arquivos executáveis simples com nomes do tipo kubectl-x. O prefixo kubectl- é obrigatório, seguido por um novo subcomando kubectl que permite chamar o plugin.

Por exemplo, o plugin hello será distribuído como um arquivo com o nome kubectl-hello.

Para instalar o plugin, você deve copiar o arquivo kubectl-x para qualquer diretório na sua variável PATH e torná-lo executável, por exemplo, usando chmod +x. Imediatamente após isso, você pode chamar o plugin usando kubectl x.

Você pode usar o seguinte comando para listar todos os plugins que estão atualmente instalados no seu sistema:

$ kubectl plugin list

Este comando também exibe avisos, se você tiver vários plugins com os mesmos nomes, ou se houver um arquivo de plugin que não seja executável.

Busca e instalação de plugins usando Krew

Os plugins Kubectl são adequados para compartilhamento ou reutilização, semelhantes a pacotes de software. Mas onde você pode encontrar plugins que foram compartilhados por outros?

O projeto Krew visa fornecer uma solução unificada para compartilhar, buscar, instalar e gerenciar plugins kubectl. O projeto se descreve como um "gerenciador de pacotes para plugins kubectl" (Krew é semelhante ao Brew).

Krew é uma lista de plugins kubectl que você pode escolher e instalar. Além disso, Krew também é um plugin para kubectl.

Isso significa que a instalação do Krew funciona, na essência, como a instalação de qualquer outro plugin kubectl. Você pode encontrar instruções detalhadas na página do GitHub.

Os comandos Krew mais importantes:

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

Tenha em mente que a instalação de plugins usando Krew não interfere na instalação de plugins pelo método padrão descrito acima.

Observe que o comando kubectl krew list exibe apenas os plugins que foram instalados através do Krew, enquanto o comando kubectl plugin list lista todos os plugins, ou seja, aqueles instalados com o Krew e aqueles instalados de outras formas.

Busca de plugins em outros lugares

Krew é um projeto jovem, atualmente na sua lista há cerca de 30 plugins. Se você não conseguir encontrar o que precisa, pode encontrar plugins em outro lugar, por exemplo, no GitHub.

Recomendo verificar a seção do GitHub kubectl-plugins. Lá você encontrará várias dezenas de plugins disponíveis que vale a pena conferir.

Escrita de seus próprios plugins

Você pode criar plugins — não é difícil. Você só precisa criar um arquivo executável que faça o que precisa, nomeá-lo como kubectl-x e instalá-lo, conforme descrito acima.

O arquivo pode ser um script bash, um script python ou um aplicativo go compilado — não importa. A única condição é que ele deve ser executável diretamente no sistema operacional.

Vamos criar um exemplo de plugin agora mesmo. No seção anterior, você usou o comando kubectl para listar os contêineres de cada pod. É fácil transformar esse comando em um plugin que você pode chamar, por exemplo, usando kubectl img.

Crie um arquivo kubectl-img users.module.ts

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

Agora torne o arquivo executável com chmod +x kubectl-img e mova-o para qualquer diretório no seu PATH. Logo após, você pode usar o plugin kubectl img.

Como mencionado, os plugins kubectl podem ser escritos em qualquer linguagem de programação ou script. Se você usar scripts de shell, há a vantagem de poder chamar facilmente o kubectl a partir do plugin. No entanto, você pode escrever plugins mais complexos em linguagens de programação reais, usando a biblioteca cliente do Kubernetes. Se você estiver usando Go, também pode usar a biblioteca cli-runtime, que existe especialmente para escrever plugins kubectl.

Como compartilhar seus plugins

Se você achar que seus plugins podem ser úteis para outros, sinta-se à vontade para compartilhá-los no GitHub. Certifique-se de adicioná-los ao tópico kubectl-plugins.

Você também pode solicitar a adição do seu plugin à lista Krew. As instruções sobre como fazer isso estão em repositório GitHub.

Autocompletar comandos

Atualmente, os plugins não suportam autocompletar. Ou seja, você deve digitar o nome completo do plugin e os nomes completos dos argumentos.

No repositório GitHub do kubectl, há uma solicitação aberta. Portanto, é possível que essa função seja implementada em algum momento no futuro.

Boa sorte!!!

O que mais ler sobre o assunto:

1. Três níveis de autoescala no Kubernetes e como usá-los de forma eficaz.
2. Kubernetes no espírito da pirataria com um modelo de implementação.
3. Nosso canal Ao Redor do Kubernetes no Telegram.

Fonte: habr.com