Kubernetes: Pods, Services e ConfigMaps

Conhecendo o Kubernetes - Introdução

Eu sou o Daniel Artine e vou ser instrutor de vocês nesse curso de Kubernetes da Alura.

Nele nós vamos entender, desde o início, o que é essa ferramenta, para que ela serve e como nós podemos utilizar os recursos que ela nos provê, para que nós possamos tirar o máximo de proveito dessa ferramenta.

E esse curso vai ser dividido em duas partes, onde nós vamos abordar diversos destes recursos que o Kubernetes tem para nós e nós vamos entender o que ele já consegue fazer para nos ajudar do início ao fim desse curso.

Então, nós vamos entender o que é um Pod, um ReplicaSet, um Deployment e um Volume. Todas essas questões nós vamos entender durante a primeira e a segunda parte desse curso, então caso você sinta a falta de algum conteúdo nessa primeira parte, fique tranquilo porque provavelmente ele vai ser coberto na segunda.

E outro aviso é que, como esse curso é voltado a introduzir e apresentar o Kubernetes para vocês, nós não vamos ter ele voltado em nenhuma plataforma específica. Então eu vou fazer o máximo para mostrar para vocês como ele funciona no Windows, no Linux e também em alguns Clouds Providers; no caso aqui, o Google Cloud plataform.

Não vai ser com foco nas plataformas, e sim como Kubernetes funcionam; para nós entendermos o que essa ferramenta nos dá e como nós podemos utilizar ela em qualquer um desses ambientes.

Então por esse vídeo aqui é só! Espero que vocês curtam o curso e nós nos veremos no próximo vídeo. Até mais!

Conhecendo o Kubernetes - O que é o Kubernetes?

Então, antes de nós começarmos a colocar a mão na massa com qualquer coisa do tipo com Kubernetes, nós precisamos entender o que é o Kubernetes, algumas questões arquiteturais em linhas gerais de como ele funciona e quais problemas ele resolve.

E isso é bem importante, tanto que nós vamos começar com um exemplo aqui bem clássico. Nós temos aqui uma máquina e nós estamos executando alguns containers.

Vamos fazer aqui a ponte com um Docker, que é o que nós temos por enquanto. Nós temos alguns containers em execução dentro dessa máquina, e caso nós queiramos executar mais containers dentro dessa máquina para mantermos a nossa aplicação em execução, o que pode acabar acontecendo?

Toda a máquina tem um limite de poder computacional; então caso essa máquina atinja o seu limite, pode ser que ela pare de funcionar, a aplicação responde de maneira mais lenta ou a máquina fique reiniciando incessantemente. Nós temos diversas possibilidades do que pode acontecer com essa máquina.

E para nós resolvermos esse problema temos uma solução bem simples, que é simplesmente comprarmos uma máquina mais potente, com maior poder computacional, para que ela consiga executar os nossos containers sem nenhum problema.

Então nós chamamos isso de adicionar mais poder computacional à uma mesma máquina; adicionando mais processamento, memória, armazenamento para resolvermos aqui o nosso problema de escalabilidade vertical. Então nós adquirimos uma máquina mais “parruda” para resolvermos o nosso problema.

E ainda no mesmo problema: como nós poderíamos resolver ele de outra forma? Nós temos a mesma situação, em que se nós tentarmos adicionar mais containers nessa máquina, ela vai parar de funcionar; nós estamos atingindo o limite computacional dessa máquina.

Para resolvermos isso nós podemos simplesmente adicionar mais máquinas para trabalhar aqui em paralelo com a nossa máquina original, então elas também vão ter capacidade de executar os containers sem nenhum problema e elas vão se comunicar de alguma maneira para falar o que estão fazendo com os containers que estão dentro delas.

Nesse caso onde nós adicionamos mais máquinas para trabalhar em paralelo em conjunto com as outras, nós chamamos de escalabilidade horizontal. Então nós adicionamos mais máquinas para resolver o nosso problema.

Mas por que eu estou falando isso para vocês? Onde é que o Kubernetes entra nessa história?

O Kubernetes entra do seguinte modo: eu falei para vocês agora que nós resolvemos o problema na escalabilidade horizontal dividindo o poder computacional das máquinas trabalhando em paralelo. Então o Kubernetes é capaz de fazer isso, ele gerencia uma ou múltiplas máquinas trabalhando em conjunto, que nós vamos chamar de cluster.

Então, uma ou mais máquinas trabalhando em conjunto, dividindo o seu poder computacional, nós vamos chamar de um cluster. O Kubernetes é capaz de criar esse cluster e o gerenciar para nós.

É aí que Kubernetes entra na história! Então nós conseguimos encontrar um cluster com Kubernetes; seja na AWS, seja no Google Cloud Plataform e na Azure também, aqui com Minikube no final.

Nós vamos utilizar aqui no curso, nós vamos fazer alguns exemplos diversos com o Google Cloud Plataform, nós vamos fazer alguns com Minikube e também com o próprio Docker desktop no Windows. Então nós vamos variar bem os cenários para vocês fixarem bem a ideia.

