Um guia para KUBECTL como nunca antes

A equipe da comunidade de código aberto da China fez sua primeira transmissão ao vivo, contando a história por trás da comunidade de código aberto da China em nome do compartilhamento."

Que tipo de engenheiro você é? Alguém consegue adivinhar só de olhar a aparência? Provavelmente é impossível adivinhar.

Traduzido de O guia para kubectl que nunca tive , autor Jake Page.

E se alguém pudesse adivinhar apenas olhando para o teclado? Provavelmente é um pouco mais fácil agora.

Você sabe que está lidando com um engenheiro do Kubernetes quando a tecla "k" do teclado está desgastada .

No escritório da Glasskube , você encontrará chaves “k” extras em todos os lugares, caso precise delas.

Claro, estou brincando.

Não tenho certeza do que um teclado desgastado diz sobre seu dono. Mas eu sei o quão importante é o kubectl para quem deseja se tornar um administrador proficiente do Kubernetes .

kubectl é uma ferramenta CLI para comunicação com a API Kubernetes, que pode parecer simples à primeira vista, mas pode rapidamente se tornar complexa.

Então, nesta postagem do blog, meu objetivo é escrever o guia que eu gostaria de ter quando estava começando . Concentre-se primeiro na sintaxe dos comandos e nos comandos úteis e, em seguida, passe para o vibrante ecossistema de plug-ins e ferramentas projetados para estender os recursos do kubectl e do Kubernetes .

Também compartilhando algumas dicas e truques, bem como uma folha de dicas útil do kubectl.

vamos começar.

Isenção de responsabilidade

Este não é um artigo sobre Kubernetes. K8s é uma tecnologia extremamente ampla que abrange muitos conceitos, como vários tipos de objetos Kubernetes e suas interações. Para esta discussão, presumo que você esteja familiarizado com esses conceitos. Em vez disso, vou me concentrar especificamente no kubectl, em seu uso e nas ferramentas criadas em torno dele.

antes do início

Se você apoia projetos de código aberto que tornam o gerenciamento de pacotes Kubernetes melhor para todos, considere apoiar o Glasskube e nos dar uma estrela no GitHub.

Instalar

Para instalar o kubectl, você tem algumas opções diferentes dependendo do seu sistema operacional. Veja como instalá-lo em algumas plataformas comuns:

Linux (Ubuntu/Debian)

sudo apt-get update && sudo apt-get install -y kubectl

MacOS usando Homebrew

brew install kubectl

Windows usando Chocolatey

choco install kubernetes-cli

Após a instalação, você pode verificar se o kubectl está instalado corretamente executando o seguinte comando:

kubectl version --client

Comando kubectl:

kubectl é uma ferramenta de interface de linha de comando (CLI) usada para se comunicar com a API Kubernetes. Existem muitos comandos, muitos para lembrar.

Mas não se preocupe, não é tão assustador quanto algumas pessoas imaginam.

Exploraremos maneiras de acessar rapidamente referências de comandos, comandos específicos para objetos k8s, aliases úteis e conclusão de comandos. Mas primeiro, como a string de comando é construída?

gramática

Inglês e chinês são línguas sujeito-verbo-objeto (SVO).

Hindi e coreano são línguas sujeito-objeto-verbo (SOV).

Se kubectl fosse uma linguagem, seria uma linguagem **kubectl + verbo + objeto/[nome opcional] + flag(kvof)**

Também semelhante à linguagem, a melhor maneira de aprender e absorver a gramática é usá-la no contexto, em vez de memorizar longas listas de verbos e objetos.

Se você tiver dúvidas e quiser fazer referência rápida a objetos existentes do Kubernetes de qualquer versão do Kubernetes, execute kubectl api-resources.

Comandos são recursos [objetos] construídos selecionando a ação [verbo] a ser aplicada ao Kubernetes desejado , geralmente seguido do nome do recurso. Além disso, você tem um grande número de filtros [flags] que podem ser aplicados ao recurso. comando. Esses filtros O escopo final e a saída serão determinados.

