Revisão do k9s — uma interface de terminal avançada para Kubernetes

K9s fornece uma interface de terminal para interagir com clusters Kubernetes. O objetivo deste projeto Open Source é facilitar a navegação em aplicativos no K8s, monitorà-los e gerenciá-los. K9s monitora constantemente mudanças no Kubernetes e oferece comandos rápidos para trabalhar com os recursos observados.

O projeto foi escrito em Go e existe há mais de um ano e meio: o primeiro commit foi feito em 1º de fevereiro de 2019. No momento da redação deste artigo, há mais de 9000 estrelas no GitHub e cerca de 80 colaboradores. Vamos ver o que o k9s pode fazer?

Instalação e execução

Este é um aplicativo cliente (em relação ao cluster Kubernetes) que é mais fácil de executar como uma imagem Docker:

docker run --rm -it -v $KUBECONFIG:/root/.kube/config quay.io/derailed/k9s

Para algumas distribuições Linux e outros sistemas operacionais, também há pacotes prontos para instalação pacotes. Em geral, para sistemas Linux, você pode instalar o arquivo binário:

sudo wget -qO- https://github.com/derailed/k9s/releases/download/v0.22.0/k9s_Linux_x86_64.tar.gz | tar zxvf - -C /tmp/
sudo mv /tmp/k9s /usr/local/bin

Não há requisitos específicos para o próprio cluster K8s. Segundo relatos, o aplicativo funciona até mesmo com versões antigas do Kubernetes, como 1.12.

O aplicativo é iniciado usando a configuração padrão .kube/config — similar ao que faz kubectl.

Navegação

Por padrão, uma janela é aberta com o namespace padrão que é especificado para o contexto. Ou seja, se você especificou kubectl config set-context --current --namespace=test, então o namespace test. será aberto (sobre como trocar entre contextos/namespaces, veja abaixo).

Entrar no modo comandos é feito pressionando “:”. Após isso, você pode gerenciar o k9s usando comandos — por exemplo, para ver a lista de StatefulSets (no namespace atual), você pode digitar :sts.

Para alguns outros recursos do Kubernetes:

• :ns — Namespaces;
• :deploy — Deployments;
• :ing — Ingresses;
• :svc — Services.

Para listar todos os tipos de recursos disponíveis para visualização, existe o comando :aliases.

É conveniente visualizar a lista de comandos disponíveis por combinações de teclas dentro da janela atual: para isso, basta pressionar “?”.

O k9s também possui modo de busca, para o qual você pode acessar simplesmente digitando “/”. Isso permite pesquisar no conteúdo da janela atual. Por exemplo, se você tiver digitado :ns, você terá uma lista de namespaces aberta. Se houver muitos, para não rolar longamente para baixo, basta digitar na janela de namespaces. /mynamespace.

Para buscar por rótulos, você pode selecionar todos os pods no namespace desejado e, em seguida, digitar, por exemplo, / -l app=whoami. Receberemos uma lista de pods com esse rótulo:

A busca funciona em todos os tipos de janelas, incluindo logs, visualização de manifestos YAML e describe para recursos — veja mais sobre essas funcionalidades abaixo.

Como é, em geral, a sequência de ações para navegação?

Com o comando :ctx é possível selecionar o contexto:

Para selecionar o namespace, já existe o comando mencionado anteriormente :ns, e depois você pode usar a busca para o namespace necessário: /test.

Se agora selecionar o recurso que nos interessa (por exemplo, o StatefulSet), as informações correspondentes aparecerão: quantos pods estão em execução com um resumo sobre eles.

Podem ser interessantes apenas os pods — então basta digitar :pod. No caso dos ConfigMaps (:cm — para a lista desses recursos) você pode escolher o objeto de interesse e pressionar 'u', após o que o K9s indicará quem especificamente utiliza (este CM).

Mais um recurso conveniente para visualizar recursos — seu ‘raio X’ (XRay view). Esse modo é chamado pelo comando :xray RESOURCE e… é mais fácil mostrar como funciona do que explicar. Aqui está uma ilustração para StatefulSets:

