Olá pessoal, estou estudando sobre Kubernetes e vim compartilhar um pouco do que aprendi. Vou supor que vocês já tenham o Docker instalado em suas máquinas. Caso contrário, deixarei um link abaixo de como instalar.

Instalar docker no macos com docker desktop

E olhando aqui no TabNews, encontrei um post onde o @tcarreira ensina uma alternativa para o Docker Desktop no macOS.

Docker em MacOS (Intel ou M1) - alternativa ao Docker Desktop

pronto agora vamos lá, primeira coisa quero dar um contexto.

Introdução ao Kubernetes

Kubernetes, frequentemente abreviado como K8s, é uma plataforma de código aberto para automatizar, dimensionar e gerenciar aplicativos contêinerizados. Desenvolvido inicialmente pelo Google e agora mantido pela Cloud Native Computing Foundation (CNCF), o Kubernetes oferece um ambiente robusto e flexível para implantação, gerenciamento e escala de aplicativos em contêineres.

O que é Kubernetes?

Kubernetes é uma ferramenta de orquestração de contêineres que simplifica e automatiza o processo de implantação, dimensionamento e gerenciamento de aplicativos contêinerizados em ambientes de produção. Ele fornece recursos poderosos para automatizar a distribuição, escalonamento, balanceamento de carga, monitoramento e recuperação de falhas de contêineres em larga escala.

Para que é Kubernetes?

Orquestração de Contêineres: Kubernetes permite a automação da implantação, dimensionamento e gerenciamento de aplicativos contêinerizados em um cluster de servidores.

Escalabilidade: Kubernetes facilita a escalabilidade de aplicativos, permitindo que eles sejam facilmente dimensionados horizontal ou verticalmente em resposta à demanda do usuário.

Disponibilidade e Confiabilidade: Com recursos avançados de balanceamento de carga e recuperação de falhas, Kubernetes ajuda a garantir que os aplicativos estejam sempre disponíveis e confiáveis.

Portabilidade: Kubernetes oferece portabilidade de aplicativos, permitindo que eles sejam executados em qualquer ambiente de infraestrutura, desde ambientes locais até nuvens públicas ou privadas.

Automação de Operações: Kubernetes automatiza tarefas operacionais, como implantação, escalonamento, monitoramento e recuperação de falhas, reduzindo a carga de trabalho administrativa.

Quando usar Kubernetes?

Kubernetes é ideal para empresas e equipes de desenvolvimento que estão implementando ou migrando para arquiteturas de microserviços ou contêineres. Ele é especialmente útil em cenários onde:

Há a necessidade de escalar aplicativos de forma dinâmica em resposta à demanda do usuário.
Aplicativos são compostos de vários serviços ou componentes distribuídos.
Existe a necessidade de garantir alta disponibilidade, confiabilidade e resiliência de aplicativos.
Quer-se maximizar a eficiência operacional e reduzir o tempo de inatividade.
Há uma variedade de ambientes de implantação, como ambientes locais, nuvens públicas ou privadas.

Estrutura Kubernetes

Historia:

A história do Kubernetes remonta ao início dos anos 2000, quando o Google começou a desenvolver internamente uma série de ferramentas para gerenciar seus aplicativos em escala. Essas ferramentas foram evoluindo ao longo do tempo e, eventualmente, culminaram no que hoje conhecemos como Kubernetes.

Aqui está um resumo dos principais marcos na história do Kubernetes:

Origens no Google (2003-2014): O Kubernetes teve suas raízes nos sistemas internos de gerenciamento de contêineres do Google. O Google já estava utilizando contêineres Linux em grande escala para seus próprios serviços, o que levou ao desenvolvimento de sistemas de gerenciamento avançados.

Projeto Borg: Antes do Kubernetes, o Google usava internamente um sistema de gerenciamento de contêineres chamado Borg. Borg era responsável por orquestrar e gerenciar milhões de contêineres em toda a infraestrutura do Google. O sucesso do Borg inspirou muitos dos conceitos e práticas que mais tarde seriam incorporados ao Kubernetes.

Lançamento do Kubernetes (2014): Em junho de 2014, o Google lançou o projeto Kubernetes como uma iniciativa de código aberto, oferecendo uma plataforma de gerenciamento de contêineres inspirada no Borg. Isso permitiu que desenvolvedores de todo o mundo tivessem acesso à mesma tecnologia de orquestração de contêineres que o Google usava internamente.