Vejamos um exemplo de construção de comando que usa o verbo get comum para recuperar todos os recursos no namespace glasskube-system, com a saída no formato yaml:

kubectl get all --namespace glasskube-system -o yaml

Se você encontrar um recurso do Kubernetes do qual nunca ouviu falar antes ou precisar de uma atualização, use kubectl explicar [nome do recurso] para obter uma descrição do terminal e instruções de uso.

trabalho imperativo

Ao trabalhar em um ambiente Kubernetes, você tem muitas tarefas, desde implantar novos aplicativos, solucionar problemas de recursos com falha, verificar o uso e muito mais. Posteriormente, exploraremos como usar uma forma declarativa de trabalho é melhor para definir e implantar cargas de trabalho, mas para todo o resto, temos comandos imperativos úteis do Kubernetes prontos.

O comando simples para começarmos é:

# Create a new deployment named "nginx-deployment" with the nginx image
kubectl run nginx-deployment --image=nginx

# Delete a pod named "nginx-deployment" in the default namespace
kubectl delete pod nginx-deployment

Para levar os comandos imperativos para a próxima etapa, saiba que você pode usar o editor TUI para modificar recursos:

Ao executar kubectl edit -n [namespace] [resource-name], um editor de texto semelhante ao seguinte será aberto. Edite e saia como vim, execute ESC + :q!.

# Please edit the object below. Lines beginning with a '#' will be ignored,
# and an empty file will abort the edit. If an error occurs while saving this file will be
# reopened with the relevant failures.
#
apiVersion: v1
kind: Pod
metadata:
  annotations:
    kubectl.kubernetes.io/default-container: manager
  creationTimestamp: "2024-04-22T17:07:39Z"
  generateName: glasskube-controller-manager-556ff6fccf-
  labels:
    control-plane: controller-manager
    pod-template-hash: 556ff6fccf
  name: glasskube-controller-manager-556ff6fccf-4qlxz
  namespace: glasskube-system
  ownerReferences:
  - apiVersion: apps/v1
    blockOwnerDeletion: true
    controller: true
    kind: ReplicaSet
    name: glasskube-controller-manager-556ff6fccf
    uid: 430e90e9-32f3-45f6-92dc-4bae26ae1654
"/var/folders/2q/wjmbwg1n5vn8v7vlw17nsz0h0000gn/T/kubectl-edit-1306753911.yaml" 209L, 5898B

A maioria dos comandos funciona em todos os tipos de objetos do Kubernetes. Antes de discutir mais comandos específicos que são úteis para determinados recursos do Kubernetes, vale a pena entender alguns sinalizadores úteis que podem ser aplicados a muitos objetos diferentes.

Sinalizadores úteis:

- ambiente:

O sinalizador --env permite especificar variáveis de ambiente para o contêiner que está sendo criado.

kubectl run nginx-deployment --image=nginx --env="ENV_VARIABLE=value"

- modelo:

Este sinalizador permite especificar um modelo Go para o formato de saída do comando kubectl. É muito conveniente quando você deseja personalizar a estrutura de saída, filtragem ou apresentação.

kubectl get pods --template='{{range .items}}{{.metadata.name}}{{"\n"}}{{end}}'

- seletor de campo:

Usando este sinalizador você pode filtrar recursos com base em campos específicos. Por exemplo, você pode filtrar pods com base no status ou rótulo.

kubectl get pods --field-selector=status.phase=Running

— tipo de seletor de campo=[Normal/Aviso]：

Este é um uso específico do sinalizador do seletor de campo, onde você pode filtrar eventos com base no tipo (Normal ou Aviso).

kubectl events -n [resource-namespace] — for=[resource-kind]/[resource-name]Este comando obtém eventos relacionados a um recurso específico no namespace especificado. Ele monitora continuamente novos eventos relacionados a um determinado recurso.

