Comandos Kubectl

Kubectl trabalha com o cluster Kubernetes. É uma ferramenta de linha de comando usada para a implementação do cluster Kubernetes. O "Kubectl" é a representação da "ferramenta de linha de comando Kubernetes" usada para executar comandos para os clusters de Kubernetes. A plataforma Kubectl permite implantar, inspecionar e gerenciar aplicativos Kubernetes e recursos de cluster. Este artigo foi projetado especificamente para aprender sobre os comandos Kubectl usados ​​com o cluster Kubernetes.

O que é Kubectl?

O Kubectl é uma ferramenta oficial da CLI que permite a comunicação com o painel de controle de clusters de Kubernetes via API Kubernetes. Ele autentica o cluster de nós mestre e faz chamadas de API para executar várias ações de gerenciamento. Quando você começa a trabalhar com Kubernetes, você precisa passar muito tempo com Kubectl.

Usando a versão mais recente do Kubectl, que é totalmente compatível com sua versão do Ubuntu, ajuda a evitar circunstâncias imprevistas. Existem diferentes métodos para instalar o Kubectl para usar os clusters de Kubernetes, gerenciamento de pacotes nativos, o comando "Curl" para instalar o binário no Linux, etc. Discutiremos a instalação do Kubectl em detalhes e o guiaremos sobre como instalar o Kubectl nas seções adicionais.

Como usar o comando kubectl?

Usar os comandos kubectl é muito fácil. A mesma sintaxe é seguida para cada comando. Veja a sintaxe geral do comando kubectl fornecido abaixo:

Kubectl

Essa mesma sintaxe é seguida para todos os comando, alterando o comando, tipo, nome e bandeira com Kubectl.

: Representa o comando principal que executa a aplicação, criar, obter, excluir, etc. funções.

: Representa os recursos dos Kubernetes, como vagens e nós.

: Representa o nome dado aos recursos. Se você não especificar o nome, Kubectl retornará todos os recursos representados pelo .

: Representa qualquer comando específico ou global adicional para executar no recurso de cluster.

Aqui estão vários comandos básicos de Kubectl que são usados ​​com os clusters de Kubernetes:

Comandos	Descrição
pegar	Usado para listar todos os recursos, pacotes e tudo especificado pelo
correr	Comece a executar as instâncias da imagem no cluster
Criar	Crie o pod, nó, espaço para nome ou tudo especificado por
Implantação	Criar uma implantação especificada pelo
espaço para nome	Criar um espaço para nome especificado pelo
Excluir	Exclua os recursos, pods, espaço para nome, etc. especificado pelo
Aplicar	Aplicar a configuração no
Anexar	Anexe os recursos especificados com o contêiner
Cp	Copiar arquivo, pasta, recursos ou qualquer coisa especificada por
descrever	Descrever os recursos especificados pelo
Versão API	Liste todas as versões disponíveis da API
cluster-info	Retorna o endereço do painel de serviços e controle
RESOLUÇÕES API	Liste todos os recursos suportados disponíveis da API
Config	Modifique a configuração dos recursos no cluster Kubernetes

Estes são os comandos básicos de Kubectl que são executados com uma variedade de serviços diferentes. Para executar todos esses comandos, você deve ter um minikube instalado no seu Ubuntu 20.04. Prossiga para a próxima seção para aprender sobre o minikube.

O que é Minikube?

Um nó único de um cluster Kubernetes é executado em todos os sistemas operacionais, incluindo Windows, Linux, MacOS, Unix, etc. Em palavras simples, o Minikube é um mecanismo local de Kubernetes que suporta todos os recursos do Kubernetes para o desenvolvimento de aplicativos locais. Ele cria uma máquina virtual em uma máquina local para ativar a implementação do Kubernetes, implantando um cluster de um nó único simples que consiste em dockers que permitem que os contêineres executem dentro do nó.