Doação para a CNCF (2015): Em julho de 2015, o Google doou o Kubernetes para a Cloud Native Computing Foundation (CNCF), uma organização sem fins lucrativos dedicada ao avanço de tecnologias de código aberto para aplicativos nativos da nuvem. Esta doação ajudou a solidificar o Kubernetes como uma tecnologia líder na orquestração de contêineres.

Crescimento e Adoção (2016-presente): Desde a doação para a CNCF, o Kubernetes experimentou um crescimento explosivo em termos de adoção e ecossistema. Empresas de todos os tamanhos, desde startups até grandes corporações, adotaram o Kubernetes como parte de sua infraestrutura de nuvem. O ecossistema ao redor do Kubernetes também se expandiu significativamente, com uma ampla gama de ferramentas e serviços que complementam e estendem sua funcionalidade.

O Kubernetes continua a evoluir rapidamente, com novos recursos sendo adicionados regularmente e a comunidade contribuindo ativamente para o seu desenvolvimento. Ele se tornou uma peça fundamental na construção de aplicativos modernos nativos da nuvem, oferecendo automação, escalabilidade e resiliência para ambientes de produção em larga escala.

Introdução ao Kubectl e Kind

O kubectl é uma ferramenta de linha de comando usada para interagir e controlar clusters Kubernetes. Ele permite que os usuários executem uma variedade de operações em seus clusters, como criar, modificar e excluir recursos, bem como obter informações sobre o estado dos aplicativos implantados no cluster.

O que é o kubectl?

O kubectl é a principal interface de linha de comando para Kubernetes. Ele atua como uma ponte entre os usuários e os clusters Kubernetes, permitindo que os usuários executem tarefas administrativas e operacionais em seus clusters usando comandos simples e intuitivos.

Para que é o kubectl?

Gerenciamento de Recursos: O kubectl permite aos usuários criar, listar, modificar e excluir recursos dentro de um cluster Kubernetes. Isso inclui pods, serviços, deployments, replicaset, e muitos outros recursos.
Implantação de Aplicativos: Com o kubectl, os usuários podem implantar aplicativos em seus clusters Kubernetes, especificando manifestos YAML ou JSON que descrevem os recursos necessários para executar seus aplicativos.
Operações de Cluster: O kubectl permite aos administradores realizar operações de cluster, como escalonamento, atualizações, rollbacks, backups e restaurações.
Monitoramento e Depuração: Os usuários podem usar o kubectl para obter informações sobre o estado atual dos recursos no cluster, como logs de contêineres, eventos do sistema e métricas de desempenho.

Quando usar o kubectl?

O kubectl é usado em uma variedade de cenários, incluindo:

Desenvolvimento de Aplicativos: Para implantar e gerenciar aplicativos durante o desenvolvimento e teste.
Operações de Produção: Para gerenciar clusters Kubernetes em ambientes de produção, incluindo operações de implantação, escalonamento e monitoramento.
Automação: Para automatizar tarefas administrativas e operacionais em clusters Kubernetes usando scripts ou ferramentas de automação.

Em resumo, o kubectl é uma ferramenta essencial para trabalhar com clusters Kubernetes, oferecendo uma interface intuitiva e poderosa para interagir e controlar a infraestrutura de contêineres em escala.

Instalar o kubectl

Linux:
Você pode instalar o kubectl no Linux usando o gerenciador de pacotes curl. Execute os seguintes comandos:

sudo apt-get update && sudo apt-get install -y apt-transport-https
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
echo "deb https://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list
sudo apt-get update
sudo apt-get install -y kubectl

Depois de instalar o kubectl, você pode verificar se foi instalado corretamente executando:

kubectl version --client

Introdução ao Kind (Kubernetes in Docker)

Kind, abreviação de Kubernetes IN Docker, é uma ferramenta de código aberto projetada para simplificar o processo de criação, execução e teste de clusters Kubernetes em ambientes locais de desenvolvimento. Ele permite que os desenvolvedores criem rapidamente clusters Kubernetes usando contêineres Docker como nós de cluster.

O que é o Kind?