kubectl events -n my-namespace --for=deployment/my-deployment

Sinalizadores de vigilância da velha escola vs. nova escola:

-o amplo dado -w:

-o wide: Este é um sinalizador "old school" que fornece um formato de saída amplo, mostrando detalhes adicionais sobre o recurso.

-w: Este é um sinalizador **"new school"** que permite o monitoramento contínuo de alterações de recursos, semelhante ao comando watch.

Usando pods

Pods são a menor abstração no ecossistema Kubernetes. São unidades lógicas que abrigam contêineres. Os pods consomem recursos, podem executar e gerar logs. Aqui estão alguns comandos para ajudá-lo a gerenciar pods.

# Show resource usage of a pod
kubectl top pod -n [namespace] [pod-name]

# Run a command inside a new pod in the cluster
kubectl run -it ubuntu --image ubuntu --rm -- bash

# Show resource labels as columns
# e.g. kubectl get pods -n [namespace] -L vault-active -L vault-sealed
kubectl get pods -n [namespace] -L vault-active -L vault-sealed

# Execute a command inside a pod
kubectl exec -it [pod-name] -n [namespace] --

# Port forward to a pod
kubectl port-forward [pod-name] [local-port]:[remote-port] -n [namespace]

# Show container logs
kubectl logs -n [namespace] [pod-name]
kubectl logs -n [namespace] /deployment/[deployment-name]  # Use -f flag for continuous streaming

# Run a command inside an existing container
kubectl exec -it -n [namespace] [pod-name] -- [command...]

Usar nó

Os nós são instâncias básicas que fornecem poder de computação e armazenamento, e os clusters Kubernetes são executados sobre eles.

# Show node resource utilization
kubectl top node [node-name]  # Node name is optional; without shows table of all nodes

# Get node information
kubectl get node

Usando implantações, DaemonSets e StatefulSets

Implantações, conjuntos de daemons e conjuntos com estado são abstrações de nível superior no Kubernetes usadas para gerenciar a implantação e o dimensionamento de cargas de trabalho de aplicativos.

# Restart a workload (e.g. deployment, stateful set, daemon set)
kubectl rollout restart -n [namespace] [workload-kind]/[workload-name]  # Triggers a re-creation of all pods for this workload, adhering to the workload configuration

# Check the status of a deployment rollout
kubectl rollout status deployment/[name]

# View rollout history of a deployment
kubectl rollout history deployment/[name]  # View rollout history of a deployment

# Scale a deployment to the specified number of replicas
kubectl scale deployment/ --replicas=[number]  # Scale a deployment to the specified number of replicas

# Watch events related to a deployment
kubectl events -n glasskube-system --for=deployment/glasskube-controller-manager  

#Update Deployment Image
kubectl set image deployment/[deployment-name] [container-name]=new-image:tag

# Delete DaemonSet
kubectl delete daemonset [daemonset-name]

Usar trabalho

Um trabalho gerencia a execução de um pod para realizar uma tarefa específica e garante a conclusão bem-sucedida da tarefa antes de encerrar.

# Run a CronJob manually
kubectl create job [job-name] --image=image/name

# Creates a new job from the job template specified in the cronjob
kubectl create job -n [namespace] --from=cronjob/[cron-job-name] [job-name]

Usar segredo

Os segredos são usados para armazenar com segurança informações confidenciais, como senhas, tokens OAuth e chaves SSH no Kubernetes.

# Create Secret
kubectl create secret generic [secret-name] --from-literal=key1=value1 --from-file=ssh-privatekey=~/.ssh/id_rsa

# Get a value from a secret
kubectl get secrets -n [namespace] [secret-name] --template='{{ .data.[key-name] | base64decode }}'

# Get a value from a secret using jsonpath
kubectl get secrets [secret-name] -o jsonpath="{.data.key1}" | base64 --decode

