Explore o Cluster Kubernetes

KubernetesBeginner
Pratique Agora

Introdução

Neste laboratório, você explorará um cluster Kubernetes local usando Minikube. Você iniciará o cluster, verificará sua configuração e inspecionará recursos básicos do cluster, como pods e deployments. Esta experiência prática o ajudará a entender os componentes e comandos fundamentais de um ambiente Kubernetes, estabelecendo a base para exploração e desenvolvimento futuros.

Você começará configurando um cluster Minikube em sua máquina local, garantindo que o cluster esteja em execução e pronto para uso. Em seguida, você verificará a configuração e a integridade do cluster usando comandos kubectl essenciais, como kubectl cluster-info e kubectl get nodes. Por fim, você inspecionará os recursos básicos do cluster, incluindo pods e deployments, para se familiarizar com o modelo de objeto Kubernetes e o estado geral do cluster.

Este é um Lab Guiado, que fornece instruções passo a passo para ajudá-lo a aprender e praticar. Siga as instruções cuidadosamente para completar cada etapa e ganhar experiência prática. Dados históricos mostram que este é um laboratório de nível intermediário com uma taxa de conclusão de 69%. Recebeu uma taxa de avaliações positivas de 100% dos estudantes.

Iniciar o Cluster Kubernetes Local

Nesta etapa, você iniciará e verificará um cluster Kubernetes local usando Minikube, que oferece uma maneira simples de configurar um ambiente Kubernetes de nó único para aprendizado e desenvolvimento.

Primeiro, navegue até o diretório do projeto:

cd ~/project

Inicie o cluster Minikube:

Observação: Usuários gratuitos não podem se conectar à internet, então o minikube já está pré-iniciado quando você inicia o laboratório. Você pode pular para a seção de código abaixo para verificar o status do cluster. Atualize para um usuário pro para praticar o início do cluster por conta própria.

Somente Usuários Pro
minikube start

Exemplo de saída:

😄  minikube v1.29.0 on Ubuntu 22.04
✨  Automatically selected the docker driver
📌  Using Docker driver with root permissions
🔥  Creating kubernetes in kubernetes cluster
🔄  Restarting existing kubernetes cluster
🐳  Preparing Kubernetes v1.26.1 on Docker 20.10.23 ...
🚀  Launching Kubernetes ...
🌟  Enabling addons: storage-provisioner, default-storageclass
🏄  Done! kubectl is now configured to use "minikube" cluster and "default" namespace

Verifique o status do cluster usando vários comandos:

minikube status

Exemplo de saída:

minikube
type: Control Plane
host: Running
kubelet: Running
apiserver: Running
kubeconfig: Configured

Verifique os nós do cluster:

kubectl get nodes

Exemplo de saída:

NAME       STATUS   ROLES           AGE   VERSION
minikube   Ready    control-plane   1m    v1.26.1

Esses comandos confirmam que:

  1. Minikube foi iniciado com sucesso
  2. O cluster Kubernetes local está em execução
  3. O cluster está pronto para uso
  4. Você tem um cluster de nó único com capacidades de plano de controle

O cluster Minikube fornece um ambiente Kubernetes completo em sua máquina local, permitindo que você desenvolva e teste aplicativos sem a necessidade de um cluster multi-nó completo.

Visão Geral da Arquitetura Kubernetes

O Kubernetes opera em um modelo cliente-servidor, com um Plano de Controle (Control Plane) centralizado governando o estado do cluster e um conjunto de Nós (Nodes) de trabalho executando cargas de trabalho. Em um nível geral, um usuário (frequentemente um desenvolvedor) interage com o cluster Kubernetes por meio de ferramentas de linha de comando ou APIs. O Plano de Controle toma decisões sobre o que deve ser executado onde, monitora a integridade do cluster e garante que o estado desejado seja alcançado. Os Nós de trabalho hospedam seus aplicativos em Pods — grupos de um ou mais contêineres — e oferecem os recursos computacionais e de armazenamento necessários para executá-los.

Plano de Controle (Control Plane)

