8 dicas e truques de Kubernetes

A maioria das dicas fornecidas a seguir envolve o uso do kubectl, uma ferramenta de linha de comando poderosa que permite executar comandos nos clusters do Kubernetes.

Se você precisar de algum conhecimento sobre Kubernetes antes de começar essas dicas, consulte os seguintes recursos:

• O que é o Kubernetes?
• VÍDEO – Orquestração de contêineres explicada
• Clusters do Kubernetes: arquitetura para entrega rápida e controlada de aplicativos na nuvem
• O que é o Kubernetes Ingress?
• Comece a usar o IBM Cloud Kubernetes Service

Você pode dividir um cluster do Kubernetes em vários ambientes usando namespaces (por exemplo, Dev1, Dev2, QA1, QA2, etc.), e cada ambiente pode ser gerenciado por um usuário diferente. Uma das inconveniências de escrever comandos kubectl é que toda vez que você escreve um comando, você precisa da opção --namespace no final. As pessoas geralmente esquecem isso e acabam criando objetos (pods, serviços, implementações) no namespace errado. 

Com esse truque, você pode definir a preferência de namespace antes de executar comandos do kubectl. Execute o seguinte comando antes de executar os comandos do kubectl para salvar o namespace de todos os comandos do kubectl subsequentes para seu contexto atual:

kubectl config set-context $(kubectl config current-context) --namespace=mynamespace

Alguns dos comandos mais comuns e úteis com namespace estão listados abaixo:

• kubectl get namespaces
• kubectl create namespace mynamespace
• kubectl get pods --all-namespaces (Liste todos os pods com status de todos os namespaces.)
• kubectl get po -o wide -n <namspace1> -n <namespace2> -n <namespace3> (Esse comando identificará os pods em cada namespace)
• kubectl describe namespace <namespace>
• kubectl config view --minify | grep namespace (Esse comando garantirá que você defina o namespace corretamente para seu contexto atual.) 

Os comandos do Kubernetes podem ser bastante demorados; portanto, configurar alguns aliases para executar o kubectl é muito útil. Você não precisará mais escrever o comando completo repetidas vezes, facilitando muito sua vida quando quiser executar vários comandos do Kubernetes em uma sessão.

Listamos os aliases de alguns comandos usados com frequência abaixo. Execute-os antes de executar comandos do kubectl para poupar tempo. Exemplo: você só precisa digitar K em vez de digitar kubectl:

• alias k='kubectl'
• alias kc='k config view --minify | grep name'
• alias kdp='kubectl describe pod'
• alias krh='kubectl run --help | more'
• alias ugh='kubectl get --help | more'
• alias c='clear'
• alias kd='kubectl describe pod'
• alias ke='kubectl explain'
• alias kf='kubectl create -f'
• alias kg='kubectl get pods --show-labels'
• alias kr='kubectl replace -f'
• alias kh='kubectl --help | more'
• alias krh='kubectl run --help | more'
• alias ks='kubectl get namespaces'
• alias l='ls -lrt'
• alias ll='vi ls -rt | tail -1'
• alias kga='k get pod --all-namespaces'
• alias kgaa='kubectl get all --show-labels'

Há muitos editores diferentes disponíveis para escrever arquivos YAML, mas há muitas vezes em que pode ser necessário ajustar rapidamente um YAML gerado e trabalhar em um terminal. Este é um ótimo lugar para usar nosso confiável vi, o editor de texto originalmente criado para o sistema operacional Unix.

O editor vi está bem documentado e tem o apoio de uma comunidade vibrante de código aberto. No entanto, um dos problemas com o editor vi ao criar arquivos YAML é a questão do espaço. Precisamos de uma maneira de endentar com tabs e alinhar com espaços. O uso de tabulações em vez de espaços para espaços em branco sempre criou problemas de sintaxe durante a gravação de arquivos YAML (por exemplo, obter o YAML de dois espaços como padrão ao pressionar o retorno de carro).