(Cada um desses recursos pode ser editado, alterado, feito describe.)

Aqui está um Deployment com Ingress:

Trabalho com recursos

Sobre cada recurso, você pode obter informações em YAML ou describe pressionando as combinações de teclas correspondentes ('y' e 'd', respectivamente). As operações básicas, é claro, são ainda mais numerosas: sua lista e combinações de teclas estão sempre à vista graças ao conveniente ‘cabeçalho’ na interface (esconde-se pressionando Ctrl + e).

Ao editar qualquer recurso ('e' após sua seleção) um editor de texto é aberto, definido nas variáveis de ambiente (export EDITOR=vim).

Aqui está como aparece a descrição detalhada do recurso (describe):

Essa saída (ou a saída visualizando o manifesto YAML do recurso) pode ser salva com a combinação de teclas familiar Ctrl + s. Para onde será salva, você saberá pela mensagem do K9s:

Log /tmp/k9s-screens-root/kubernetes/Describe-1601244920104133900.yml salvo com sucesso!

A partir dos arquivos de backup criados, você também pode restaurar recursos, removendo previamente os rótulos e anotações do sistema. Para isso, você precisará acessar o diretório com eles (:dir /tmp), após o que deverá selecionar o arquivo desejado e aplicar apply.

Vale lembrar que você pode reverter a qualquer momento para um ReplicaSet anterior se houver problemas com o atual. Para isso, é necessário escolher o RS desejado (:rs da lista deles):

… e executar o rollback pressionando Ctrl + l. Devemos receber uma notificação de que tudo foi bem-sucedido:

k9s/whoami-5cfbdbb469 revertido com sucesso

Para escalar as réplicas, basta pressionar "s" (scale) e escolher o número desejado de instâncias:

É possível acessar qualquer um dos contêineres usando shell: para isso, vá para o pod desejado, pressione "s" (shell) e escolha o contêiner.

Outras possibilidades

Claro, também é possível visualizar logs ("l" para o recurso selecionado). Para visualizar novos logs, não é necessário pressionar Enter constantemente: basta marcar ("m"), e depois acompanhar apenas as novas mensagens.

Neste mesmo painel, é possível escolher um intervalo de tempo para a exibição dos logs:

• a tecla "1" — para 1 minuto;
• "2" — para 5 minutos;
• "3" — para 15 minutos;
• "4" — para 30 minutos;
• "5" — para 1 hora;
• "0" — para todo o tempo de vida do pod.

Um modo de operação especial chamado Pulse (comando :pulse) exibe informações gerais sobre o cluster Kubernetes:

Nele, é possível ver a quantidade de recursos e seu estado (aqueles que estão com status são mostrados em verde Em execução).

Outra função interessante do K9s é chamada Popeye. Ela verifica todos os recursos com base em determinados critérios de correção e exibe a "classificação" resultante com explicações. Por exemplo, é possível ver que faltam probes ou limites, e que algum contêiner pode ser executado como root...

Há suporte básico para Helm. Por exemplo, é possível ver os releases implantados no cluster:

:helm all # tudo
:helm $namespace # em um namespace específico

Benchmark

O K9s até inclui hey — um gerador simples de carga para o servidor HTTP, alternativa ao mais conhecido ab (ApacheBench).

Para ativá-lo, será necessário ativar a port-forward no pod. Para isso, escolha o pod e pressione Shift + f, passando para o submenu de port-forward através do alias "pf".

Após escolher a porta e pressionar Ctrl + b, o benchmark será iniciado. Os resultados de seu funcionamento são salvos em /tmp e estão disponíveis para visualização posterior no K9s.

Para alterar a configuração do benchmark, é necessário criar um arquivo $HOME/.k9s/bench-.yml (definido para cada cluster).