Este é o "cérebro" do cluster, consistindo em vários componentes que trabalham juntos para gerenciar todo o sistema:

  • kube-apiserver (API): Serve como a porta de entrada do cluster. Todos os comandos administrativos e solicitações de recursos passam por ele.
  • etcd (Key Value Store): Armazena todos os dados de configuração e o estado atual do cluster. Se você perder os dados do etcd, perderá o estado do cluster.
  • kube-scheduler (SCH): Atribui Pods aos Nós com base nos requisitos de recursos, restrições e políticas.
  • kube-controller-manager (CTLM): Executa uma variedade de controladores que ajustam continuamente o estado do cluster, garantindo que o estado real corresponda ao estado desejado definido por seus deployments e configurações.

Nós (Máquinas de Trabalho)

Os Nós são onde as cargas de trabalho são executadas. Cada Nó tem:

  • kubelet (KLT): Um agente em nível de nó que se comunica com o Plano de Controle. Ele garante que os Pods estejam em execução e relata seu status de volta ao Plano de Controle.
  • Container Runtime (CR): Software que executa e gerencia contêineres (por exemplo, Docker ou containerd). Ele cria e gerencia aplicativos em contêineres dentro dos Pods.

Pods

Um Pod é a menor unidade implantável no Kubernetes, normalmente representando uma única instância de um aplicativo em execução. Os Pods podem conter um ou mais contêineres que compartilham o mesmo namespace de rede e volumes de armazenamento.

Services

Um Service é uma abstração que define um conjunto lógico de Pods e uma política para como acessá-los. Os Services fornecem endereços IP estáveis, nomes DNS e balanceamento de carga, garantindo que consumidores externos e outros componentes do cluster possam se conectar de forma confiável aos seus aplicativos — mesmo quando os Pods se movem entre os Nós ou são substituídos durante o dimensionamento ou atualizações contínuas.

Interagindo com o Cluster

  • Desenvolvedores e administradores interagem com o cluster por meio do kube-apiserver, geralmente usando kubectl ou outros clientes Kubernetes.
  • Quando um novo aplicativo é implantado, os componentes do Plano de Controle (scheduler, controllers) trabalham para colocar os Pods nos Nós apropriados.
  • O kubelet em cada Nó garante que os Pods estejam íntegros e em execução conforme instruído.
  • Os Services roteiam o tráfego para os Pods corretos, permitindo que os clientes acessem os aplicativos sem ter que rastrear as alterações de localização dos Pods.
flowchart TB %% User interacting with the cluster User((Developer)) User -->|kubectl CLI| API[kube-apiserver] %% Control Plane Components subgraph ControlPlane[Control Plane] API ETCD[etcd - Key Value Store] SCH[kube-scheduler] CTLM[kube-controller-manager] API --> ETCD API --> SCH API --> CTLM end %% Worker Node 1 subgraph Node1[Worker Node] KLT1[kubelet] CR1[Container Runtime] subgraph Pods1[Pods] P1[Pod] P2[Pod] end KLT1 --> CR1 CR1 --> P1 CR1 --> P2 end %% Worker Node 2 subgraph Node2[Worker Node] KLT2[kubelet] CR2[Container Runtime] subgraph Pods2[Pods] P3[Pod] P4[Pod] end KLT2 --> CR2 CR2 --> P3 CR2 --> P4 end %% Connections between Control Plane and Nodes API --> KLT1 API --> KLT2 %% Service connecting to Pods across different Nodes Service[Service] Service --> P1 Service --> P2 Service --> P3 Service --> P4

No diagrama:

  • O desenvolvedor interage com o kube-apiserver (API) por meio de uma ferramenta CLI como kubectl.
  • Os componentes do Plano de Controle (API, etcd, Scheduler, Controller Manager) gerenciam o estado do cluster e orquestram as cargas de trabalho.
  • Cada Nó de trabalho executa um kubelet e um container runtime, hospedando vários Pods.
  • Um Service roteia o tráfego externo ou interno para os Pods corretos, fornecendo um endpoint estável que abstrai a complexidade dos ciclos de vida dos Pods e as alterações de IP.

Este modelo mental ajuda você a entender o que você está vendo quando inspeciona o estado do cluster, verifica a integridade do Nó, lista os Pods e consulta os Services — conceitos que você aplicará ao continuar explorando o Kubernetes com os comandos kubectl.

Verificar a Configuração do Cluster

Nesta etapa, você aprenderá como verificar a configuração e a integridade do seu cluster Kubernetes usando comandos kubectl essenciais. Esses comandos ajudarão você a entender o estado atual e a conectividade do cluster.