A interface da linha de comando do Minikube permite que as operações básicas de bootstrapping funcionem com o cluster, que inclui início, exclusão, status e parada. O principal objetivo do Minikube é ser a ferramenta perfeita para o desenvolvimento local de aplicativos Kubernetes. Ele fornece o ambiente local perfeito para testar a implementação do Kubernetes sem usar recursos extras.

Este tutorial demonstra o procedimento completo para instalar o Minikube no Ubuntu 20.04.

Como instalar o Minikube no Ubuntu?

Trabalhar com Minikube é direto. Ele suporta todos os lançamentos mais recentes do Kubernetes e é capaz de trabalhar com vários contêineres simultaneamente. Ele simplifica todos os tipos de implementação local de Kubernetes, fornecendo uma plataforma de desenvolvimento. Para testes, implementação ou execução de qualquer tipo de aplicativo Kubernetes, um minikube precisa ser instalado no sistema.

Antes de iniciarmos a instalação do Minikube, vamos ver o que os pré -requisitos devem ser cumpridos.

Pré -requisitos

Enquanto instalamos o minikube no Ubuntu 20.04, o sistema deve ter Ubuntu 20.04 executando. Os privilégios do sudo precisam ser ativados para um usuário específico da máquina.

Dê uma olhada em cada etapa e siga as instruções para instalar suavemente o minikube.

Etapa 1: atualize o sistema

A primeira etapa na instalação do Minikube é atualizar o sistema. O comando "sudo apt-get update" é usado para atualizar o sistema. Veja o comando e sua saída abaixo:

Etapa 2: Atualize o sistema

Depois que o sistema for atualizado com todas as atualizações novas e essenciais, atualize-o usando o comando "sudo apt-get upgrade". O comando "Upgrade" lê toda a lista de pacotes e cria uma árvore de dependência para atualizar o sistema para processamento adicional. Aqui está como você pode atualizar seu sistema:

Etapa 3: Instale os pacotes

Agora que o sistema é atualizado e atualizado com todas as atualizações recentes, ele está pronto para instalar os pacotes necessários. Basta fazer uma verificação rápida para garantir que os pacotes ainda não estejam instalados.

Vamos instalar “Curl”, para que possamos transferir HTTP, FTP, SFTC e qualquer outro protocolo de ou para um servidor. Consulte a execução do comando “Apt-Get Install Curl” abaixo:

Para instalar o Minikube, precisaremos de acesso aos repositórios por meio do protocolo de transporte HTTPS. É por padrão incluído no APT-Transport-https. Se você olhar para a saída abaixo, indica que as versões atualizadas dos pacotes já estão instaladas:

Etapa 4: Instale o Minikube

Neste tutorial, estamos usando o Docker, para não instalar a máquina virtual separadamente. Supondo que o Docker já esteja em vigor, vamos instalar o minikube no Ubuntu 20.04. Use o comando "wget" para baixar e instalar o minikube no armazenamento da web. O "wget" é um utilitário gratuito que permite downloads de arquivos não interativos e diretos da web. O endereço da web é dado abaixo, do qual você pode baixar e instalar o Minikube no Ubuntu 20.04:

Depois que o download for concluído com sucesso, copie todos os arquivos e mude -os para uma pasta local, digamos a pasta "/usr/local/bin/minikube". Execute o comando completo fornecido abaixo no seu terminal Ubuntu, e você terá seu minikube baixado arquivos copiados para a pasta local,/usr/local/bin/minikube:

Se o processo de copiar arquivos foi feito corretamente e tiver sido bem -sucedido, você não terá nenhuma saída no terminal. A próxima coisa que você precisa fazer é usar o comando "chmod" para permitir arquivar executivo. Consulte a saída de execução do comando “CHMOD”, dada abaixo:

Novamente, se o processo estiver correto e bem -sucedido, você não terá nenhuma saída no terminal. Se for esse o caso, você instalou com sucesso o Minikube no Ubuntu 20.04. Agora, vamos verificar a versão do minikube para garantir que ele seja instalado com sucesso. Para isso, temos o comando "versão". O comando "versão" no Ubuntu ou Linux é usado para obter a versão do software, pacotes ou qualquer coisa instalada no sistema.