JSONPath é uma linguagem de consulta usada para extrair dados específicos de documentos JSON. No Kubernetes, as expressões JSONPath são frequentemente -o jsonpathusadas com sinalizadores em comandos kubectl para extrair informações específicas da saída desses comandos.

Conclusão do shell

Você deve ter notado que os comandos do kubectl podem ficar muito longos muito rapidamente. Um script de preenchimento de shell bacana pode ser adicionado ao seu arquivo bash ou zshell para permitir o preenchimento fácil de tags. Chega de estudar. Para conseguir isso em todas as sessões do shell, adicione o seguinte ao seu arquivo ~/.zshrc:

source <(kubectl completion zsh)

e reinicie o shell. Se você usa bash, siga as instruções aqui:

# Install bash-completion package
sudo apt-get install -y bash-completion
# Store the output of the completion command in .bashrc
echo "source <(kubectl completion bash)" >> ~/.bashrc
# Activate the completion rules
source ~/.bashrc

trabalhando declarativamente

O gerenciamento declarativo de recursos do Kubernetes envolve o uso de arquivos de manifesto YAML para especificar o estado desejado dos recursos e a aplicação desses manifestos ao cluster.

Criar arquivo YAML

Quer os objetos do Kubernetes sejam escritos por você ou por outra pessoa, todos os objetos são definidos em arquivos YAML. A API Kubernetes usa definições de arquivo YAML para entender o status do cluster:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: glasskube-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: glasskube
      env: prod
  template:
    metadata:
      labels:
        app: glasskube
        env: prod
    spec:
      containers:
      - name: glasskube-container
        image: your-glasskube-image:latest

Para criar esta implantação do zero, use o comando kubectl create:

kubectl create -f glasskube-deployment.yaml

Arquivo YAML do aplicativo (aplicativo cliente)

Usar arquivos YAML é a maneira padrão de gerenciar recursos do Kubernetes. Você pode definir o estado desejado de seus recursos no formato YAML e aplicar esses arquivos YAML ao cluster.

kubectl apply -f manifest.yaml

Aplicativo do lado do servidor (SSA)

A aplicação do lado do servidor é um método mais recente de aplicação de alterações de configuração aos recursos do Kubernetes. Com o SSA, as alterações são aplicadas diretamente no servidor, o que significa que o servidor da API Kubernetes é responsável por garantir que o estado desejado seja alcançado.

kubectl apply --server-side -f manifest.yaml

Plug-ins e ferramentas

Sempre que vejo alguma discussão sobre Kubernetes, o que é exatamente. Para quais casos de uso ele é mais adequado e qual a melhor forma de pensar sobre isso, o mesmo tweet de Kelsey Hightower vem à mente.

Essa visão é amplamente reconhecida, como evidenciado pelo grande ecossistema de plug-ins e ferramentas do Kubernetes projetados para ajudar a lidar com vários estágios do ciclo de vida do Kubernetes.

Gerenciador de plug-ins Krew Kubernetes

Um poderoso gerenciador de plugins para encontrar novos plugins é o krew , como instalá-lo é o seguinte. O comando para instalar o plug-in kubectl por meio do Krew:

kubectl krew install <PLUGIN_NAME>

Vamos explorar algumas das principais categorias de depuração e ferramentas, destacando alguns dos itens mais úteis. Como há muito a ser observado, adicionarei uma seção de honras para cada seção.

Troca de conteúdo e namespace

Em um ambiente Kubernetes, você sempre opera dentro de dois contextos hierárquicos, clusters e namespaces. Garantir a execução precisa do comando requer a especificação do contexto apropriado para obter a saída desejada. A troca de contextos de cluster ou namespaces pode envolver comandos longos e difíceis de lembrar, e é aí que entram ferramentas como Kubectl e Kubens.

Kubectx e Kubens

Visualize facilmente clusters e namespaces disponíveis e alterne entre eles aqui.