Primeiro, verifique as informações do cluster:

kubectl cluster-info

Exemplo de saída:

Kubernetes control plane is running at https://192.168.49.2:8443
CoreDNS is running at https://192.168.49.2:8443/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'

Este comando fornece detalhes sobre o plano de controle Kubernetes e serviços principais como o CoreDNS.

Em seguida, obtenha uma visão detalhada dos nós do cluster:

kubectl get nodes -o wide

Exemplo de saída:

NAME       STATUS   ROLES           AGE    VERSION   INTERNAL-IP    EXTERNAL-IP   OS-IMAGE             KERNEL-VERSION
minikube   Ready    control-plane   15m    v1.26.1   192.168.49.2   <none>        Ubuntu 22.04 LTS    5.15.0-72-generic

Vamos examinar os detalhes do nó de forma mais abrangente:

kubectl describe node minikube

Exemplo de saída (parcial):

Name:               minikube
Roles:              control-plane
Labels:             beta.kubernetes.io/arch=amd64
                    beta.kubernetes.io/os=linux
                    kubernetes.io/arch=amd64
                    kubernetes.io/hostname=minikube
                    kubernetes.io/os=linux
                    minikube.k8s.io/commit=86a3b7e45a9a35cdcf8f4c80a4c6a46d20dda00f
Annotations:        node.alpha.kubernetes.io/ttl: 0
                    volumes.kubernetes.io/controller-managed-attach-detach: true
CreationTimestamp:  [Current Timestamp]
Capacity:
  cpu:                2
  ephemeral-storage:  17784212Ki
  memory:             1947748Ki
  pods:               110
Allocatable:
  cpu:                2
  ephemeral-storage:  16388876Ki
  memory:             1845348Ki
  pods:               110

Principais insights desses comandos:

  1. Verifique se o plano de controle do cluster está em execução
  2. Verifique o status do nó (Ready/NotReady)
  3. Entenda os recursos e a configuração do nó
  4. Confirme a versão do Kubernetes e os detalhes do nó

Inspecionar Recursos Básicos do Cluster

Nesta etapa, você inspecionará recursos básicos do Kubernetes — como Pods, Deployments e Services — em todos os namespaces. Ao usar a flag -A (ou --all-namespaces), você verá como os recursos são organizados em todo o cluster. Esta é uma excelente oportunidade para apresentar e entender o conceito de Namespaces no Kubernetes.

Namespaces: Isolamento de Recursos

Namespaces são partições lógicas dentro de um cluster Kubernetes que ajudam a organizar e gerenciar recursos. Eles fornecem uma maneira de agrupar objetos relacionados e aplicar políticas, controles de acesso e cotas de recursos em um nível granular. Ao separar os recursos em diferentes namespaces, você pode:

  • Melhorar a Organização: Agrupar cargas de trabalho relacionadas (por exemplo, por projeto, equipe ou ambiente — como dev, test e production).
  • Aprimorar a Segurança e o Controle de Acesso: Restringir quais usuários ou contas de serviço podem visualizar ou modificar recursos em um namespace específico.
  • Simplificar o Gerenciamento de Recursos: Aplicar limites de recursos, políticas de rede e outras configurações em todo o cluster de forma mais eficaz.

Ao listar recursos com a flag -A (ou --all-namespaces), você notará que os componentes pertencentes ao sistema Kubernetes residem no namespace kube-system, que é dedicado à infraestrutura em nível de cluster. Aplicativos criados pelo usuário normalmente residem no namespace default ou em outros namespaces personalizados que você define.

Namespaces e Recursos