Como você pode ver na saída anterior, a versão do minikube é retornada pelo comando "versão", e isso é "v1.26.1 ”.

Etapa 5: Instale Kubectl

Agora que instalamos com sucesso o Minikube em nosso Ubuntu 20.04 Sistema, nosso sistema está pronto para testar e executar os aplicativos Kubernetes. Mas, antes de iniciarmos o teste de Kubernetes, devemos instalar o Kubectl. Como discutido anteriormente, Kubectl permite ao usuário jogar com Kubernetes na plataforma Ubuntu. Novamente, use o comando "Curl" para baixar o Kubectl. A declaração completa a seguir é usada para baixar o comando kubectl no Ubuntu 20.04:

Como você pode ver na saída que o Kubectl é baixado com sucesso; O próximo passo é fazer um campo binário executável. Instale o binário Kubectl usando o “Chmod +X ./kubectl ”comando. Quando você executa este comando no seu terminal Ubuntu, ele instalará o binário Kubectl em seu sistema. Novamente, se você não vir nenhum erro ou outra saída no terminal, isso significa que o plug -in é instalado com sucesso.

Siga o mesmo processo novamente e copie todos os arquivos da sua pasta local, que é/usr/local/bin/kubectl. Para isso, use o comando "sudo mv". O comando "MV" no sistema Linux ou Unix é usado para mover arquivos de um diretório ou pasta para outro lugar. O comando completo para mover os arquivos é fornecido abaixo:

Finalmente, agora podemos verificar se o Kubectl está instalado com sucesso. Use o mesmo comando "versão" novamente para verificar a versão do Kubectl e verifique se ele está instalado corretamente.

O comando “versão” retornou todos os campos, incluindo a versão do Kubectl, e isso é “V4.5.4 ”. O terminal indicou que nosso sistema está pronto e agora podemos começar a trabalhar no minikube.

Etapa 6: Inicie o Minikube

Todos os requisitos dos pré -requisitos são atendidos e todos os softwares e o pacote necessários são instalados e configurados para o Minikube. Agora, podemos trabalhar nisso. Quando você executa o comando "Minikube Inict" no seu terminal Ubuntu, o sistema baixará o arquivo Minikube ISO de uma fonte da Web e Binário Localkube. Depois disso, ele se conectará com o Docker para configuração, pois estamos usando o Docker em vez de uma máquina virtual em uma caixa virtual. Vamos começar o minikube:

Observe que o comando retornou com um erro. Isso aconteceu porque a versão do Minikube e os drivers instalados não são perfeitamente compatíveis com a versão do Docker. No entanto, o sistema sugeriu resolver o erro, e isso é adicionando o usuário ao grupo Docker. Isso pode ser alcançado executando o comando "UserMod" antes de iniciar o minikube novamente.

O comando "UserMod" no Ubuntu é usado para alterar ou modificar os atributos do usuário atual através da CLI. Quando você executa o comando "UserMod" em seu terminal, o comando solicitará a senha do usuário atual, nome de usuário, shell, localização do diretório etc. A declaração completa “UserMod” para adicionar o usuário é mostrada abaixo:

Observe que os comandos "UserMod" e "NewGRP" são usados ​​juntos. O comando "UserMod" é usado para modificar os detalhes da conta de usuário atual, e o comando "newGrp" é usado para adicionar o grupo de usuários ao Docker. Se o processo foi feito corretamente e o usuário foi adicionado ao Docker com sucesso, não haverá saída no terminal indicando que o sistema está pronto para iniciar o minikube. Digite o mesmo comando "Minikube Inict" para iniciar o Minikube:

Observe que o minikube começou com sucesso e o driver do Docker está sendo usado com os privilégios de raiz. O terminal também está mostrando que Kubectl está configurado para usar o minikube, e estamos prontos para ir. Agora podemos implementar os clusters Kubernetes e Kubectl em nosso minikube e testar os comandos. Mas, antes de passarmos para os comandos Kubectl, crie -nos primeiro um daemonset para Kubernetes.

O que é Daemonset em Kubernetes?