NB: É importante que a extensão de todos os arquivos YAML no diretório .k9s seja exatamente .yml (.yaml (não funciona corretamente).

Exemplo de configuração:

benchmark:
  padrões:
    # Número de threads
    concorrência: 2
    # Número de requisições
    requisições: 1000
  contêineres:
    # Configurações para o contêiner de benchmark
    # O contêiner é definido como namespace/pod-name:container-name
    default/nginx:nginx:
      concorrência: 2
      requisições: 10000
      http:
        caminho: /
        método: POST
        corpo:
          {"foo":"bar"}
        cabeçalho:
          Aceitar:
            - text/html
          Content-Type:
            - application/json
 serviços:
    # É possível realizar o benchmark em serviços do tipo NodePort e LoadBalancer
    # Sintaxe: namespace/service-name
    default/nginx:
      concorrência: 5
      requisições: 500
      http:
        método: GET
        caminho: /auth
      auth:
        usuário: flant
        senha: s3cr3tp455w0rd

Interface

O formato das colunas para listas de recursos é modificado criando um arquivo $HOME/.k9s/views.yml. Um exemplo do seu conteúdo:

k9s:
 visões:
   v1/pods:
     colunas:
       - IDADE
       - NAMESPACE
       - NOME
       - IP
       - NÓ
       - STATUS
       - PRONTO
   v1/serviços:
     colunas:
       - IDADE
       - NAMESPACE
       - NOME
       - TIPO
       - CLUSTER-IP

Na verdade, falta uma coluna para os rótulos, sobre a qual há uma questão no projeto.

A ordenação por colunas é feita com combinações de teclas:

• Shift + n — por nome;
• Shift + o — por nós;
• Shift + i — por IP;
• Shift + a — por tempo de vida do contêiner;
• Shift + t — por número de reinicializações;
• Shift + r — por status de prontidão;
• Shift + c — por uso de CPU;
• Shift + m — por uso de memória.

Se alguém não gosta do esquema de cores padrão, o K9s até suporta skins. Exemplos prontos (7 no total) estão disponíveis aqui. Aqui está um exemplo de um desses skins (na marinha):

Plugins

Finalmente, plugins eles permitem expandir as funcionalidades do K9s. Eu mesmo usei apenas um deles no meu trabalho — kubectl get all -n $namespace.

Isso fica assim. Criamos um arquivo $HOME/.k9s/plugin.yml com o seguinte conteúdo:

plugin:
 get-all:
   atalho: g
   confirmar: falso
   descrição: obter todos
   escopos:
   - todos
   comando: sh
   fundo: falso
   args:
   - -c
   - "kubectl -n $NAMESPACE get all -o wide | less"

Agora pode-se entrar no espaço de nomes e pressionar "g" para executar o comando correspondente:

Entre os plugins, há, por exemplo, integrações com kubectl-jq e uma ferramenta para visualizar logs stern.

Conclusão

Na minha opinião, o K9s se mostrou muito conveniente de usar: é bastante rápido se acostumar a buscar tudo que é necessário sem usar kubectl. Fiquei satisfeito com a visualização e o armazenamento de logs, a edição rápida de recursos e a velocidade geral de operação; o modo Popeye foi útil. Vale mencionar as possibilidades de criar plugins e adaptar o aplicativo para as suas necessidades.

* Embora tenha notado um desempenho lento do K9s com um grande volume de logs. Nessas horas, a ferramenta consumia 2 núcleos de um Intel Xeon E312xx e podia até travar.

O que falta atualmente? Um rollback rápido para a versão anterior (não me refiro ao RS) sem ter que acessar o diretório. Além disso, a recuperação acontece apenas para todos os recursos: se você excluiu uma anotação ou um rótulo, será necessário excluir e restaurar todo o recurso (é aqui que será preciso acessar o diretório). Outro detalhe — falta a data desses 'backups' salvos.

P.S.

Confira também em nosso blog:

• «Revisão de interfaces gráficas para Kubernetes»;
• «Anúncio da interface web Kubernetes Web View (e uma breve revisão de outras UIs web para Kubernetes)»;
• «kubebox e outras interfaces de console para Kubernetes».

Fonte: habr.com