Kind é uma ferramenta que permite aos desenvolvedores criar clusters Kubernetes usando contêineres Docker como nós. Ele é projetado para ser simples de usar e configurar, tornando-o uma escolha popular para ambientes de desenvolvimento local e testes automatizados.

Para que é o Kind?

Desenvolvimento Local: Kind é ideal para desenvolvedores que precisam criar clusters Kubernetes em seus ambientes de desenvolvimento local para desenvolvimento, teste e depuração de aplicativos.

Testes Automatizados: Kind pode ser usado para executar testes automatizados em clusters Kubernetes em pipelines de integração contínua (CI), permitindo que as equipes testem seus aplicativos em ambientes Kubernetes de forma rápida e eficiente.

Experimentação e Aprendizado: Kind é uma ótima ferramenta para experimentar e aprender sobre Kubernetes sem a necessidade de provisionar recursos de nuvem ou hardware físico.

Quando usar o Kind?

O Kind é especialmente útil em cenários onde:

Desenvolvedores precisam de um ambiente Kubernetes local para desenvolvimento e testes.
Equipes querem executar testes automatizados em clusters Kubernetes como parte de seus pipelines de CI/CD.
Desenvolvedores e equipes desejam experimentar e aprender sobre Kubernetes sem custo adicional de infraestrutura.
É necessário provisionar rapidamente clusters Kubernetes para fins de teste ou validação de aplicativos.
Em resumo, o Kind simplifica a criação e o gerenciamento de clusters Kubernetes em ambientes locais de desenvolvimento, oferecendo uma solução leve e flexível para as necessidades de desenvolvimento, teste e aprendizado relacionadas ao Kubernetes.

Passo a passo básico para instalar o Kind (Kubernetes IN Docker):

Pré-requisitos:

Certifique-se de ter o Docker instalado e em execução no seu sistema.
Tenha o kubectl instalado. Você pode instalá-lo seguindo as instruções oficiais: Instalando o kubectl.

Passo 1:
Baixar o Binário do Kind
Visite a página de releases do Kind no GitHub e baixe o binário compatível com o seu sistema operacional. Por exemplo, para Linux, você pode usar o seguinte comando:

curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.11.1/kind-linux-amd64

Em seguida, torne o binário executável:

chmod +x ./kind

Passo 2:
Adicionar o Executável ao PATH
Para facilitar o acesso ao Kind, mova o executável para um diretório que esteja incluído na sua variável de ambiente PATH. Por exemplo, você pode movê-lo para /usr/local/bin/:

sudo mv ./kind /usr/local/bin/

Passo 3:
Verificar a Instalação
Você pode verificar se a instalação foi bem-sucedida executando:

kind version

Isso deve exibir a versão do Kind instalada.

Passo 4:
Criar um Cluster Kubernetes
Agora que o Kind está instalado, você pode criar um cluster Kubernetes executando o seguinte comando:

kind create cluster

Este comando irá criar um cluster Kubernetes com as configurações padrão.

Passo 5:
Verificar o Cluster
Após a criação do cluster, você pode verificar se o cluster foi criado corretamente executando:

kubectl cluster-info --context kind-kind

Isso deve exibir as informações do cluster Kubernetes que você acabou de criar.

Passo 6:
Usar o Cluster
Agora que o cluster está pronto, você pode começar a usar o **kubectl ** para interagir com ele como faria com qualquer outro cluster Kubernetes.

Este é um guia básico para instalar e usar o Kind. Dependendo das suas necessidades específicas ou do ambiente em que você está trabalhando, pode haver configurações adicionais ou personalizações necessárias. Certifique-se de consultar a documentação oficial do Kind para obter mais informações

pronto, agora vamos colocar a mão na massa.

Criando Primeiro Cluster com Kind

Criar um cluster Kubernetes é tão simples quanto:

kind create cluster

Isso inicializará um cluster Kubernetes usando uma imagem de nó pré-construída . As imagens pré-construídas são hospedadas em kindest/node .

por padrão o kind cria apenas um cluster, ao executar o camando acima de create, irá aparecer o seguinte, ao criar o cluster

Creating cluster "kind" ...
 ✓ Ensuring node image (kindest/node:v1.29.2) 🖼
 ✓ Preparing nodes 📦
 ✓ Writing configuration 📜
 ✓ Starting control-plane 🕹️
 ✓ Installing CNI 🔌
 ✓ Installing StorageClass 💾