Veja as instruções de instalação aqui .

Louvável:

kubectl-cf : Uma maneira mais rápida de alternar entre arquivos kubeconfig (em vez de contextos).

visibilidade

Clusters Kubernetes são sistemas complexos com muitas partes móveis que dependem umas das outras para executar seu aplicativo. É crucial ter sempre uma compreensão clara do que está acontecendo.

k9s

K9s é um painel interativo leve e conveniente do Kubernetes que roda no terminal. Além de visualizar seus recursos k8s, você pode facilmente mergulhar em pods, editar manifestos e gerenciar suas cargas de trabalho em um só lugar. Esta é provavelmente uma das minhas ferramentas de gerenciamento favoritas do Kubernetes.

As instruções de instalação estão aqui .

árvore kubectl

Um plug-in kubectl para explorar relações de propriedade entre objetos Kubernetes por meio deownersReferences nos objetos.

Instalar :

kubectl krew install tree
kubectl tree --help

kubecolor

KubeColor é usado para adicionar cor à saída do kubectl.

As instruções de instalação estão aqui .

Gerenciamento de pacotes

O gerenciamento de pacotes de cluster usando ferramentas regulares de gerenciamento de pacotes pode ser frustrante e a atualização de pacotes pode ser entediante. A configuração é desajeitada e, até agora, a pilha de pacotes necessária para aplicá-la declarativamente estava fora de controle.

Cubo de vidro:

Com o Glasskube, todos os problemas encontrados nos gerenciadores de pacotes tradicionais, como o helm, são eliminados, garantindo que você tenha tempo para gerenciar suas cargas de trabalho e não se preocupe em gerenciar sua pilha de pacotes k8s.

rede

Cílio Kubectl:

kubectl-Cilium é um plug-in que interage com o Cilium, uma solução nativa da nuvem baseada em eBPF para provisionar, proteger e observar conexões de rede entre cargas de trabalho.

Instalar:

kubectl krew install cilium

Gerente de certificados

Cert-manager adiciona certificados e emissores de certificados como tipos de recursos em clusters Kubernetes, simplificando a obtenção, atualização e uso desses certificados.

As instruções de instalação podem ser encontradas aqui.

Menção especial :

Ksniff : Este é um plugin kubectl que aproveita tcpdump e Wireshark para iniciar a captura remota em qualquer Pod em um cluster Kubernetes.

RBAC

A Cubeologia

Kubelogin é um plug-in certificado pelo Kubernetes OpenID Connect (OIDC), também conhecido como kubectl oidc-login.

As instruções de instalação estão aqui .

Consultor de política Kube

Kube-policy-advisor facilita a criação de políticas de segurança de pod K8s (PSP) ou políticas OPA a partir de um ambiente K8s ativo ou de um único arquivo .yaml contendo especificações de pod (implantações, conjuntos de daemons, pods, etc.).

Instalar:

kubectl krew install advise-policy

Louvável:

kubectl-who-can : mostra que SUBJECTS tem permissões RBAC em VERB [TYPE | TYPE/NAME | NONRESOURCEURL] no Kubernetes.
rakkess : avaliar acesso - plugin kubectl para exibir a matriz de acesso dos recursos do servidor
kubectl-rolesum : resume funções RBAC para um assunto especificado (ServiceAccount, usuário e grupo).

Linting

Kubectl-puro:

Kubectl-neat : Kubectl-neat remove a desordem dos manifestos do Kubernetes e os torna mais legíveis. Ele procura e ignora principalmente duas categorias de conteúdo: valores padrão inseridos pelo modelo de objeto do Kubernetes e controladores de mutação comuns.

Instalar:

kubectl krew install neat

KubeLinter:

O KubeLinter analisa arquivos YAML do Kubernetes e gráficos do Helm e os compara com várias práticas recomendadas, com foco na preparação e segurança da produção.