flowchart LR %% User interacts with the cluster via kube-apiserver User((Developer)) User -->|kubectl get pods -A| API[kube-apiserver] %% Control Plane Subgraph subgraph ControlPlane[Control Plane] API ETCD[etcd] SCH[kube-scheduler] CTLM[kube-controller-manager] end API --> ETCD API --> SCH API --> CTLM %% kube-system namespace subgraph kube-system[Namespace: kube-system] SysDeployment[Deployment: coredns] SysPod1[Pod: coredns-xxx] SysService[Service: kube-dns] SysDeployment --> SysPod1 SysService --> SysPod1 end %% default namespace (renamed to avoid parse issues) subgraph defaultNs[Namespace: default] DefDeployment[Deployment: my-app] DefPod1[Pod: my-app-pod1] DefPod2[Pod: my-app-pod2] DefService[Service: my-app-service] DefDeployment --> DefPod1 DefDeployment --> DefPod2 DefService --> DefPod1 DefService --> DefPod2 end %% dev namespace subgraph dev[Namespace: dev] DevDeployment[Deployment: dev-app] DevPod[Pod: dev-app-pod] DevService[Service: dev-app-service] DevDeployment --> DevPod DevService --> DevPod end %% Demonstration of communication API --> kube-system API --> defaultNs API --> dev

No diagrama:

  • O Plano de Controle gerencia todo o cluster, comunicando-se com os nós e controlando as cargas de trabalho.
  • Namespaces (como kube-system, default e dev) separam logicamente os recursos dentro do cluster.
    • kube-system contém componentes em nível de sistema, como CoreDNS e kube-dns.
    • default é comumente usado para cargas de trabalho gerais, aqui representado por um deployment my-app.
    • dev pode representar um ambiente de desenvolvimento, isolado das cargas de trabalho de produção.

Ao visualizar os recursos em todos os namespaces, você obtém uma compreensão abrangente de como essas partições lógicas ajudam a manter um cluster organizado e seguro.

Exemplos:

Listar todos os pods em todos os namespaces:

kubectl get pods -A

Exemplo de saída:

NAMESPACE     NAME                               READY   STATUS    RESTARTS      AGE
kube-system   coredns-787d4945fb-j8rhx           1/1     Running   0             20m
kube-system   etcd-minikube                      1/1     Running   0             20m
kube-system   kube-apiserver-minikube            1/1     Running   0             20m
kube-system   kube-controller-manager-minikube   1/1     Running   0             20m
kube-system   kube-proxy-xb9rz                   1/1     Running   0             20m
kube-system   kube-scheduler-minikube            1/1     Running   0             20m
kube-system   storage-provisioner                1/1     Running   1 (20m ago)   20m

Aqui, você vê todos os pods relacionados ao sistema em execução no namespace kube-system. Se você tivesse outros deployments ou services em namespaces diferentes, eles também apareceriam nesta lista, cada um claramente delimitado por seu namespace.

Listar todos os deployments em todos os namespaces:

kubectl get deployments -A

Exemplo de saída:

NAMESPACE     NAME      READY   UP-TO-DATE   AVAILABLE   AGE
kube-system   coredns   1/1     1            1           20m

O deployment coredns reside no namespace kube-system.

Obter uma visão abrangente de todos os recursos em todos os namespaces:

kubectl get all -A

Este comando exibe uma visão geral de pods, services e deployments em diferentes namespaces, ajudando você a entender como esses recursos são distribuídos em todo o cluster.

Principais Conclusões:

  • Namespaces fornecem isolamento lógico e organização dentro de um cluster Kubernetes.
  • Diferentes componentes e recursos do Kubernetes são organizados em namespaces específicos (por exemplo, kube-system para serviços principais, default para cargas de trabalho gerais e namespaces adicionais que você cria).
  • Ao usar -A para visualizar recursos em todos os namespaces, você obtém informações sobre como seu cluster é estruturado e como os namespaces servem como limites para a organização de recursos e controle de acesso.

Ao entender como os namespaces funcionam como ambientes lógicos, você pode navegar, isolar e gerenciar melhor suas cargas de trabalho e recursos relacionados ao cluster, especialmente ao dimensionar seus deployments e introduzir mais complexidade em seu ambiente Kubernetes.

Resumo

Neste laboratório, você iniciou e verificou um cluster Kubernetes local usando o Minikube, que fornece uma maneira simples de configurar um ambiente Kubernetes de nó único para aprendizado e desenvolvimento. Você confirmou que o cluster Minikube foi iniciado com sucesso, o cluster Kubernetes local está em execução, o cluster está pronto para uso e você tem um cluster de nó único com capacidades de plano de controle. Você também aprendeu como verificar a configuração e a integridade do seu cluster Kubernetes usando comandos kubectl essenciais, como kubectl cluster-info e kubectl get nodes, que ajudaram você a entender o estado atual e a conectividade do cluster.