A solução? Crie um ~/.vimrc por estas linhas antes de criar arquivos YAML com o editor vi para facilitar a edição:

• set smarttab
• set expandtab
• set shiftwidth=4
• set tabstop=4
• set number

Podemos criar arquivos YAML complexos na linha de comando usando comandos kubectl.

A maioria das pessoas concordaria que trabalhar com arquivos YAML não é divertido, e os arquivos YAML do Kubernetes podem ser muito detalhados e difíceis de criar a partir do zero. É muito mais fácil criar o arquivo YAML a partir de comandos kubectl em vez de a partir de uma página em branco usando um editor.

Os comandos a seguir criarão um arquivo YAML com nome yamlfile . Depois de criar o arquivo YAML a partir desses comandos do kubectl, você pode modificá-lo com base em suas necessidades e usá-lo em vez de escrevê-lo do zero:

• kubectl run busybox --image=busybox --dry-run=client -o yaml --
  restart=Never > yamlfile.yaml
  

  kubectl create job my-job --dry-run=client -o yaml --image=busybox -- date>yamlfile.yaml
  

• kubectl get -o yaml deploy/nginx > 1.yaml(Certifique-se de que você
  tenha uma implementação chamada nginx)
  

• kubectl run busybox --image=busybox --dry-run=client -o yaml 
  --restart=Never -- /bin/sh -c "while true; do echo hello; echo 
  hello again;done" > yamlfile.yaml
  

• kubectl run wordpress --image=wordpress –-expose –-port=8989 -
  -restart=Never -o yaml
  

• kubectl run test --image=busybox --restart=Never --dry -
  run=client -o yaml -- bin/sh -c 'echo test;sleep 100' > 
  yamlfile.yaml(Observe que --bin vem no final. Isso criará um arquivo yaml).
  

(Observe que --bin  vem no final. Isso criará um arquivo yaml).

Outra boa ideia para criar o arquivo YAML é obter o arquivo diretamente da internet usando o comando wget. 

Na Dica 1, aprendemos alguns comandos úteis para usar namespaces do Kubernetes e salva-los para que você não precise adicionar a cada comando. Vamos expandir a ponta para facilitar a alternância entre namespaces e contextos kubectl.

Há várias ferramentas que podem ajudar, mas gostamos de kubectx e kubers para gerenciar contextos e namespaces, respectivamente. Veja os detalhes do kubectx e do kbens aqui.

Veja como fazer download dos binários do Linux para o kubectx e o utilitário kuber:

• wget https://github.com/ahmetb/kubectx/releases/download/v0.9.0/kubectx_v0.9.0_linux_x86_64.tar.gz
  

• wget https://github.com/ahmetb/kubectx/releases/download/v0.9.0/kubens_v0.9.0_linux_x86_64.tar.gz
  

Em seguida, você os extrai com os seguintes comandos:

• tar -xvf kubectx_v0.9.0_linux_x86_64.tar.gz
  

• tar -xvf kubens_v0.9.0_linux_x86_64.tar.gz
  

Por fim, você os migra para seu PATH:

• sudo mv kubectx /usr/local/bin
• sudo mv kubens /usr/local/bin

Depois de instalado, você pode simplesmente usar o kubens para listar os namespaces e alternar entre eles:

Ao trabalhar com vários clusters, o kubectx facilita a alternância entre contextos:

Você sabia que o kubectl oferece preenchimento automático para BSH e ZSH? Essa é uma configuração opcional.

Digamos que você entenda os conceitos de Kubernetes e tenha alguma experiência com kubectl, mas talvez não seja tão bom em memorizar comandos. Primeiro, você instala o bash-completion e, em seguida, habilita o kubectl autocompletion. Você pode encontrar todos os detalhes na página dedocumentação " Instalar e configurar o kubectl " para seu ambiente.

Abaixo estão as opções de configuração com a funcionalidade de preenchimento automático:

Agora, é só navegar!

O comando top é provavelmente uma das ferramentas mais populares para monitorar processos e recursos do sistema. Ele fornece uma interface simples baseada em caracteres e acesso rápido a informações cruciais.

Você pode ver a utilização de recursos por nó:

Utilização de recursos por pod:

E o prático comando watsonx pode ajudar você a exibir o comando em um intervalo desejável sem precisar executá-lo repetidas vezes. O exemplo a seguir o executa a cada cinco segundos (o padrão é dois segundos): 

watch kubectl top node -n 5

Observação: é necessário baixar o comando watch para seu ambiente.

Seu cluster do Kubernetes também precisa estar executando o heapster para que o comando top funcione, caso contrário você receberá o seguinte erro: "Erro do servidor (NotFound): o servidor não pôde encontrar o recurso solicitado (get services http:heapster:)”

O comando kubectl fornece uma visualização resumida dos Recursos armazenados pelo apiserver. Há muitos outros campos armazenados pelo apiserver que não são mostrados. Você pode usar o comando kubectl get com a saída do recurso bruto para criar sua própria visualização e seus próprios comandos. 

Você pode imprimir os recursos brutos em JSON com o seguinte comando:

kubectl get deployments -o json

Você também pode chamar o recurso diretamente usando a chamada da api:

kubectl get --raw=/apis/apps/v1/deployments

Você pode até mesmo combinar a saída com ferramentas como jq para oferecer diferentes visualizações, filtrar a saída ou alimentar a saída para outras ferramentas para automação. 

Por exemplo, pode ser difícil encontrar problemas em clusters com vários namespaces e implementações, mas o exemplo abaixo usa a API bruta para escanear todas as implementações no cluster e filtrar somente as implementações com réplicas com falha:

kubectl get --raw=/apis/apps/v1/deployments | jq '.items[] 
| {name: .metadata.name, replicas: .status.replicas, available:
 (.status.availableReplicas // 0), unavailable:
 (.status.unavailableReplicas // 0)} | select (.unavailable > 0)'

A seguir está uma explicação rápida do comando acima:

• Primeiro, chamamos a API do Kubernetes para retornar todas as implementações. A saída padrão é em JSON. É difícil visualizar a estrutura do documento JSON, mas você pode canalizar para jq para ter uma ideia melhor, como no exemplo abaixo:

  kubectl get --raw=/apis/apps/v1/deployments | jq .
  

• Observe que o documento de resposta tem uma série de itens para cada implementação. Queremos inspecionar o campo de status dessa matriz até o final. O comando abaixo mostra como imprimir apenas os dados necessários e um valor padrão de 0 quando o campo não estiver disponível:

   

  kubectl get --raw=/apis/apps/v1/deployments | jq '.items[] |
  {name: .metadata.name, replicas: .status.replicas, available:
   (.status.availableReplicas // 0), unavailable: 
  (.status.unavailableReplicas // 0)}'
  
  
  
  
  

• A peça final do quebra-cabeça é usar a função select para exibir somente implementações com réplicas indisponíveis:

   

  kubectl get --raw=/apis/apps/v1/deployments | jq '.items[] | 
  {name: .metadata.name, replicas: .status.replicas, available:
   (.status.availableReplicas // 0), unavailable: 
  (.status.unavailableReplicas // 0)} | select (.unavailable > 0)'
  

Esperamos que algumas dessas dicas e truques sejam úteis enquanto trabalha com o Kubernetes. Informe-nos se você tem uma dica favorita ou uma dica pessoal que gostaria de compartilhar.

Não se esqueça de consultar o IBM Cloud Kubernetes Service e colocar essas dicas e truques em uso.

Quer ter uma experiência prática e sem custo com o Kubernetes? Aproveite o IBM CloudLab, uma nova plataforma interativa que oferece tutoriais do Kubernetes com certificação, sem custo nem configuração.