O Damonset em Kubernetes é um recurso que garante que todas as vagens do sistema estejam funcionando sem problemas e programadas em todos os nó. Portanto, quando trabalhamos com Kubernetes, devemos criar um daemonset para garantir que a cópia de cada pod funcione com sucesso em todos os nós. O benefício de criar um daemonset é que, sempre que você cria um novo nó em um cluster Kubernetes, um novo pod é automaticamente adicionado ao nó recém -criado. Quando você exclui os nós do cluster, a cópia deles permanecerá para trás na vagem. Somente quando você remove o daemonset, as vagens criadas serão removidas do sistema.

Qual é o uso de Daemonset em Kubernetes?

Daemonset é criado em Kubernetes para garantir que cada nó tenha uma cópia da vagem. A vagem anexada ao nó é geralmente selecionada pelo agendador, embora o DAEMONSET Controller cleham e gerencie os pods após a criação de Daemonset. Além disso, quando um novo nó é adicionado ao cluster, uma cópia do pod é automaticamente conectada a ele e, quando o nó é removido, a cópia do pod também será removida. No entanto, os pods só serão limpos se o daemonset for removido do sistema. Os usos mais comuns de um daemonset são os seguintes:

Armazenamento de cluster: Execute o armazenamento de cluster como Ceph, Gluster, etc. Em todos os nó que foram criados.

Coleção de logs: Execute a coleção de logs como Logstash, Fluentd, etc. Em todos os nó que foram criados.

Monitoramento de nós: Execute o monitoramento do nó como colecionamento, exportador de nó, etc. Em todos os nó que foram criados.

Implantar vários daemonsetes: para Um tipo de daemon, implante vários daemonsetes via CPU ou solicitações de memória de diferentes tipos de bandeiras que suportam uma variedade de hardware e configurações.

Criação de Daemonset no cluster de Kubernetes?

Agora, sabemos o que é Daemonset e quais são seus usos, vamos criar um daemonset no Ubuntu 20.04. Para isso, verifique se pelo menos um nó do trabalhador deve existir no cluster Kubernetes. Siga as etapas fornecidas abaixo para criar um daemonset em seu cluster Kubernetes:

Etapa 1: Verifique o daemonset

O primeiro passo para criar um daemonset é garantir que ele ainda não seja criado no cluster Kubernetes. Liste todos os daemonsetes usando o sinalizador "-ver-namespaces" com o comando "get". O comando "get" é usado para extrair arquivos, pacotes e tudo, desde o cluster Kubernetes, e quando o sinalizador "Daemonsets Namespace" for adicionado a ele, ele listará todos os daemonsetes do espaço de nome padrão. No entanto, para listar todos os daemonsetes de todos os namespaces, adicione a bandeira "All" com "namespace".

Observe que todos os campos de um daemonset são devolvidos por "namespaces", incluindo namespace, nome, desejado, atual, pronto, atualizado, disponível, seletor de nó e idade. Existe apenas um daemonset chamado "Kube-proxy" que pertence ao espaço de nome "Kube-System".

Etapa 2: Obtenha pods

Agora, temos a lista de daemonsets, vamos obter as cápsulas que pertencem aos namespace de "Kube-System" daemonsets. O mesmo comando "get" é usado para obter as cápsulas que pertencem ao espaço para nome "Kube-System". Execute o comando “Kubectl Get PODS -N Kube -System” no terminal para obter os pods que pertencem a este espaço de nome específico. Consulte a captura de tela fornecida abaixo:

Etapa # 3: Obtenha vagens proxy

O comando "get Pods" retornou a lista de vagens do espaço para nome "Kube-System". Agora, usando os mesmos comandos "Get Pods", podemos obter as vagens proxy do mesmo espaço de nome. Adicione o comando "get proxy" aos comandos "get pods" para obter as vagens proxy do espaço para nome. A declaração de comando completa é mostrada abaixo:

Etapa 4: verifique os detalhes de Daemonset