Mas como o Kubernetes vai trabalhar com esse cluster? O que ele é capaz de fazer? Digamos que, mais uma vez, usando a licença poética de chamar de “container” até então, porque é o que nós sabemos do Docker.

Então, digamos que nós queremos utilizar um container dentro de uma máquina do nosso cluster. Nós simplesmente pedimos ao Kubernetes que ponha esse container para executar dentro do nosso cluster e ele vai definir para ele aqui, usando os algoritmos que ele tem ali internamente - que, por exemplo, a nossa primeira máquina é a melhor a executar esse container.

E se eu quiser executar outro como a primeira máquina, já está sendo utilizada ali um pouco do poder computacional dela; pode ser que o Kubernetes defina que a segunda máquina vai ser responsável por executar esse container.

E caso esse container falhe, por exemplo, o Kubernetes tem total capacidade de adicionar um novo container para substituir esse que estava até então ali na nossa máquina e falhou.

E caso essas duas máquinas atinjam o seu limite de poder computacional em algum momento, o Kubernetes também é capaz de criar uma nova máquina dentro do nosso cluster para que nós consigamos também adicionar mais containers à essas máquinas - e isso é claro, uma máquina virtual. Nós não vamos materializar uma máquina física aqui na nossa casa ou no nosso ambiente de trabalho.

Então a questão é essa: o Kubernetes é capaz de criar e gerenciar um cluster para que nós consigamos manter a nossa aplicação escalável sempre que nós quisermos adicionar novos containers, sempre que nós quisermos reiniciar a nossa aplicação de maneira automática, caso ela tenha falhado. Então nós chamamos isso de orquestração de containers.

Então o Kubernetes é um orquestrador de containers capaz de resolver todos esses problemas que eu listei para vocês.

Então nós vamos ver no decorrer desse curso todas as formas que o Kubernetes tem para nos ajudar a resolver diversos tipos de problemas que ainda podem aparecer. A ideia base para vocês é essa, mas nós vamos abordar várias outras no decorrer do curso.

Para o primeiro vídeo é isso. Nós continuaremos estudando como Kubernetes vai nos ajudar nos próximos e eu vejo vocês lá. Até mais!

Conhecendo o Kubernetes - A arquitetura do Kubernetes

Antes de nós colocarmos a "mão na massa" no próximo vídeo, nós vamos entender ainda uma última questão arquitetural e de recursos do Kubernetes. Como assim?

Ele vai muito além de ser um simples orquestrador de containers, ele já tem diversos recursos, como eu acabei de falar para vocês, que nos ajudam a resolver diversos tipos de problemas de maneira bem mais prática, sem nós implementarmos tudo do zero.

Como assim? Esse resources para se dizer a terminologia correta, já têm soluções ali implementadas para determinadas tipos de caso. Então nós temos, por exemplo: pods, ReplicaSets, Deployments, Volumes. Nós vamos estudar cada um desses no decorrer do curso e quais problemas eles resolvem.

Então, por exemplo: se eu quero lidar com a questão de persistência de dados eu posso utilizar um recurso já pronto, que é o Persistent Volume. Então eu só vou definir como eu quero utilizar o Persistent Volume: se eu quero e devo utilizar e encapsular um container para utilizar no Kubernetes, eu utilizo um pod.

Então já dando um pequeno spoiler para vocês: um podnada mais é do que um recurso que encapsula um container no Kubernete. Nós nunca vamos utilizar um container propriamente dito diretamente no Kubernete, nós vamos utilizar pods.

Mas nós vamos ter uma aula voltada só para isso e para o Persistent Volume. É só para dar uma noção para vocês.

Utilizando esses recursos nós conseguimos construir aplicações bem elaboradas; onde, por exemplo, nós recebemos um tráfego de dados no nosso session, no nosso serviço e ele consegue fazer o balanceamento de cargas entre os pods que nós temos dentro da nossa aplicação.

Esses pods podem estar sendo gerenciados por um ReplicaSet que pode estar sendo gerenciado por um deployment e pode ser escalado. Nós podemos aumentar o número de pods, um horizontal pod autoscaler.

Então são coisas bem legais que nós conseguimos fazer de maneira bem prática com Kubernetes, porque estes recursos já nos estão prontos.

Mas como eu falei para vocês, vamos com calma. Nós vamos ver isso no decorrer da parte 1 e da parte 2.

Só que outra coisa que é importante nós sabermos também é que o Kubernetes ,como eu falei para vocês, vai gerenciar um cluster, e as máquinas dentro de um cluster recebem denominações diferentes.

Elas podem ser master, onde o master é responsável por coordenar e gerenciar todo o nosso cluster e nós temos os notes que são responsáveis pela execução do trabalho duro, para executar os nossos pods em capsulas containers, por assim dizer.