Beleza, agora vou explicar o que aconteceu acima,

O output "Creating cluster "kind"":

Ensuring node image (kindest/node:v1.29.2):

O Kind (Kubernetes IN Docker) está garantindo que a imagem do nó (node image) esteja disponível ou baixando-a, se necessário. A imagem do nó é essencial para executar os nós Kubernetes no cluster.

Preparing nodes:

Kind está preparando os nós do cluster Kubernetes. Isso pode envolver a configuração de recursos, como CPU, memória e armazenamento, além de outras configurações necessárias para garantir que os nós estejam prontos para executar os componentes do Kubernetes.

Writing configuration:

Kind está escrevendo a configuração do cluster. Isso inclui informações sobre como os nós devem ser configurados e como eles se comunicarão entre si. A configuração é essencial para garantir que o cluster Kubernetes funcione corretamente.

Starting control-plane

Kind está iniciando o plano de controle do Kubernetes. O plano de controle é responsável por gerenciar o estado do cluster, como agendamento de pods, escalonamento de aplicativos e monitoramento de recursos.

Installing CNI (Container Network Interface)

Kind está instalando a interface de rede do contêiner (CNI). A CNI é um padrão para redes de contêineres no Kubernetes, permitindo que os pods se comuniquem entre si e com recursos externos.

Installing StorageClass

Kind está instalando a classe de armazenamento. Uma classe de armazenamento define as propriedades do armazenamento que podem ser usadas por aplicativos no Kubernetes. Isso pode incluir o tipo de armazenamento, políticas de recuperação e outras configurações relacionadas ao armazenamento.

--
Essas etapas são fundamentais para criar um cluster Kubernetes funcional usando o Kind. Cada uma delas desempenha um papel importante na configuração e inicialização do cluster, garantindo que ele esteja pronto para implantar e executar aplicativos.

agora, execute o seguinte comando.

kubectl cluster-info --context kind-kind

irá aparecer mais ou menos isso:

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

Kubernetes control plane is running at https://127.0.0.1:44297:

Esta mensagem informa que o plano de controle do Kubernetes está em execução. O plano de controle é composto por vários componentes, como o API server, o scheduler, o controller manager e o etcd (um armazenamento de chave-valor distribuído). Esses componentes são essenciais para o funcionamento do Kubernetes e gerenciam o estado do cluster, programando pods, monitorando recursos e muito mais. O URL fornecido (https://127.0.0.1:44297) é o ponto de entrada para acessar o API server do Kubernetes, que permite interagir com o cluster por meio de comandos kubectl ou APIs.

CoreDNS is running at https://127.0.0.1:44297/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy:

Esta mensagem indica que o CoreDNS, que é o sistema de resolução de nomes padrão no Kubernetes, está em execução. O CoreDNS é responsável por resolver nomes de serviços para seus endereços IP correspondentes dentro do cluster. O URL fornecido é um proxy para o serviço CoreDNS, permitindo o acesso a ele para resolução de nomes dentro do cluster.
Em resumo, essas mensagens indicam que o Kubernetes foi iniciado com sucesso e que os principais componentes, como o plano de controle e o sistema de resolução de nomes (CoreDNS), estão em execução e prontos para uso.

Então, agora que criamos o cluster, temos alguns comandos interessantes que podemos executar, vamos la!:

kind get clusters

Esse comando a cima, irá retornar o cluster criado, e por padrão deve retornar escrito "kind"

Excluindo um Cluster,
se você criou um cluster com kind create cluster a exclusão, será igualmente simples:

kind delete clusters kind

Pronto! Se você seguiu esses passos, acabou de criar seu primeiro cluster com Kubernetes e Kind.

Sequencia em outro Post, no link abaixo:

Sequencia dá série, kubernetes

Agora vamos dar os créditos aos links do Docker.
ED Blog:
tcarreira
marciojg

Qualquer dúvida, basta comentar que estou à disposição para ajudar no que for possível.

Iniciando com Kubernetes com kind e docker.

Introdução ao Kubernetes

Introdução ao Kubectl e Kind

Criando Primeiro Cluster com Kind