Depois de extrair todas as vagens e vagens de procuração, obtenha os detalhes do daemonset que está controlando os pods de proxy. O comando "Kubectl descreve Daemonset" é usado para obter os detalhes do Daemonset. O comando "descrever" em Kubernetes é usado para descrever os recursos em Kubernetes. Pode ser usado para definir recursos únicos e múltiplos.

Quando você precisa descrever um recurso específico de Kubernetes, basta fornecer o nome desse recurso com o comando "descrever". Nesse caso, precisamos dos detalhes de nosso daemonset "Kube-proxy" do espaço para nome "Kube-System", para que forneçamos esse nome de namespace e o nome do daemonset ao comando "descrever". A saída do comando "descrever" é mostrada abaixo:

Observe que uma lista completa de detalhes é retornada pelo comando "descrever". A saída contém todos os detalhes do Daemonset, que controla as vagens proxy em Kubernetes.

Etapa 5: Crie um arquivo YAML

O próximo passo é criar um arquivo YAML vazio no Docker. Use o comando "Touch" para gerar um arquivo YAML. Veja a declaração de comando completa fornecida abaixo:

O "Touch" é o comando para construir um arquivo YAML vazio, o "Daemon" é o nome do arquivo e ".yaml ”é a extensão do arquivo. A declaração completa instrui o sistema a criar um arquivo YAML chamado "Daemon". Agora, vamos abrir o arquivo YAML no editor desejado. O comando "nano" é usado para abrir o arquivo no editor desejado pelo usuário. Use o comando "nano" com o nome de arquivo específico para abri -lo no editor desejado. Veja o seguinte código:

Quando você executa os dois comandos anteriores, um arquivo YAML chamado “Daemon.yaml ”será criado. A saída fornecida abaixo mostra a lista completa de definições de Daemonset para o daemon.arquivo yaml. Você verá a versão da API, espaço para nome, recursos como CPU e memória, etc. Na definição de arquivo daemon.

Etapa 6: Crie um daemonset do arquivo de definição

Agora que criamos um arquivo YAML e adquirimos sua definição completa, podemos facilmente criar um daemonset a partir dele. Basta usar o comando "create" para criar o Daemonset usando o arquivo de definição que criamos na etapa anterior. Use o comando "create -f" para criar o daemonset a partir do arquivo de definição criado. Consulte o comando completo fornecido abaixo:

O daemonset chamado My-Fluentd-Elasticsearch-Daemonset foi criado com sucesso. Agora, vamos obter o espaço para nome novamente para verificar se o my-fluentd-elástica pesquisa-daemonset Daemonset é adicionado no espaço para nome do “sistema de kube”. Use a declaração "Get" novamente para listar todos os daemonsetes do espaço para nome "Kube-System".

Como você pode ver na saída anterior, o novo Daemonset foi criado no espaço para nome do “sistema Kube”.

Etapa 7: descreva o novo Daemonset

Desde que criamos um novo daemonset, é hora de descrevê -lo. Como o daemonset é criado no espaço para nome do “sistema de kube”, precisamos definir o daemonset no mesmo espaço de nome. Use o mesmo comando "descreva" com o nome Daemonset "My-Fluentd-Elasticsearch-Daemonset" e Namespace "Kube-System" para descrever o novo daemonset. Veja o comando completo na captura de tela fornecida abaixo:

Se você ver cuidadosamente a saída anterior, notará que 1 pod foi implantado com os nós. Além disso, observe que o status da vagem está "esperando".

Etapa 8: Obtenha detalhes da vagem implantada

Aqui, sabemos quantos pods são implantados nos nós. Vamos obter os detalhes da vagem implantada usando os mesmos comandos "Get Pods" e "Grep". Dê uma olhada no comando completo fornecido abaixo:

Criamos com sucesso um daemonset e aprendemos como os pods são implantados no recém -criado Daemonset em cada nó no cluster Kubernetes. Temos quase terminado com todas as instalações essenciais e criamos todos os pacotes necessários para executar suavemente os comandos Kubectl no cluster Kubernetes gerenciados pelo Minikube. Na próxima seção, vamos listar todos os comandos básicos e mais usados ​​Kubectl e forneceremos exemplos simples e fáceis para cada comando, para que você possa aprender sobre os códigos corretamente. Os exemplos de amostra ajudarão você no processo de implementação e você poderá criar seu aplicativo usando esses comandos.