Instruções de instalação: https://github.com/stackrox/kube-linter?tab=readme-ov-file#installing-kubelinter.

Manutenção e segurança de cluster

KubePug

KubePug baixa o arquivo de dados gerado data.json contendo informações de descontinuação da API para uma versão específica do Kubernetes, verifica o cluster do Kubernetes em execução para determinar se algum objeto é afetado pela descontinuação e exibe os objetos afetados ao usuário.

Exemplo:

Você pode usar o comando a seguir para visualizar o status de um cluster em execução.

$ kubepug --k8s-version=v1.22 # Will verify the current context against v1.22 version
[...]
RESULTS:
Deprecated APIs:
PodSecurityPolicy found in policy/v1beta1
     ├─ Deprecated at: 1.21
     ├─ PodSecurityPolicy governs the ability to make requests that affect the Security Context that will be applied to a pod and container.Deprecated in 1.21.
        -> OBJECT: restrictive namespace: default


Deleted APIs:
     APIs REMOVED FROM THE CURRENT VERSION AND SHOULD BE MIGRATED IMMEDIATELY!!
Ingress found in extensions/v1beta1
     ├─ Deleted at: 1.22
     ├─ Replacement: networking.k8s.io/v1/Ingress
     ├─ Ingress is a collection of rules that allow inbound connections to reach the endpoints defined by a backend. An Ingress can be configured to give servicesexternally-reachable urls, load balance traffic, terminate SSL, offer namebased virtual hosting etc.DEPRECATED - This group version of Ingress is deprecated by networking.k8s.io/v1beta1 Ingress. See the release notes for more information.
        -> OBJECT: bla namespace: blabla

Instalar:

kubectl krew install deprecations

Cubescape:

Kubescape é uma plataforma de segurança Kubernetes de código aberto para clusters, pipelines de CI/CD e IDEs que separa sinais de segurança do ruído do scanner.

Instruções de instalação aqui .

Vale a pena falar sobre:

kubectl-watch : outra ferramenta de observação para visualizar visualmente alterações incrementais nos recursos do Kubernetes.

solução de problemas

Dispositivo do inspetor:

Inspektor-gadget é uma coleção de ferramentas (ou gadgets) para depurar e inspecionar recursos e aplicativos do Kubernetes.

As ferramentas do Inspektor Gadget são chamadas de gadgets. Você pode implantar um, dois ou vários gadgets.

K8s-gpt:

k8sgpt é uma ferramenta para verificar seu cluster Kubernetes, diagnosticar e fazer triagem de problemas em inglês simples.

Instruções de instalação aqui .

Vale a pena falar sobre:

kubectl node-shell : inicia um shell raiz diretamente no sistema operacional host de um nó em execução.

exploração madeireira

Popa:

Stern permite rastrear vários pods no Kubernetes e vários contêineres dentro de um pod. Cada resultado é codificado por cores para uma depuração mais rápida.

Instalar:

kubectl krew install stern

Algumas implicações de segurança do uso de plug-ins kubectl incluem possíveis vulnerabilidades, escalonamento de privilégios e divulgação inadvertida de dados. Certifique-se de usar apenas plug-ins mantidos ativamente e, de preferência, que tenham uma comunidade ativa ao seu redor.

Alias

Existem tantos comandos kubectl para lembrar, simplifique sua vida usando atalhos de teclado ou aliases.

Você encontrará aqui um repositório que contém um script para gerar centenas de aliases de shell convenientes para kubectl. O problema é que muitos aliases são muito longos e podem ser difíceis de lembrar. Mas não se preocupe, achei esta postagem de blog muito útil de Benoit Couetil sobre como lidar com os vários aliases gerados pelo script acima.

Folha de referências do Kubectl

Nenhum guia está completo sem uma folha de dicas, certo?

# Basic Commands
# List API Resources
kubectl api-resources

# List Resources
kubectl get [name]

# Explain Resources
kubectl explain