Mas, se nós formos sinalizar para entendermos de uma maneira mais detalhada, nós já vimos que os masters são responsáveis por gerenciar o cluster, eles vão ser responsáveis também por manter e atualizar o estado desejado.

Então se eu quero que um pod esteja em execução, o master vai ser o responsável por manter esse pod em execução; caso ele caia, ele vai ter um sinal ali responsável por fazer esse pod voltar a execução.

Ele também é responsável por receber os comandos. Eu quero criar algum recurso novo no meu cluster; eu vou me comunicar através do master, o qual vai ter todos os componentes necessários para lidar com isso e os nodes vão ser responsáveis por executar as nossas aplicações.

Mas se nós ainda formos detalhar um pouco mais, nós conseguimos que os componentes que eu falei para vocês agora possam ser destrinchados. Então, a API, por exemplo, é responsável por receber e executar os novos comandos, ela é uma API REST.

E nós temos o Controller Manager, que é responsável por manter e atualizar o estado desejado; nós temos os scheduler, responsável por definir onde determinado pod, vai ser executado no nosso cluster.

E nós temos ETCD, o responsável por armazenar todos os dados vitais do nosso cluster através de um banco de dados chave-valor.

E dentro do nosso Node nós encontramos dois componentes: o Kubelet, que é responsável pela execução dos poddentro dos nodes; e o KubeProxy, que é responsável pela comunicação entre os nossos nodes dentro do nosso cluster.

Então, a partir daí nós conseguimos saber o quê? Nós conseguimos nomear essa parte de Control Plane, a composição desses quatro de cima (API, Controller Manager, Scheduler e ETCD) e esses dois componentes (Kubelet e KubeProxy) fazem parte dos Nodes, Control Plane Nodes.

Então, só para vocês terem essa noção, terem o conhecimento e saber do que se trata, caso você entrem em uma conversa sobre isso, para saber e entender como funciona por debaixo dos panos, para não passar batido - isso é bem importante.

Mas para visualizarmos ainda melhor, nós temos esses seis componentes aqui (API, Controller Manager, Scheduler e ETCD) e que nós dividimos de um lado o nosso Control Plane e nós dividimos do outro aqui os nossos nós

Então, nós vamos ter para cada nó que nós tivermos, um par de Kubelet e KubeProxy. A API vai ser responsável por manter a comunicação entre todos esses componentes.

Então a API, além de receber as ordens do mundo externo e do que nós queremos fazer com o nosso cluster, ela é responsável por manter a comunicação com Controller Manager, um ETCD, com Scheduler e também os nossos nodes.

Por isso que ela é tão importante, ela é tão importante que nós vamos falar aqui sobre ela mais um pouco. Nós vimos que ela é responsável por fazer essa mágica, por conseguir gerenciar os recursos do nosso cluster, nos nossos resources.

Então através dela nós conseguimos criar um pod, editar um ReplicaSet, ler os dados no Deployment, deletar um Volume - tudo isso através da API, nós nunca vamos nos comunicar diretamente com os outros componentes; vai ser sempre através da API.

Mas, como nós nos comunicamos através da API? Como nós falamos com a API? A nossa máquina não tem poder da vidência e de saber o que é API e como se comunicar com ela, nós precisamos ter uma forma clara de se comunicar com ela através dessa API REST.

Para isso, nós temos uma ferramenta chamada Kubectl, que nos provê as funcionalidades de criar, ler, atualizar e remover os dados do nosso cluster, os componentes do nosso cluster, os nossos recursos.

Então, através do Kubectl nós conseguimos fazer isso de maneira declarativa ou imperativa. Nós podemos criar arquivos de definição, que nós vamos ver no decorrer do curso, ou executarmos comandos, que simplesmente vão fazer essa mágica acontecer.

E tudo isso ainda vai ser enviado um request do nosso Kubectl para a nossa API REST, que vai fazer a mágica acontecer dentro do nosso cluster. Só que a dúvida que fica agora e que nós vamos responder no próximo vídeo é: como nós instalamos o Kubectl? Porque nós não temos instalado ainda. E como nós inicializamos o nosso cluster?

Nós vamos ver que tem diferentes maneiras de nós inicializarmos aqui o nosso cluster, seja no Windows, seja no Linux, ou seja na nuvem. Eu vou mostrar os três casos para vocês e nós vamos entender como o cluster é inicializado e como nós utilizamos o Kubectl para nos comunicarmos com ele.

Então é isso! Por esse vídeo nós ficamos com essa parte bem teórica, mas no próximo nós começaremos com a prática. Até mais!

Sobre o curso Kubernetes: Pods, Services e ConfigMaps

O curso Kubernetes: Pods, Services e ConfigMaps possui 134 minutos de vídeos, em um total de 59 atividades. Gostou? Conheça nossos outros cursos de Containers em DevOps, ou leia nossos artigos de DevOps.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Conhecendo o Kubernetes
• Criando o cluster
• Criando e entendendo pods
• Expondo pods com services
• Aplicando services ao projeto
• Definindo variáveis de ambiente