Comandos básicos de Kubectl

Como sabemos que o Kubectl é uma ferramenta oficial de linha de comando para implementar, executar e executar o aplicativo Kubernetes. A ferramenta Kubectl e os comandos permitem construir, atualizar, inspecionar e remover os objetos Kubernetes. Aqui, forneceremos alguns comandos básicos que podem ser usados ​​com vários recursos e componentes da Kubernetes. Vamos ver os comandos comuns de Kubectl um por um. Lembre -se de que a palavra -chave "kubectl" será usada com todos os comandos. Isso é essencial para executar qualquer comando kubectl.

Comando # 1: cluster-info

O comando "cluster-info", como o nome sugere, fornecerá as informações do cluster. Ele fornece as informações do terminal dos serviços e o mestre do cluster. Confira a saída do comando "cluster-info" mostrado abaixo:

O "cluster-info" forneceu as informações do cluster em execução em qual porta.

Comando # 2: versão

O comando "versão" do Kubectl é usado para obter a versão do Kubernetes, que está em execução no servidor e no cliente. Veja o seguinte comando “versão” executado com sua saída produzida:

Observe que o comando "versão" retornou o "V4.5.Versão de 4 ”dos Kubernetes.

Comando # 3: Config View

O próximo comando é a "Visualização de configuração". É usado para configurar o cluster em Kubernetes. Quando você executa o comando "Kubectl Config View", você obterá uma definição completa da configuração do cluster. Os detalhes contêm o último horário de atualização, informações do provedor, versão do Minikube, versão da API, etc. Veja a lista completa de detalhes na saída fornecida abaixo:

Comando # 4: Resumo da API

Existem muitos recursos de API usados ​​em Kubernetes; Para listar todos esses, temos o comando "API-RESOURCE". Dê uma olhada na lista de todos os recursos ativos fornecidos abaixo:

Comando # 5: API-versões

Para listar todas as versões disponíveis da API, temos o comando “API-versões” disponível. Basta executar a "Kubectl API-Versão" no terminal e obter todas as versões da API que estão disponíveis atualmente. Aqui estão a lista de todas as versões da API disponíveis mostradas abaixo:

Comando # 6: Obtenha todos os namespaces

Já usamos o comando namespaces na seção anterior para criar o daemonset. No entanto, vamos ver a definição geral do comando "todos os espaços para nome". O comando -Al -Namespaces lista todos os espaços para nome criados no Kubectl. Veja a lista de todos os espaços para nome fornecidos abaixo:

Comando # 7: Obtenha Daemonset

O comando "get Daemonset" é usado para obter a lista de todos os daemonsetes criados no espaço de nome padrão até agora.

Suponha que você execute este comando antes de criar qualquer daemonset. Não retornará nada, pois nenhum recurso de daemonset foi criado no espaço para nome. No entanto, criamos um daemonset na seção anterior e podemos ver a lista de daemonset recém -criado lá.

Comando # 8: Obtenha implantação

O comando "Get Deployment" é usado para listar todas as implantações que foram feitas até agora nos Kubernetes.

Como ainda não há implantação, nenhum recurso foi encontrado no espaço para nome.

Comando # 9: toque

O comando "Touch" é usado para criar um arquivo novo e em branco para fornecer a configuração nele. Para criar um arquivo em branco, basta fornecer o nome do arquivo com a extensão de arquivo desejada, descrevendo o tipo de arquivo para o comando "touch". Veja a seguinte execução de comando:

Comando # 10: Nano

O comando "nano" é usado para abrir os arquivos no editor desejado. Criamos um YAML usando o comando "Touch", por isso forneceremos o mesmo nome de arquivo ao comando "nano" para abri -lo.

Aqui está a saída do comando "nano":