# Working with Pods
# Create a new deployment named "nginx-deployment" with the nginx image
kubectl run nginx-deployment --image=nginx

# Show Resource Usage of a Pod
kubectl top pod -n [namespace] [pod-name]

# Run Command in Pod
kubectl run -it [pod-name] --image [image-name] --rm -- [command]

# Show Resource Labels
kubectl get pods -n [namespace] -L [label1] -L [label2]

# Execute Command in Pod
kubectl exec -it [pod-name] -- [command]

# Port Forwarding
kubectl port-forward [pod-name] [local-port]:[remote-port]

# Filtering Pods by Node Name
kubectl get pods --field-selector spec.nodeName=[node-name]

# Filtering Pods by Phase
kubectl get pods --field-selector status.phase=Running

# Delete a pod named "my-pod" in the default namespace
kubectl delete pod my-pod

# Working with Nodes
# Watch Nodes (Old School)
watch kubectl get nodes -o wide
# Watch Nodes (New School)
kubectl get nodes -w

# Node Resource Utilization
kubectl top node [node-name]

# Get Node Resource
kubectl describe node [node-name]

# Working with Deployments, Daemonsets, and StatefulSets
# Restart Workload
kubectl rollout restart -n [namespace] [kind]/[name]

# Rollout Status
kubectl rollout status [kind]/[name]

# Rollout History
kubectl rollout history [kind]/[name]

# Scale Deployment
kubectl scale deployment/[name] --replicas=[replica-count]

#Update Deployment Image
kubectl set image deployment/[deployment-name] [container-name]=new-image:tag

# Watch events related to a deployment
kubectl events -n glasskube-system --for=deployment/glasskube-controller-manager  

# Delete DaemonSet
kubectl delete daemonset [daemonset-name]

# Working with Jobs
# Run CronJob Manually
kubectl create job -n [namespace] --from=cronjob/[cron-job-name] [job-name]

# Working with Secrets
# Get Value from Secret
kubectl get secret -n [namespace] [secret-name] -o=jsonpath='{.data.[key]}' | base64 --decode

# Create Secret
kubectl create secret generic [secret-name] --from-literal=key1=value1 --from-file=ssh-privatekey=~/.ssh/id_rsa

# Get a value from a secret
kubectl get secrets -n [namespace] [secret-name] --template='{{ .data.[key-name] | base64decode }}'

# Working with Containers
# Show Container Logs
kubectl logs -n [namespace] [pod-name] 
kubectl logs -n [namespace] deployment/[deployment-name]

# Run Command in Container
kubectl exec -it -n [namespace] [pod-name] -- [command]

# Working Imperatively
# Modify Resource
kubectl edit -n [namespace] [resource-kind]/[resource-name]

# Delete Resource
kubectl delete [resource-kind]/[resource-name]

# Create Resource
kubectl create -f [resource-file]

# Working Declaratively
# Use Server-Side Apply (SSA)
kubectl apply --server-side -f [resource-file]

# Events and Logs
# Show Events for Resource
kubectl get events -n [namespace] --field-selector involvedObject.kind=[kind] --field-selector involvedObject.name=[name]

# Filtering Events by Type
kubectl get events --field-selector type=Warning

# Filtering Events by Involved Object Name
kubectl get events --field-selector involvedObject.name=[resource-name]

# Show Resource Usage
kubectl top

Outros recursos

Lista de plug-ins em destaque: https://github.com/ishantanu/awesome-kubectl-plugins
Lista de aliases: https://github.com/ahmetb/kubectl-aliases
Repositório de plug-ins Krew: https://krew.sigs.k8s.io/plugins/

Se você gosta desse tipo de conteúdo e deseja ver mais, considere nos apoiar dando-nos uma estrela no GitHub .

Este artigo foi publicado pela primeira vez em Yunyunzhongsheng ( https://yylives.cc/ ), todos são bem-vindos para visitar.