Como você pode ver, a implantação chamada "httpd-frontend" foi criada. A etiqueta "App" no campo do modelo diz ao rótulo da vagem, e isso é "httpd-frendend". Finalmente, a etiqueta "imagem" no campo do modelo especifica a versão da imagem, que é 2.4-alpine e o rótulo "nome" indica que os pods estão executando o contêiner "httpd".

Comando # 11: Criar -f

O comando "create -f" é fundido para gerar uma implantação. Quando você executa o “Kubectl Create -f Implement.Comando Yaml ”no terminal, o comando CREATE criará a implantação. Veja a nova implantação na seguinte saída:

Como você pode ver, uma implantação "httpd-frontend" foi criada com sucesso. Para ver os detalhes da implantação, execute o mesmo comando "Get Deployment" novamente no terminal. Quando você executa o comando "Get Deployment", ele listará todas as implantações criadas até agora. Veja a seguinte lista:

Comando # 12: Obtenha REPLICASET | grep

O “Get ReplicaSet | O comando grep ”é usado para exibir a lista de replicaset das implantações. Como acabamos de criar uma implantação, podemos ver os detalhes usando o seguinte comando:

Comando # 13: Obtenha pods | grep

Quando você cria uma implantação, ela cria pods e replicasets. Já listamos o replicaset. Agora, vamos criar todas as vagens criadas pelo réplica. Os “Get Pows | O comando Grep ”é usado para listar todas as vagens criadas pelo Replicaset. A lista de pods criados pelo ReplicaSet será exibida, correspondendo ao nome especificado fornecido pelo usuário. Veja a seguinte saída:

Comando # 14: Exclua

Vamos excluir o pod para testar a criação automática da vagem. Para excluir o pod existente, temos o comando "excluir". Quando você executa o comando "Excluir pod", o pod especificado será excluído. Veja a seguinte saída:

Como você pode observar, o pod “httpd-frontend-6f67496c45-56vn8” foi excluído com sucesso. Agora, vamos verificar se o novo pod é criado automaticamente após a exclusão especificamente da vagem existente. Para fazer isso, execute as “Get PODS | Grep ”comando novamente no terminal. Aqui está o seguinte resultado:

Observe que um novo pod foi criado automaticamente após a exclusão da vagem existente. Agora, vamos verificar o que acontece depois de excluir o réplica. Primeiro, obteremos a lista de replicaset usando o mesmo “Get ReplicaSeet | Grep ”comando. Veja a seguinte lista:

Agora, exclua o replicaSet usando o comando delete e especificando o nome do réplica.

Como você pode ver, o terminal indica que o réplicaset foi excluído com sucesso. Então, vamos verificar se a implantação havia criado automaticamente a replicaset ou não quando foi excluída. Vamos executar o mesmo “Obtenha replicaSet | Comando Grep ”para listar toda a replicaset criada pela implantação. Veja a seguinte saída:

Observe que o ReplicaSet foi criado automaticamente pela implantação, mesmo depois de ter sido excluído com força. Confira o próximo comando para obter mais detalhes sobre o pod:

Comando # 15: -o largo

O comando "-o wide" é usado para obter os detalhes da vagem que foi criada recentemente. Basta especificar o nome do pod e usar o comando "get" com o campo "-o wide" para obter informações detalhadas sobre o pod. Veja a saída fornecida abaixo:

Agora, se você precisar ver os detalhes completos da vagem, poderá executar o comando "descrever" novamente, fornecendo especificamente o nome do pod.

Como você pode ver, o comando descreve retornou os detalhes completos do poder httpd-franco, incluindo nome de pod, espaço para nome, horário de início, detalhes do nó, status, endereço IP, ID de contêiner, etc. Agora, se você não precisar mais da implantação, remova -o usando o comando "excluir". Primeiro, obtenha a lista de implantações através do comando "Get Deployment".

A única implantação que temos no cluster de Kubernetes é "httpd-frend". Execute o comando "Excluir" na implantação "httpd-frarontend" para excluí-lo.

A implantação de "httpd-frontend" foi excluída com sucesso. Se você verificar as implantações agora, nada será devolvido. Veja a saída fornecida abaixo:

Observe que quando excluímos a implantação, ela não foi criada novamente. No entanto, quando excluímos o pod e o ReplicaSet, ambos foram criados automaticamente novamente pela implantação. Como ambos fazem parte da implantação, eles serão criados novamente até que você exclua a própria implantação, mesmo que você os exclua com força.

Criação de namespaces em Kubernetes usando comandos Kubectl?

Permite ao administrador organizar, estruturar, organizar, agrupar e alocar recursos para funcionar suavemente a operação de cluster. Vários espaços para names podem ser encontrados em um único cluster de Kubernetes, todos logicamente separados um do outro.

Etapa 1: Crie o arquivo YAML

A primeira etapa que você precisa executar é criar um novo arquivo YAML para configuração usando o comando "touch". Depois disso, abra o arquivo recém -criado no editor desejado usando o comando "nano".

Um arquivo YAML do tipo namespace foi criado. Agora adicione “APIVERSION: V1, Kind: Namespace, Metadata: Nome: Kalsoom” no arquivo e salve -o. Veja o arquivo aberto fornecido abaixo:

Etapa 2: Crie YAML específico com Kubectl Crie -f

Use o comando "Kubectl Create -f" com o nome do espaço para nome seguido pelo caminho do arquivo YAML para criar o espaço para nome desse nome específico.

Como você pode ver, a saída indica que o namespace foi criado com sucesso.

Etapa # 3: Liste todos os namespaces

Use o comando “Kubectl Get Namespaces” para listar todos os namespace que estão presentes no cluster.

Os "Get Namespaces" retornaram o nome, o status e a idade de todos os espaços para nome existentes no cluster de Kubernetes. Se você quiser ver os detalhes de um espaço para nome específico, pode fazer isso usando o nome do espaço para nome com o comando get, como mostrado abaixo:

Etapa 4: Obtenha a descrição completa do espaço para nome

Se você precisar ver os detalhes completos de um espaço para nome específico, isso pode ser feito usando o comando descrever. Veja a saída fornecida abaixo:

Como trabalhar com pods em Kubernetes usando os comandos Kubectl?

Vamos criar algumas vagens no cluster Kubernetes.

Etapa 1: obtenha todos os nós existentes

Execute o comando "Kubectl Get nós" no terminal para ver os nós do cluster. Veja a saída abaixo:

Etapa 2: Crie o pod usando a imagem nginx

O pod pode ser criado usando a imagem nginx.

A saída mostra que o Nginx POD foi criado em execução com a imagem Nginx no hub do documento. Observe que a bandeira "reiniciar" foi definida como "nunca". Isso é feito para garantir que os Kubernetes criem uma única vagem em vez de uma implantação.

Etapa 3: Liste todos os pods

Para ver o pod que foi criado recentemente, podemos executar o comando "get pods". O comando "Kubectl Run Pods" exibe o status da vagem.

Etapa 4: obtenha todos os detalhes das vagens

Se você precisar ver os detalhes completos e a configuração inteira dos pods, use o mesmo comando "descrever" novamente com o nome de pod. O comando completo é mostrado abaixo:

Você pode ver o YAML para o pod que foi criado recentemente. A configuração inclui o nome, espaço para nome, horário de início, etiquetas, status, tipo de imagem, etc. Isso também contém os detalhes completos do contêiner nginx.

Etapa 5: Excluir pod

O POD criado nas seções anteriores pode ser excluído simplesmente usando o comando "excluir" com o nome de pod.

A execução do comando "delete" foi bem -sucedida, então a vagem foi excluída.

Conclusão

Ao iniciar sua jornada de Kubernetes, você terá que lidar com todos os tipos de comandos de Kubectl. Este artigo completo ajudará você a entender os comandos Kubectl e como você pode usá -los para criar diferentes pacotes, namespaces, vagens, nós, etc. Esses comandos ajudam você a executar as operações básicas em todos os objetos de cluster de Kubernetes.