Aula 2 - Desafio Kubernetes | Desafio DevOps & Cloud

Opa Tudo bem seja muito bem-vindo e muito bem-vinda a segunda aula do desafio devops e Cloud eu sou Fabrício Veronez E durante essa semana eu tô te mostrando de forma objetiva Como criar uma solução devops de ponta a ponta e conquistar um dos perfis mais valorizados e bem pagos no mercado de ti e como as aulas são complementares se você ainda não assistiu a aula um pausa aqui e vai lá assistir primeiro porque você vai precisar entender sobre contêiners e sobre docker para acompanhar o conteúdo de hoje beleza Hoje nós vamos falar sobre o kubernetes

que é de longe o melhor e mais utilizado orquestrador de contêiners do mercado e eu ouso dizer que essa é uma das Ferramentas mais importantes pra sua carreira a dobradinha Dock e kubernetes realmente muda o jogo de qualquer profissional de ti isso porque o docker ele vai te ajudar a criar novas versões do software para serem testadas em contêiners oferecendo a padronização e a consistência que elimina conflitos de ambiente enquanto o kubernetes te ajuda a gerenciar o Deploy das suas atualizações em produção sem ter Down time no sistema e garantindo a escala de acordo com

o aumento e a diminuição de requis ições inclusive é provável que você já tenha passado por uma situação parecida como essa aqui que eu tinha na época para trabalhar era Pascal fiz as apis dele tudo dentro do do Apache roda funciona beleza mas não tem escalabilidade aí eu comecei a ver que tinha o como fazer isso com o docker Né pô bem legal isso funciona né só que faltava alguma coisa ainda então se eu tinha se eu tinha 10 acessos simultâneo er uma beleza se eu tinha 100 acesso simultâneo uma beleza chegava a 1600 caía

tudo eu não eu não sabia para onde que eu ia eu não sabia que rumo tomar para mim modernizar as aplicações minhas ou dos meus clientes né tava perdido porque eu tava preso numa estrutura que que não era escalável quando esse meu amigo começou a convers começamos a conversar ele falou assim meu conheç o cernes cobnet ficou entrou na minha vida para ficar isso é meu inquestionável hoje eu tenho 1000 se acrescentar mais ele escala e continua rodando belezinha tá a minha produtividade é muito melhor muito maior eu tinha até medo de pegar um sistema

muito grande não dá conta hoje eu não tenho mais então eu eu eu me concentro mais no que dev do que eu devo fazer o que eu devo me concentrar que é o código em si a qualidade do código qualidade do códo aumentou muito até assim conversando com os amigos que já são da área tudo eles eles me vê até de outra forma hoje né que eles me chamam de dinossauro da informática que o cara que tá lá então né Hoje é o dinossauro que fica em cima né Marc ele cai e esmaga né então

foi rápido foi se meses e tem um outro tem uma outra empresa aqui dentro da empresa não foi só mudança do sistema foi mudança de pensamento do sistema foi um divisor de águas mesmo de verdade fala sério você já passou por isso aí não é agora imagina se você tivesse uma ferramenta que te ajudasse a Balancear a carga do sistema e que escalasse os recursos automaticamente evitando a instabilidade e a indisponibilidade do sistema te ajudando a dar conta de períodos de alta criticidade e a consumo na sua aplicação como por exemplo uma black friday então

o kubernetes ele vai te ajudar com isso assim como aconteceu com o nosso aluno Alison comecei a ter contato com kubernet e eu tive que caí Dentro Cara eu tive que e tive que mergulhar a fundo mesmo entendeu porque assim eu era o Senior da equipe entendeu E quando eu cheguei cara e ninguém sabia de kubernetes essa empresa ela tem muitos clientes precisava escalar isso né para que para que todas as aplicações né aguentassem e o tráfego que a gente esperava né no dia da black friday essa black friday foi diferente porque e foi o

meu primeiro contato com kubernetes em produção né e cara eram muitas aplicações no dia da Black Fry tava rodando 500 e poucos Pods mais ou menos 300 aplicações eu acho cara era muita coisa meio milhão de request por minuto cara foi uma parada bizarra na semana da black friday né E a gente não teve nenhum problema tá e a gente tava esperando que acontecesse algum problema sacou e não aconteceu nenhum problema isso assustou a gente e foi com esse curso que eh que eu consegui eh me virar né num ambiente de produção que tinha kubernetes

sacou como kubernetes e o docker são importantes e geram um valor enorme nos seus projetos então não tem mais essa de ficar procurando desculpa para não cair dentro e se I alizar porque o que mais tem aí são empresas querendo contratar profissionais que resolvam os seus problemas e cabe a você mostrar que você pode ser essa pessoa e é por isso que eu tô aqui fazendo o evento para te ajudar a evoluir cada vez mais feixado na aula de hoje nós vamos avançar na orquestração dos contêineres para garantir alguns atributos fundamentais que todos os sistemas

de autodesempenho devem ter como a resiliência a estabilidade e a escalabilidade da nossa aplicação E você também vai aprender a criar um cluster kubernetes local ou seja você vai ser capaz de fazer o Deploy de uma aplicação na sua própria máquina Fala sério isso é irado né E mesmo que você nunca tenha ouvido falar em kubernetes ou não tenha a menor ideia do que ele faz Fica tranquilo fica tranquila que você vai conseguir acompanhar aqui comigo beleza então vamos lá até agora aga nós vimos Como a tecnologia de contêiners e o docker facilitam a execução

de processos de maneira isolada permitindo rodar diversas aplicações sem conflito e comunicando apenas os processos que eu quero isso funciona bem em cenários simples mas quando a gente precisa de escalabilidade resiliência e disponibilidade 24 por7 o Dock sozinho ele não resolve todos os problemas por exemplo em um ambiente com diversos microsserviços é necessário criar réplicas dos contêiners para Balancear a carga durante ali os picos de uso o Dock sozinho ele não faz isso Além disso recursos como service Discovery onde cada réplica de um microsserviço tem um endereço diferente e a gente precisa de um ponto

único de acesso para essa réplica o docker também não vai fazer isso Outro ponto importante gerenciar a atualização das aplicações com formas de garanti Down time zero pro usuário gerenciar as configurações dessas aplicações e muito mais coisas o docker sozinho ele não vai resolver E aí que entra o kubernetes ele é um orquestrador de contêiners que gerencia todos os contêiners do seu ambiente independente da tecnologia utilizada com kubernetes você pode criar um ambiente único de gerenciamento de aplicações garantindo a escalabilidade a resiliência E especialmente para aplicações críticas e de grande porte o kubernetes ele foi

criado pelo Google em 2014 baseado no projeto borg e foi doado a Linux foundation em 2015 Hoje ele é mantido pela Cloud Native computing foundation e é amplamente utilizado no mercado como a principal ferramenta para ambientes escaláveis e resilientes o o kubernetes funciona com uma arquitetura de clusters composta por duas principais partes o control Plane e o worker o control plane ele orquestra o cluster enquanto o worker ele Executa os contêiners o control plane ele inclui o Api server que é o Ponto Central de comunicação com o kubernetes o etcd que é um banco chave

valor que armazena as informações do cluster o scheduler que éons ável por definir em qual nó os contêiners vão ser executados o Controller Manager que gerencia os controladores que mantém o estado desejado do cluster e já os worker ou worker nodes incluem O kubet que é responsável por garantir a execução dos contêiners se comunicando com o contêiner runtime e o Cub proxy que gerencia a comunicação de rede no cluster um ponto muito importante aqui você já deve ter ouvido falar que o docker não é mais compatível com o kubernetes e para você esquecer o docker

Mas calma que não é bem assim por mais que o docker não seja mais utilizado como contêiner runtime no kubernetes o kubernetes utiliza outros contêiners runtimes como container d e o cryo que seguem o padrão definido pela Open container initiative a oci ou seja o docker ele segue esse padrão Isso significa que você pode criar imagens no docker e usar no kubernetes Sem problema nenhum Existem algumas formas de você criar um cluster kubernet a primeira forma é o on premise onde você gerencia todo o ambiente ele é a forma mais complexa você criar o cluster

kubernetes Mas você também vai ter maior controle porque você vai gerenciar tudo você vai gerenciar instalação do Linux atualização configuração do cluster e ainda as aplicações nesse cluster kubernetes se você tá começando nesse mundo de kubernetes ou tem uma equipe pequena para gerenciar o cluster eu não recomendo que você faça por aqui a segunda forma é o kubernetes S Service utilizando serviços gerenciados pelos Cloud providers como o Eks o aks e o gke aqui você solicita a criação do cluster e o cloud provider vai fazer tudo para você Te Entregando o cluster pronto você vai

ter ali que se preocupar com o gerenciamento das sua das suas aplicações no kubernet esse aqui é o cenário que eu mais recomendo para ambiente produtivo e a terceira forma é utilizando ambiente local que é ideal para estudos e provas de conceito utilizando ferramentas como minic cube Kid E k3d essas ferramentas criam o seu cluster kubernetes baseado em contêiners doc cara é isso aí cada máquina do seu CL vai ser um contêiner na sua máquina local cada abordagem tem as suas vantagens e as suas desvantagens mas se você tá começando ou tem uma equipe pequena

Eu recomendo você usar um serviço gerenciado para simplificar a criação e a gestão do cluster agora nós vamos pra parte prática que nós vamos criar o cluster kubernetes utilizando o k3d uma solução leve e Fácil de usar ideal para dar os primeiros espaços e montar o seu ambiente de estudo local o k3d ele utiliza contêiners docker para simular os nós do cluster permitindo criar ambientes locais com muito menos recurso Então bora lá Criar o cluster e entender como fazer o Deploy de uma aplicação Bom vamos lá mas antes da gente começar aqui você precisa ter

alguns requisitos na sua máquina e ambiente para poder trabalhar com o kubernetes o primeiro requisito é ter o DOC Porque como a gente vai utilizar o k3d e ele utiliza containers Dock você precisa ter o Dock instalado mas provavelmente você já tem aí por conta da aula um segundo vs code ou qualquer editor de texto porque a gente vai trabalhar aqui com arquivos eemo o kubernetes ele é baseado em arquivos emos para criar os recursos Então a gente vai utilizar um editor Eu recomendo vs code que é o que eu utilizo que o mercado utiliza

mais mas Mas você pode utilizar aí qual você quiser utiliza o mesmo que a gente utilizou ou que você utilizou comigo na aula um agora outro ponto importante é o Cub CTL esse cara ele é responsável para por fazer a comunicação com o cluster kubernetes é através del que você vai executar os comandos e se comunicar com o cluster então precisa ter o Cub CTL instalado para instalar o Cub CTL deixa eu compartilhar aqui a minha tela você vai vir aqui ó Cub CTL install no Google e o primeiro item que ae vai achar aqui

vai ser a documentação do CUB CTL e você pode instalar o Cub CTL no Windows no Linux e no Mac aqui na nossa aula eu recomendo que você utilize o Mac ou ambiente Linux seja ele com wsl rodando no Windows ou Linux mesmo nativo não tem problema nenhum no no Windows Eu recomendo fortemente que você utilize o wsl fechado e então aqui ó para fazer instalação com o macos você vai seguir aqui o passo a passo eu recomendo que você use aqui e o brill install Cadê tá aqui ó brill install para fazer a instalação

no Linux você pode utilizar aqui o gerenciador de pacote da distribuição que você tá utilizando ou aqui com pegando o binário com o c Eu recomendo que você use o gerenciador de pacote tem aqui embaixo deixa eu achar aqui ó ele tem com distribuições baseadas em deban então deban é Ubunto pop os onde você vai utilizar aqui o aptg ou APT para fazer a instalação tem aqui para distribuições baseadas em Red Hat e tem aqui pra Suzi também então eu recomendo que você você faça pelo gerenciador de pacote e por último aqui tem o Windows

como eu falei não recomendo que você utilize direto ali no Windows Mas se você quiser É uma opção Apesar de eu não recomendar Mas você pode fazer e para você utilizar aqui no Windows você pode utilizar aqui o chocolate que é um gerenciador de pacotes também do Windows que funciona no Windows que você pode e utilizar aqui para fazer a instalação você executa aqui o choco instal e consegue fazer instalação Sem problema de novo Eu recomendo que você utilize o ambiente Mac ou ambiente Linux o segundo item que a gente vai instalar aqui é o

k3d E como eu disse antes ele utiliza containers docker Mas você já tem o docker aí instalado tá tudo certo para fazer a instalação no k3d também é bem tranquilo a gente vai vir aqui certo em k3d e.io e vamos fazer aqui a instalação Ele é bem leve como você pode ver aqui ó ele é uma distribuição que utiliza como base o k3s que é uma outra distribuição de kubernetes que tem como objetivo ser uma distribuição leve então ele roda em contêiners cara você vai ver como é que é rápido fácil você começar a criar

o seu cluster aqui para estudos eu adoro o k3d é um dos que eu mais utilizo na verdade e para fazer inst instalação é bem tranquila tem aqui a parte de instalação e você pode também instalar ele no Windows no Linux e no Mac e para fazer a instalação você pode pegar aqui o binário certo e fazer a instalação ou o que é a forma que eu recomendo é você fazer a instalação via script aqui ó você pode pegar aqui ó e executar o script de instalação na verdade esse aqui já é pro script Mas

você pode pegar o binário também aqui no caso no no Linux certo utilizando aqui o c ou o wget e você pode fazer também em outras plataformas aqui outros modos de instalação ele vem assim fechadinho você pode expandir que você vai ver aqui ó a instalação pra Mac utilizando o brill install aqui tem também pro Arc Linux tem aqui a parte do baixando aqui a release né que foi o que eu falei antes você pode no Windows utilizar o choco para fazer a instalação ou aqui o Scoop o Scoop eu nunca utilizei né quando eu

utilizei para Windows eu utilizei com o choco instal e de novo Eu recomendo que você faça a instalação no ambiente Mac ou Linux né evita utilizar aqui o Windows no no seu ambiente então eu recomendo que você faça aqui via script se você tiver no ambiente Linux e no Mac utilizar aqui o brill install agora falta aqui um outro ponto que eu recomendo muito que você utilize se você tiver utilizando o ves code que é a extensão do vs code pra kubernetes é assim como tem a extensão do docker para você utilizar para que Vai

facilitar ali na criação do docker file e de muitas outras coisas no docker o vcj também tem a extensão de kubernet e para fazer instalação é bem tranquilo vou comp compartilhar aqui a minha tela de novo eu tô aqui com o meu terminal aberto e eu vou abrir aqui o ves code depois que eu abro aqui o vest code você vai ver deixa ele abrir aqui tá aqui na outra aba mas depois que você vê aqui Eu abrindo o vest code Ele abriu aqui um remote container não sei por deixa eu cancelar beleza e aqui

ó na na parte de extensões você vai ver que eu tenho aqui ó a extensão do Doc que eu já instalei e tem aqui também ó kubernet que se não me engano também é da Microsoft lá ó é da Microsoft e você pode instalar vai ajudar muito aqui no processo de criação do manifesto e na hora de trabalhar com o kubernetes é tem aqui o link dele á aqui para você fazer instalação aqui direto pelo site ou pelo vs code mas vai vs code extensões coloca kubernet e faz aqui a instalação Ok bom com tudo

isso aqui instalado né com o Cub CTL com o k3d com a extensão do vs code a gente pode partir pra prática e trabalhar com kubernet mas antes o primeiro passo é ter o cluster kubernetes criado Então antes de trabalhar com um Deploy de aplicações com kubernetes vamos ver como criar na prática o cluster kubernetes utilizando o k3d Então vamos lá vamos criar aqui o nosso cluster kubernetes eu tô aqui com o meu terminal aberto utilizando o wsl dentro do Windows então eu tô com uma distribuição Ubunto aqui e eu no caso eu tenho aqui

ó o docker instalado tenho o k3d instalado e o Cub CTL também certo então tenho aqui tudo necessário para rodar aqui o nosso ambiente de estudo o comando mais simples que eu vou utilizar aqui para criar o cluster kubernetes com k3d é o k3d cluster Create ele vai criar aqui um cluster kubernetes simples com só um nó rodando E aí você pode até pensar pô Fabrício mas eu não tenho que ter control plane work node e tal esse nó ele vai exercer o papel de tudo como ele é um ambiente de estudo ele é um

laboratório não é um ambiente produtivo não tem problema fazer isso porque vai inclusive otimizar recurso computacional na sua máquina quanto mais nó formando ali o cluster kubernetes no seu ambiente local mais você precisa de recurso computacional então aqui não tem problema fazer dessa forma então eu vou dar um Clear aqui e se eu executar o Cub CTL get nodes que é o comando para listar os nós do cluster kubernetes com Cub CTL ele vai mostrar aqui eu só tenho um nó rodando né então ele bota aqui inclusive que ele tá como control planin e como

Master certo e tá rodando aqui a versão 1.30 do kubernetes ok então criei aqui o meu cluster kubernetes e posso utilizar mas eu tenho aqui algumas operações que eu posso fazer aqui eu posso por exemplo listar os clusters kubernetes que eu tenho criado com o k3d então aqui ó k3d eh cluster list ele vai mostrar aqui qu quantos nós eu tenho ou melhor quantos clusters eu tenho então aqui el mostra o k3d default ele tem aqui é um server rodando que no caso aqui é um control plane né o server aqui é o control Plane

e o Agent aqui é o worker node e se você reparar tem aqui também ó o load balancer habilitado O que que significa isso significa que junto com o cluster kubernetes também é criado um load balancer um segundo com contêiner que representa uma máquina de load balance então a minha comunicação pelo Cub CTL com o cluster kubernetes não é direto pelo cluster é pelo load balancer inclusive quando a gente faz a criação aqui do cluster kubernetes com o k3d ele faz também todo o setup toda a configuração do CUB CTL você vê que depois que

eu criei aqui o cluster kubernetes eu simplesmente venho aqui Cub CTL get noodes e tudo certo ele já foi e criou aqui tudo para mim então eu tive aqui e nenhum esforço de configuração e agora vamos dar uma olhada no docker o que que acontece né com o docker aqui os contêiners que ele cria Se eu vir aqui ó docker container LS ele vai listar os contêiners que eu tenho agora em execução no meu ambiente e aí você percebe que ele cria na verdade três contêiners né eu tenho aqui o cluster kubernetes Né o nó

do cluster kubernetes que é esse carinha aqui eu tenho o proxy que na verdade é o load balancer e eu tenho aqui um contêiner auxiliar que é o de Tools é o ferramental aqui que ele utiliza no k3d então ele vai utilizar aqui três contêiners e quanto mais nos eu adiciono nesse meu cluster kubernetes ele vai adicionar aqui um contêiner a mais e eu vou mostrar para você como fazer isso mas antes vamos deletar esse cluster que eu acabei de criar E aí para isso eu vou utilizar o k3d cluster delete E aí ele deleta

o cluster lá você vai ver que ele vai deletar Beleza se eu vir aqui k3d cluster list Eu já não tenho mais nada l não tem mais nenhum cluster rodando se eu executar aqui docker container LS também não tem nenhum container em execução então eu matei n esse cluster kubernetes na minha máquina e para criar de novo aqui só que com um setup mais completo com alta simulando o ambiente de alta disponibilidade eu vou utilizar o mesmo comando k3d cluster Create porque é o comando para criar um cluster só que agora eu vou mudar aqui

os parâmetros antes eu não coloquei nada executei e ele criou para mim com um nome ali É genérico né um k3d cluster algo assim né e agora eu quero dar um nome para esse cluster Então vou colocar aqui meu cluster você vê que a minha imaginação é maravilhosa né para botar nome então e k3d cluster Create meu cluster vai criar o cluster kubernet simples da mesma forma que a gente fez antes só que com o nome mas eu não quero isso eu quero um cenário de alta disponibilidade eu quero criar mais control Plan eu quero

colocar mais o work node nesse cluster kubernetes E aí para isso eu preciso definir a quantidade de servers que como eu falei lá quando a gente listou e o cluster com k3d são os os control Planes né não são os work Notes são os control Planes então eu vou botar aqui três que eu quero três control Planes e vou botar aqui também os Agents que vão ser os worker noes Esses são os work noes então servers são os control brines e Agent são os work noes coloco aqui três também você pode colocar a quantidade que

você quiser e vou executar esse setup aqui demora mais por quê Porque eu tô criando mais máquinas ele tá criando ali mais recursos consome mais CPU consome mais memória e além de criar né tudo ele vai conectar com rede inicializar Então esse processo aqui ele demora um pouco Ok então deixa eu cortar aqui pro momento que a termina aqui ó beleza ele terminou e se eu limpar aqui o terminal e executar o Cub CTL get nodes á já mudou ele tem aqui três control Planes e três o worker noes nesse setup aqui que a gente

tá trabalhando o control plan ele acaba também exercendo o papel de work node pode acontecer de você executar e a criação de um contêiner e você vê ir rodando no control plane Mas não tem problema aqui nesse cenário aqui é um laboratório é um ambiente de estudo não é um ambiente produtivo então aqui ó eu tenho o servers e eu tenho aqui os Agents E se eu executar aqui Cub CTL e Ou melhor se eu executar aqui docker container LS a Live vai mostrar aqui para mim uma porrada de Cont eu tenho aqui ó e

o server zero server 1 server 2 Agent z0 Agent 1 Agent 2 o server LB que é o prox né o o load balancer e eu tenho aqui a parte de Tools que são os ferramentais então aqui a gente criou um cluster kubernet simulando o ambiente produtivo com alta disponibilidade um cluster kubernetes mais completo qual que eu recomendo que você utilize aqui pra aula qualquer um dos dois se você tem pouco recurso computacional na sua máquina pode colocar lá com um work node só com um nó apenas vai funcionar você vai conseguir aqui fazer tranquilamente

e se você tem aí uma máquina mais parruda que consiga e criar esse ambiente mais complexo beleza O que você pode fazer aqui também é criar um cluster kubernetes deixa eu até botar aqui ó deixa eu primeiro matar aqui ó k3d cluster delete e meu cluster para matar aqui o cluster e você pode criar aqui também se você quiser vai ser bem legal criar um cenário onde você tenha só um control Plane e três ou dois é worker Notes também é um ambiente de estudo você vai ver a distribuição ali dos contêiners em vários worker

nodes e não vai gastar ali tanto recurso computacional ó aqui ó e colocar aqui vamos botar dois Agents e servers vamos botar aqui um beleza esse cenário aqui e consome aí uma quantidade intermediária de recurso e a gente consegue usar aqui um cenário com vários work nodes e ver a distribuição Mas você pode utilizar um só Sem problema nenhum beleza bom agora que você aprendeu Como criar o cluster kubernetes com k3d vamos entender os elementos que fazem parte de um Deploy eficiente no kubernetes e fazer o Deploy de uma aplicação na prática agora vamos pro

ponto que é o mais importante aqui em relação ao kubernetes que é inclusive o objetivo que eu acredito que você tá aqui nessa aula que é fazer o Deploy de forma eficiente no kubernetes E por que que eu digo isso né Por que que isso é importante porque você deve prestar aqui tanta atenção porque é muito comum quando você tá começando a trabalhar com kubernetes seguir ali e um passo a passo sem saber exatamente o que que tá acontecendo e como é feito esse Deploy quais são os componentes que fazem parte de um Deploy no

kubernetes então aqui a gente vai passar por todos esses componentes eu vou mostrar para você cada um deles aqui na prática mas basicamente para fazer o Deploy no kubernetes eu tenho alguns elementos envolvidos O primeiro é o pod que é o menor objeto do cluster cuber é nele que eu executo os meus contêiners depois eu tenho o replica set que vai cuidar da escalabilidade e da resiliência dos meus Pods ele é o controlador do meu pod ele vai verificar quantos Pods eu quero que sejam executados e vai garantir que tenha essa quantidade realmente em execução

e eu tenho também um cara que fica acima do R Cass 7 que é o deployment o deployment ele vai fazer o gerenciamento do RCA 7 para fazer a troca de versão da minha aplicação então basicamente o deployment ele vai tá ali acima gerenciando os replic sets que vão gerenciar ali os deployment e depois a gente tem também o service que é utilizado para Expor os meus Pods e expor a minha aplicação no cluster kubernetes Mas calma a gente vai ver tudo isso na prática criando aqui o nosso Deploy e vendo cada um desses elementos

funcionando e vendo como Eles garantem escalabilidade e resiliência certo mas como é que eu faço para declarar esse meu deployment para criar RCA set pode e tudo mais tudo no kubernetes é criado de forma declarativa você pode criar de forma imperativa através de linha de comando mas o correto é você trabalhar de forma declarativa e o que é a forma declarativa é a forma em que você declara o que você quer criar ali no cluster kubernetes seja um pod um repica 7 um deployment e o cluster kubernetes ele vai ver essa especificação do que você

quer rodando lá e ele vai cuidar do resto Então você não vai imperativamente falar assim olha cria o pod depois o r CET e depois o deployment não você vai especificar num arquivo Olha eu quero um deo com essas características rodando esses Pods E aí você aplica esse estado esse arquivo e ele vai fazer isso lá para você é claro que pode acontecer dele não conseguir criar por falta de recurso e n e outros motivos mas é dessa forma que o kubernetes funciona você declara o que você quer e ele cria para você e como

é que é feita essa declaração como é que eu declaro ali os objetos que eu quero criar no cruster kubernetes você vai fazer o que a gente chama de criar um arquivo Manifesto o que que é um arquivo Manifesto basicamente é um arquivo emo com uma especificação do objeto que você quer criar no kubernetes então quando falarem para você assim olha cria um arquivo de Manifesto aí pro kubernetes você vai criar um arquivo eemo seguindo a especificação para declarar isso no kubernetes E como eu vou utilizar aqui um arquivo yemo no caso aqui eu vou

utilizar o vs Code com a extensão do kubernetes Mas você pode utilizar qualquer extensão e um ponto muito importante é que antes é claro da gente fazer aqui o manifesto e fazer o Deploy no kubernetes o kubernetes aí trabalha com contêiners Então você precisa ter a imagem de contêiner da aplicação que você quer executar aqui nós vamos utilizar a conversão de distância o exemplo que a gente utilizou na aula anterior então tranquilo a gente já tem essa imagem pronta vamos agora focar na criação realmente do Manifesto Então vou compartilhar aqui a minha tela eu tô

aqui no diretório de aula né no mesmo diretório tem aqui o conversão de distância eu vou entrar aqui no projeto certo e ah conversão distância faz certo que dá certo e eu vou abrir aqui o vs code aí tá aqui o projeto né tá aqui com e o dockerfile tudo certinho e agora eu vou começar aqui a criar o meu arquivo de Manifesto deixa eu aumentar aqui um pouquinho beleza para isso eu vou criar um diretório aqui k8s para deixar tudo bem separado e vou criar aqui o arquivo deployment deployment pemo certo e agora vamos

começar aqui a criar o nosso Manifesto tem três ou melhor tem quatro Campos que eu preciso ter aqui no meu arquivo de Manifesto qualquer objeto que você for criar no kubernetes Ou pelo menos a boa maioria vão ter esses quatro Campos eu vou ter aqui o Api e version certo vou ter aqui também e o kind certo metadata metadata e vou ter aqui também o spec O que significa cada um desses Campos aqui que eu declaro com o iemo o Api version ele significa a versão da api que eu tô utilizando todo objeto que eu

vou criar no kubernetes ele é agrupado em apis e muitas vezes eu posso ter o mesmo objeto em grupos diferentes de api em versões diferentes de api Principalmente quando você tá trabalhando com um recurso ou com algum objeto do kubernetes que ainda tá em Beta ou que ainda tá em alfa e aí ele vai evoluindo conforme vai tendo a evolução também do kubernetes as novas versões E aí pode ser promovido de uma versão Alfa para uma beta e aí para não gerar incompatibilidade imediata porque muitas vezes esses campos vão mudar a estrutura vai mudar até

sair a versão final e eles são agrupados em API então você pode ter eh o mesmo objeto numa api que esteja ali como é alfa beta ou Beta v1 V2 E por aí vai e na versão final T também certo no caso aqui desses objetos que a gente vai trabalhar não vai acontecer porque são objetos finais são versões finais aqui do kubernetes Mas isso pode acontecer com outros recursos E como é que você faz para saber qual é o Api version que você vai utilizar ali para um objeto específico no kubernetes Eu tenho um comando

que ele mostra isso para mim eu tô aqui com o meu cluster kubernet já criado com k3d seix eu ver aqui ó get noes eu tenho aqui um cluster kubernetes com um server ou um control Plane e dois Agents ou dois e worker nodes Então dependendo aí do teu setup vai est diferente mas para ver o grupo de api eu vou executar o comando Cub CTL api resources resources E aí ele vai vai listar aqui para mim deixa eu até diminuir aqui um pouquinho para ficar melhor de visualizar aqui ó ele vai listar e todos

os objetos todos os recursos que eu posso criar no kubernetes E aí eu tenho aqui ó você vê que cara o kubernetes ele é gigante essa aula aqui é realmente uma introdução nesse mundo tem muito mais coisa lá no no devops pro mas só para você ter uma ideia aqui ó a quantidade de objetos e de recur cursos que eu tenho no kubernetes kubernetes é um mundo mas aqui ó tem os objetos que a gente vai trabalhar aqui ó o IP tem aqui cadê cadê cadê tá aqui vamos ver aqui ó tem o deployment tem

o replica set todos eles estão aqui e se você olhar Eu tenho o nome do objeto eu tenho o short name que é o atalho na forma que eu posso e escrever ele como em atalho né um nome menor como se fosse um apelido vai e eu tenho aqui o Api version que é o que eu vou utilizar aqui para declarar lá no Manifesto eu tenho aqui se ele é separado ou não por namespace e eu tenho aqui o kind que eu também uso lá no arquivo de manifesto que é o tipo de objeto então

aqui como eu vou criar um deployment o deployment que vai gerenciar os outros objetos eu vou pegar aqui ó o deployment e aqui ó esse é o Api version do deployment Apps bar v1 E no caso aqui ó o kind é deployment então aqui eu já pego o apps v1 coloco aqui coloca formatado né para ficar direito e aqui o kind eu vou fazer a mesma coisa deployment deployment E aí beleza comecei aqui a declarar o meu objeto deployment no kubernet legal E aí depois eu tenho aqui o metadata o que que é o metadata

no metadata eu vou ter os metadados desse objeto então aqui eu vou colocar o nome vou colocar as labels que eu vou explicar depois o que são labels mas basicamente aqui no deployment eu vou colocar o nome que no caso é o name E aí eu boto aqui conversão eh distância dessa forma aqui certo e agora o spec ele vai ter o que aqui ele vai ter a especificação do meu deployment o que que eu tenho que colocar no deployment eu vou definindo deployment tudo que eu preciso para executar a aplicação Como eu utilizo para

executar conteng no kubernetes o pod eu vou definir aqui o template do meu pod Qual é o tipo de pod que eu quero que esse deployment junto com os repc 7 gerencie E aí ele vai fazer aqui a criação de uma ou mais réplicas e vai gerenciar isso para mim E além disso eu também vou colocar a quantidade de réplicas quantas réplicas eu quero desse pod sendo criado nesse momento então aqui ó eu vou colocar réplicas por enquanto um que eu quero trabalhar com só uma réplica e eu vou começar a definir aqui os outros

recursos que no caso vai ser o template do meu pod mas antes de eu definir aqui o template do meu pod eu preciso definir o selector Fabrício o que que é essa parada de selector tudo no kubernetes né Toda vez que eu vou trabalhar com o kubernetes eu vou ter vários objetos interagindo entre si você vê que eu tenho o deployment que interage com repc 7 que interage com o pod e muitos outros também e como é que eu faço para garantir essa interação e saber que os objetos eles vão interagir corretamente eles vão est

selecionando ali os objetos corretos para interagir eu vou utilizar esse conceito de labels e selectors label nada mais é do que elementos chave e valor que você vincula a um objeto você marca aquele objeto com alguma característica É como se você colocasse uma pulseira de uma cor ali no determinado objeto Como se você tivesse colocando aí em você por exemplo uma pulseira Verde vamos dizer assim e aí o select é a seleção dos objetos que T essas labels no caso eu poderia est com uma pulseira aqui verde e alguém estaria aqui procurando né na minha

residência aqui ou no estúdio sei lá e e alguém com essa pulseira verde aí Quem seria essa pessoa eu se tivesse aqui uma outra pessoa com uma pulseira Azul essa pessoa não seria eh esse seletor né Essa pessoa que estaria buscando não estaria interagindo com a pessoa com a pulseira Azul apenas comigo porque eu tenho a pulseira verde o princípio é basicamente esse o selector ele vai selecionar objetos que tem ali labels que são declaradas nesse selector nesse seletor então é importante eu criar o selector aqui do deployment para especificar qual vão ser os Pods

que ele vai trabalhar por debaixo dos panos a gente vai ver que é o RCA 7 Mas calma basicamente é aqui como eu tô criando o deployment eu preciso definir esse seletor E é claro que no pod no template do pod eu preciso ter a Label obedecendo esse seletor então vai ficar mais claro aqui você vendo vai ficar mais claro então vou colocar aqui ó selector certo e aí eu vou criar a regra onde eu quero que a regra seja o match Lay Ou seja que bata ali o a regra de seleção da Label que

eu vou declarar aqui que no caso Opa eu vou colocar aqui um app né eu tô colocando o elemento chave valor aqui que vai ser a chave app e a O valor vai ser conversão distância certo dessa forma e aí no meu pod eu tenho que ter essa Label beleza declarado aqui o que que eu vou fazer agora eu vou especificar o meu template né template de quê template do meu pod do que eu quero que esse deployment gerencie certo e aí eu preciso colocar tudo isso aqui também né o kind o Api version e

tudo mais não o Api version e aqui o kind eu não preciso porque como eu tô dentro de um deployment eu não preciso colocar ali que é um pod porque eu já sei que dentro do template do deployment é um pod e eu não preciso colocar isso aqui beleza mas o metadata eu preciso colocar porque eu preciso definir os metadados aqui desse objeto eu vou declarar o nome desse pod não como o pod ele vai ser criado destruído vai escalar vai diminuir o número de ricas o tempo todo esse nome ele é gerado dinamicamente então

eu não vou colocar esse cara aqui manualmente mas dentro do metadata eu preciso declarar aqui as minhas labels que precisa bater com o selector eu preciso colocar aqui ó igualzinho senão dá ruim depois eu vou mostrar para você aqui é diferente aí você vai ver que não vai funcionar certo beleza então coloquei aqui o metadata declarei aqui a minha Label Agora eu preciso botar o quê aqui como tá aqui em cima ó eu tenho que botar o spec Né o o CoPilot tá soltando o spoiler aqui mas não tem problema o spec ele vai ter

a especificação do meu pod o pod ele é o menor objeto do cluster kubernets onde ele executa um ou mais contêiners dentro do meu cluster então o que que eu vou ter aqui basicamente os meus contêiners declarados no caso aqui eu vou trabalhar com um contêiner só né que é o conversão de distância e aí você pode estar pensando aí ah Fabrício beleza conversão de distância né aplicação simples quando eu tô trabalhando com uma arquitetura de microsserviços vários microsserviços eu vou colocar tudo dentro do mesmo pod e tá de boa né não você não vai

fazer isso por quê Porque quando a gente coloca eh os contêiners no mesmo pod o que escala aqui no cluster kubernetes São os Pods o que eu falei aqui o deployment ele vai criar repica set que vai criar o pod vai cuidar da escala e da resiliência Se eu colocar tudo no mesmo pod Cara eu tô criando um monolit com os meus microsserviços que aí quando eu for escalar eu vou escalar todos eles então você não vai fazer isso você vai criar um pod um deployment para cada microsserviço para você escalar individualmente e o uso

de vários contêiners dentro do mesmo pod é utilizado principalmente num design pattern chamado do sidecar que é muito utilizado em ferramentas de service mesh como ISO linkage e por aí vai onde você tem o teu contêiner principal que no caso aqui é o conversão de distância e esse cara que é o principal vai ter contêiners auxiliares fazendo ali e tarefas requisitos não funcionais como por exemplo coleta de log pode ter autenticação tráfego de rede e por aí vai então no caso aqui a a gente só vai ter realmente um contêiner então eu vou declarar aqui

containers certo e aqui em baixo eu preciso declarar cada um deles mas aqui eu vou trabalhar com apenas um então primeiro ponto eu vou colocar o nome desse contêiner que vai ser o conversão né de distância certo o nome dele não é o nome da imagem é o nome do contêiner dentro do do meu pod são coisas diferentes Então beleza coloquei aqui agora opa agora sim eu vou definir a imagem que no caso aqui é image né faz certo que dá certo e aí eu vou colocar aqui Fabrício Veronez barra conversão distância E aí eu

vou botar aqui no caso v1 certo acabou não coloquei aqui o nome coloquei a imagem Agora eu preciso declarar as portas que eu vou utilizar aqui desse contêiner E aí no caso a nossa aplicação aqui utiliza Qual a porta 5.000 Já que é uma aplicação aqui utilizando o Python utilizando Flash ele utiliza a porta 5000 por padrão é o que a gente colocou aqui inclusive ó no G unicórnio e aqui também na imagem então aqui no caso eu vou declarar o contêiner port como 5.000 beleza dessa forma aqui vai aparecer aqui para você se você

tiver utilizando o vs code essa esse warning aqui esse sublinhado aqui em amarelo se você colocar aí em cima ele vai falar que ah você não declarou o resarce limit e tal isso aqui são outros recursos do kuber n onde eu defino limite de recurso defino e CPU memória que vai ser utilizado aqui nesse pod eu não vou entrar nesse nesse assunto certo aqui é uma aula para você entender os conceitos básicos e fazer um Deploy eficiente e eu não vou falar sobre isso tá tem mais tem muito mais assunto na formação devops pro em

relação à kubernetes então aqui basicamente a gente terminou certo fizemos aqui criamos aqui o deployment colocamos aqui a quantidade de réplicas definimos aqui o template do pod tá tudo certo só para simular um erro eu vou fazer o seguinte aqui eu vou ao invés de utilizar o o Mat Label e a Label igual eu vou tirar aqui ó eu vou botar conversão simplesmente assim com traço depois a gente acerta só para você ver que não vai funcionar E aí como é que a gente faz para executar esse car como é que eu faço para pegar

aqui esse manifesto e aplicar ele lá no cluster kubernetes eu poderia utilizar dois comandos eu posso utilizar o Cub CTL Create Men F k8s deployment certo e aí olha Opa já acabei digitando aqui mas beleza que que vai acontecer aqui é com o Create eu tô pegando o conteúdo desse arquivo e fala Olha cria esses objetos aí no kubernetes E aí o kubernetes ele vai lá e cria para você ou eu posso utilizar além do Create eu posso utilizar o apply o apply ele vai falar pro kubernetes assim olha pega esse arquivo aí com esses

objetos e aplica no kubernetes Fabrício qual é a diferença a diferença é se eu utilizar o Create esses objetos eles não podem existir ainda no no kubernetes se eles já existirem ele não vai criar nada ele vai te dar um erro o apply ele mesmo que esses objetos já existam ele vai aplicar E aí se o objeto não existe o kubernetes vai criar E se o objeto ele tiver diferente do que tá no Arquivo ele vai fazer as alterações SAS Eu normalmente utilizo o apply tá eu cara pouquíssimas vezes eu utilizo o Create eu vou

no apply garanto que vai tá sempre mesmo se não tiver aí vai criar para mim e tá tudo certo se eu executar aqui ah lá ele dá erro justamente porque esse erro ele não tá com o Label e o match labels iguais Ah deixa eu até tirar aqui na verdade ele deu um outro erro mas se eu aplicar aqui ó ah lá ele fala que o o selector não bate com as labels se eu voltar aqui certo e salvar agora ele vai criar para mim ó lá vem aqui ó lá ele criou para mim então

agora eu tenho os objetos criados aqui no kubernetes agora eu vou dar uma conferida aqui e verificar os objetos junto com você e Primeiro vamos dar uma olhada no pod certo e para listar o os Pods eu vou utilizar o comando Cub CTL get Pods que é o comando de listagem aqui no kubernetes ele vai estar aqui ó os meus Pods que no caso eu só tenho um assim como eu fiz com get noodes aqui eu tô utilizando o get Pods e eu posso ver também aqui as algumas informações já do meu pod eu tenho

o nome do meu pod E aí você vê que ele tá utilizando aqui o conversão distância né que é o nome ali do meu deployment mais um conjunto aqui de caracteres aqui depois eu tenho o Ready né que diz quantos contêiners eu tenho aqui declarados aqui no meu pod e quantos eu tenho em execução que eu tenho aqui já prontos executando eu tenho o status aqui do meu pod que no caso aqui é o Running a quantidade de Restart né De quantas vezes ele Restart o contêiner aqui dentro no pod e o tempo aqui desse

pod que no caso ele tem aí 28 segundos se eu executar aqui de novo né ele vai mostrar que tem mais segundos ó lá 92 e conforme vai passando o tempo ele vai mostrando aqui então essa é a forma de listar o meu pod de verificar aqui quantos Pods eu tenho em execução agora se eu quiser verificar mais informações aqui do meu pod se eu quiser ver mais detalhes desse pod eu vou utilizar o Cub CTL describe pod E aí eu preciso colocar o nome aqui do pod pro describe É sempre bom colocar aqui senão

ele vai fazer o describe em todos os Pods aí eu não vou saber nem qual pod que eu tô que eu tô vendo ali a informação Então coloca aqui o nome executo e ele vai mostrar aqui ó muito mais detalhes ó o nome namespace o priority eh service account em qual nó ele tá sendo executado aqui no meu cluster kubernetes depois eu vou mostrar aqui também aqui as labels que tem nele então aqui eh várias informações aqui em relação também ao nome da Imagem e por aí vai e aqui embaixo eu tenho também os eventos

desse pod aqui ó o momento em que ele foi eh definido aonde vai ser eh executado depois eh pegando aqui a imagem criando aqui o contêiner e startando aqui o contêiner e vai mostrando aqui todos os eventos certo então aqui são as informações do meu pod eu tenho também o Club CTL get RCA set E aí aqui ó ele vai ter também as informações do meu repc set que é o controlador dos Pods aí que vai gerenciar que o estado desejado que eu quero aqui no meu CR kubernetes a quantidade de podes que eu quero

aqui em execução seja realmente a que está ali em execução tanto que ele mostra aqui ó o desired state né quantos quantas réplicas eu quero em execução lá no meu cluster kubernetes aqui quantos eu tenho realmente e quantos eu tenho aqui ó em Ready quantos Estão realmente aqui prontos executando e aqui o tempo desse RCA 7 inclusive Se eu vir aqui aqui ó Cub CTL get réplica 7 vírgula pode e listar aqui os dois olha só que legal eh o RCA 7 ele tem aqui um nome certo ele tem ali o nome que foi criado

para ele se você reparar o nome do pod ele é a junção do nome aqui do RCA 7 com mais esse conjunto de caracteres aqui criado então o RCA 7 ele tá de diretamente ligado aos Pods ele vai garantir que o estado desejado a quantidade desejada de réplicas seja que tá realmente em execução só para você ter uma ideia disso só para você ver isso eu vou mostrar aqui para você ó eu vou voltar aqui no Manifesto e eu vou mudar aqui a quantidade de réplicas de um Vou botar aqui para vai vou botar oito

e vou executar aqui de novo Cub CTL apply Men F Ah k8s deployment E aí vou aplicar Ó lá ele vai configurar né ele fez ali e a alteração e se eu vir aqui Cub CTL get e botar aqui réplica 7 de novo vírgula pode pra gente ver os dois olha lá como é que já mudou ele tem agora uma quantidade muito maior Deixa eu diminuir aqui mais aqui tem uma quantidade muito maior de Pods aqui em execução inclusive tá criando aqui ainda ó tá vendo mas aqui ó já mudou ó ele mostra no RCA

7 que o desired state né o o o Estado desejado agora é oito porque eu coloquei oito réplicas aqui o corrente é oito porque ele tem já oito aqui criado e Red aqui no caso tem três que tinham três aqui em execução se eu provavelmente rodar aqui de novo ah lá eu já tô com todos agora em execução de novo e aí o que que acontece se eu diminuir esse cara e botar aqui de novo um ele vai voltar a ter um e vai eliminar os que tem ali a mais né sete no caso eu

vou mostrar aqui de novo mas eu vou fazer agora diferente eu vou executar aqui um apply junto tá com o comando watch eh Cub CTL get pod certo E aí ele vai executar e vai continuar listando aqui ó e aí você viu que ele foi terminando e agora só tem um Se eu vir aqui agora e executar o get ah lá agora eu tenho aqui o meu desir como um eu tenho aqui o current como um o Ready eu também tenho aqui como um certo e aqui eu só tenho um pod em execução Se eu

mudar aqui de novo boto aqui ó oito ele vai voltar lá pro botar aqui com o Watch de novo se eu executar de novo ó lá ó ele vai criar ali tudo de novo e aí depois ele tá em execução e eu posso ver aqui também ó com o Cub CTL get pod menos ó Wide aqui ó mais detalhes sobre o meu pod onde eu tenho e a lista dos meus Pods e ele mostra aqui para mim também ó em qual node que ele tá sendo executado né vai ficar muito pequeno aqui na tela mas

eu quero mostrar aqui para você ó como é que muda aqui ó como é que muda aonde os podes estão em execução certo com o Cub CTL get pod menos o Wide que aí dá mais detalhes inclusive ele me dá aqui ó o IP do pod e tudo mais então aqui ó eu vou botar um de novo pra gente a gente vê aqui ele vai diminuir de novo certo ó lá diminuiu e aí eu vou ter aqui só um então você vê que o replica 7 ele é justamente esse controlador que vai garantir a escalabilidade

e a resiliência da minha aplicação garantindo que a quantidade de réplicas que eu coloquei vai ser a que realmente vai tá em execução inclusive vamos fazer esse teste aqui ó Cub CTL get POD eu vou vir aqui ó e vou deletar esse pod aqui ó CLB CTL delete pod Vou botar aqui o Watch de novo né Vou botar aqui ó watch Cub CTL e get pod para você ver Opa botar aqui ó opa cubc opa watch Cub CTL get pod certo opa Ah não tem que botar aqui no delete eu tenho que botar o nome

do pod né faz certo dá certo quero deletar o pod qual pod que eu quero deletar beleza aí executo aqui ó delete ele deletou e ó lá já foi criado outro lugar você vê que agora aqui ó tem um criado há 5 segundos atrás não eu já tinha ali um pod criado certo então aqui eu tenho a escalabilidade e a resiliência por conta do réplica 7 agora vamos ver aqui o deployment eu vir aqui ó Cub CTL get deployment eu consigo Lar aqui o meu deployment e aí você vê que eu tenho aqui né o

deployment e ele mostra a quantidade de Pods in Ready quanto que eu tenho aqui atualizado e quanto eu tenho aqui disponível mas daqui a pouquinho a gente vai ver essa relação de up to date né atualizado e realmente disponível quando a gente for eh verificar ali a troca de versão Agora eu tenho aqui o meu deployment criado repica set e o pod criado também mas como é que eu acesso aqui a minha aplicação lá o conversão de distância eh se eu vir aqui ó eu posso executar o comando deixa eu primeiro listar aqui o pod

mas eu tenho o comando chamado aqui ó Cub CTL port forward esse cara ele vai fazer o redirecionamento de porta toda chamada para uma porta específica aqui da minha máquina local vai ser redirecionada pra porta do pod como se fosse ali o publish de porta ou port bind do docker só que aqui no caso eu vou fazer com pod E aí eu executo ele dessa forma Cub CTL port forward podde coloco aqui o nome do meu pod certo coloco aqui pá beleza e vou colocar aqui a porta 880 com a porta 5000 aqui do meu

pod que é a porta lá da minha aplicação web executo aqui ó ele vai fazer o forward e eu vou só abrir aqui ó vou vir aqui local host 8080 E aí eu vou conseguir acessar a minha aplicação ele tá aqui processando aqui ó Foi abri aqui a minha aplicação conversão de distância funcionando igualzinho foi na aula um só que trabalhando agora com o kubernetes não tô mais só com o DOC tô trabalhando com o kubernetes inclusive você vê aqui ó embaixo que ele mostra ó o servidor que processou a requisição é o conversão distância

E aí mostra aqui o nome do pod inclusive mostra também o IP I desse pod lá no cluster kubernetes certo então Sempre que você quiser acessar um pod específico você pode utilizar aqui o port forward mas cara não é dessa forma que eu quero trabalhar né eu consegui criar aqui o deployment RCA set pod tudo bonitinho conseguindo ter escalabilidade resiliência mas cara eu não quero acessar o meu pod dessa forma né que acabei de tirar o port Ford Se eu tentar aqui a minha aplicação não vai est mais acessível eu não quero isso eu quero

trabalhar de uma forma em que eu tenha um ponto de comunicação ali para poder acessar eh as réplicas da minha aplicação e é aí que entra o service que a gente vai ver agora então o que é o service o service ele é justamente esse ponto único de comunicação com os meus Pods Sempre que você quiser expor um pod seja internamente no cluster ou para fora do cluster kubernetes você vai utilizar o service não importa a quantidade de podes que você tenha você tem um pod você vai expor ele com service você tem sei lá

10 100 Pods você vai utilizar o service também ele vai ser esse ponto único ele vai ser o service Discovery para os seus Pods mesmo que você tenha aqui acessar internamente de pode para pode se for alguém acessando de fora você vai utilizar o Service Agora você tem vários tipos diferentes de service que cada um deles é utilizado para cada situação eu vou falar aqui os principais mas tem alguns outros que eu não vou entrar aqui o primeiro é o cluster IP o cluster IP é o service utilizado para fazer a comunicação interna no kubernetes

ele só é acessível internamente Então você vai utilizar ele sempre que você quiser fazer a comunicação entre el podes dentro do mesmo cluster se você tiver vários microsserviços e eles tenham que se comunicar ali internamente você pode utilizar o cluster IP eu tenho também o Service do tipo node port o Service do tipo node port ele expõe o service el o pod pro mundo externo mas como é que funciona o Service do tipo node port como é que eu faço para acessar o meu service os meus Pods e a através dele o node port ele

vai ser acessível através de qualquer IP que faça parte do seu cluster kubernetes você vai acessar ele a partir de qualquer máquina que faça parte do cluster kubernetes mas tem um ponto aqui muito importante Toda vez que você cria um Service do tipo node port ele Vai eleger uma porta que vai ser utilizada como acesso por padrão ele vai utilizar uma porta que esteja no Range de porta 30.000 até a porta 32.767 então criou um Service do tipo node port você vai poder acessar com qualquer IP que faça parte ali do das máquinas do seu

cluster kubernetes mas você tem que saber qual é a porta que ele tá utilizando E é claro que se alguém já tiver utilizando alguma dessas portas na hora dele gerar ele não vai utilizar a não ser que você faça na mão a gente vai ver como fazer isso aqui também certo é esse service esse tipo de service seria muito utilizado em cenários on premise quando a gente fala num cenário de cloud aí já é diferente a gente utiliza o Service do tipo load balancer e o nome até eles Parece que só esse service ele faz

o balanceamento de carga entre os meus Pods e não é nada disso todo o service ele vai expor os Pods e também fazer esse balanceamento de carga distribuir as requisições entre os Pods Mas por que que is se chama load balancer porque na verdade ele cria um load balance na frente do meu service E aí eu não vou utilizar os IPs das máquinas do meu cluster kubernet para acessar o meu service eu vou utilizar o IP que é criado para esse load balancer então ele é mais utilizado em cenários que você tá trabalhando com Cloud

provider Onde você tá utilizando um a service como o Eks o aks e outros mais porque quando você for criar esse service o cloud provider vai fornecer o load balancer e esse IP público para ser utilizado como acesso a gente vai ver isso na aula TRS na aula de cloud mas já fica com isso registrado quando a gente utiliza o service load Ban ele vai fornecer um IP público não tem nada a ver de que ah ele faz o balanceador de carga nada disso você pode utilizar o load balancer em clusters kubernetes on premise Sim

mas você precisa ter um setup a mais você precisa de uma ferramenta mais para isso que normalmente é o metal LB mas eu não vou falar sobre isso aqui eh no evento porque ele é mais focado para cenários de data center aqui o objetivo é a gente falar mais em ambientes de cloud Ok então agora que você sabe quais são os tipos de service vamos voltar aqui pra tela e fazer aqui a criação do Service pra gente poder acessar o nosso pod acessar aqui a nossa aplicação no kubernetes Então agora eu vou abrir aqui o

vs code Ok e agora eu preciso adicionar mais um objeto aqui no meu Manifesto e eu poderia criar aqui um outro arquivo e aplicar esses dois sem problema mas é uma boa prática você colocar todos os manifestos todas as declarações que fazem parte ali de uma mesma solução no mesmo arquivo então aqui eu vou colocar junto aí eu posso colocar aqui api version e tudo mais poderia mas quer dizer você pode mas tem um ponto aqui você tem que separar aqui três traços que aí já entende aqui ó que é um objeto entrando aqui também

e aí eu vou fazer todo o passo a passo aqui para criar o objeto tendo aqui esses quatro Campos também o Api version o kind o metadata e o spec então o Api version já coloquei e no caso aqui o Api version é o v1 não é o apps v1 se você quiser conferir é só dar uma olhada lá no api resource e aqui aqui eu vou vir aqui e colocar né O resto que eu preciso que é o kind onde eu defino aqui o meu service eu vou botar aqui o metadata que vão ter

os metadados aqui e do meu objeto e aí eu vou colocar aqui o name conversão distância também certo Vou definir aqui o spec que vai ser a especificação aqui do meu objeto e o que que eu vou ter aqui no meu service eu preciso ter a regra Onde Eu Vou definir quais objetos quais podes né eu vou expor aqui com esse service E aí eu vou utilizar para isso o conceito de labels E selectors então aqui eu preciso definir o selector então eu já coloco aqui ó o selector e é importante assim como aqui onde

eu coloquei o match Label pro meu deployment eu colocar aqui né O meu a minha Label aqui também igualzinha certo o match Label e a Label tem que ser igual aqui também então o selector e precisa obedecer aqui esse critério preciso colocar aqui a Label certinha senão ele não vai expor Depois eu mudo aqui aí você vai ver também ele não expondo mas agora que eu tenho aqui o selector declarado eu tenho que definir quais portas que eu vou expor então eu vou botar aqui né o ports certo e vou colocar aqui né a porta

que eu vou trabalhar como eu quero trabalhar com a porta http que é a porta padrão para acessar a aplicações web eu vou utilizar a porta 80 que é a porta padrão mas pô a porta que eu tô utilizando aqui no meu pod é a 5.000 e aqui eu coloquei a 80 então para fazer o redirecionamento para bater na porta 80 e ir pra porta 5000 eu preciso definir aqui o target port que vai ser a porta alvo ali do do meu pod E aí eu posso botar aqui a 5000 certo é só isso é

só isso E aí pra gente ver funcionando eu aplico aqui Cub CTL apply - F k8s deployment E aí vamos ver o que que vai acontecer ele não alterou nada aqui no meu deployment e aqui no service Ele criou Se eu vir aqui Cub CTL get All Vou botar aqui um get All o get All ele lista todos os objetos aqui do kubernetes né todos os principais então aqui ó ele mostra para mim o POD ele mostra aqui para mim o service e mostra aqui também o deployment e o replica set E aí se eu

olhar aqui o meu service olha só que interessante eu tenho é o IP dele no meu cluster kubernetes certo que eu posso utilizar aqui esse IP eu não devo eu posso mas eu não devo utilizar IP dentro do cluster kubernet para acessar nada eu vou sempre utilizar aqui Services para isso então não vai aqui esquece esse IP por enquanto esquece finge que aí não existe não use IP para acessar aqui você vai utilizar o service e aqui eu tenho o IP dele interno o IP dele externo caso tivesse trabalhando aqui com load balance e a

porta aqui que ele tá utilizando e se você reparar eu tenho aqui o tipo o tipo cluster IP ele é utilizado para acessar internamente né A minha aplicação para acessar aqui o meu pod a mas eu não consigo acessar caso eu utilize aqui é o cluster IP dá pra gente utilizar o port forward então se eu vir aqui ó e executar Cub c é apply não né mas se eu vir aqui ó Cub CTL eh port forward botar aqui o service barra que aí no caso eu tenho que trabalhar com service não é mais com

pod Service conversão e distância E aí botar aqui a mesma coisa porta 80 80 só que agora a porta 80 porque eu tô trabalhando com Serv não é a 5000 e executar aqui olha lá ele vai e fazer o forord para mim E aí se eu vir aqui e atualizar Ó lá eu consigo acessar a aplicação Sem problema nenhum então vou continuar conseguindo acessar aqui sem problemas mas pô ainda não é isso que eu quero eu quero acessar externamente cluster IP ele é utilizado internamente eu não posso utilizar o load balancer porque eu tô aqui

no meu ambiente local se eu colocar aqui o load balancer ele não vai gerar um IP externo para mim que eu não tenho Cloud provider conectado então aqui eu vou utilizar o node port então eu vou alterar aqui a minha o meu service e Vou definir aqui o Type né do meu service que vai ser node port certo e agora que que eu vou fazer aqui eu vou executar o apply novamente Ó lá ele vai atualizar e eu executo cctl get All ele vai mostrar aqui para mim ó os o pod em execução vai mostrar

aqui o meu service de novo só que agora é diferente ó deixa eu até diminuir aqui um pouco ele mostra aqui ó o conversão distância o Type agora é node port e se você olhar aqui ó logo depois do 80 eu tenho 30519 então ele pegou uma porta que tá lá naquele Range de portas da 30.000 a 32.767 e tá utilizando aqui e aí com o IP de uma máquina que faça parte do meu cluster kubernetes eu consigo acessar a minha aplicação utilizando essa porta então se eu Teoricamente se eu pegasse aqui e botasse dessa

forma aqui né com o IP né o IP da máquina certo eh botando aqui dois pontos à porta eu conseguiria acessar né no caso aqui aí não acessou porque ip da máquina não existe mas a gente tem aqui um outro problema Por quê como eu tô trabalhando com contê né Eu tô trabalhando aqui com ambiente local k3d coners e tudo mais e eu não tenho ip da máquina né Eu não tenho como acessar né o meu serviço utilizando IP porque o contêiner tá rodando aqui na minha máquina e se eu tiver trabalhando aqui com o

IP eu não tô trabalhando da maneira correta então eu não vou né tornar aqui o meu serviço acessível dá para fazer isso mas a gente vai ter que mudar um pouquinho a criação do cluster kubernetes aqui com o k3d então vamos fazer o seguinte eu vou deletar aqui o cluster kubernetes que eu criei com o k3d eh cluster delete botando aqui o meu cluster certo deletando aqui o cluster E aí ele vai remover esse cluster e eu vou criar ele aqui novamente com um parâmetro a mais que a gente precisa ter beleza e deletou e

agora eu vou criar ele aqui utilizando o comando k3d cluster Create meu cluster vou passar aqui o servers da mesma forma que passando um Ei gente ISS aqui com dois e agora eu vou passar um parâmetro adicional que é o menos P O que que é esse parâmetro menos p é a mesma coisa que eu faço lá com o docker eu faço um publish eu faço um bind de porta eu vinculo a porta da minha máquina com a porta de um contêiner então eu não vou precisar me preocupar com o endereço IP do contêiner que

vai est representando ali o cluster kubernetes porque eu já vou ter o bind de porta aqui direto da minha máquina local e aí tá tudo certo eh então eu vou fazer isso eu vou declarar aqui uma porta da minha máquina e eu vou vincular a porta do contêiner para poder acessar aqui no caso eu não vou fazer a porta 80 igual o service porque não é uma boa prática e provavelmente eu teria problemas aqui de acesso trabalhar com porta baixa né então aqui no caso eu não vou utilizar a porta 80 para ser a porta

padrão http eu vou utilizar aqui a porta 8080 da mesma forma que eu tava usando aqui antes n no caso aqui eu tenho que botar um aspas Vou botar aqui 8080 dois pontos eu tenho que pegar uma porta aqui que seja utilizada como node port da 30.000 a 32.767 vou pegar aqui a 30.000 mesmo que é a primeira porta e tá tudo certo e aí agora que eu tenho a porta da minha máquina com a porta do contêiner eu vou especificar qual contêiner né que o k3d vai criar que eu vou fazer esse vínculo como

eu tenho aquele load balance na frente recebendo todas as ições eu vou utilizar aqui justamente o container load balancer E aí eu fiz aqui o port bind da porta 8080 da minha máquina com a porta 30.000 do load balance executo ele vai fazer todo o processo de criação aqui de novo do cluster mas dessa vez vai ser mais rápido porque já tenho aqui todas as imagens na máquina demora um pouquinho mas menos do que antes deixa aí terminar aqui de criar ele tá terminando aqui de criar lá tá fazendo as conexões de rede vai fazer

a configuração do CUB CTL E aí beleza agora eu vou executar aqui o Cub CTL get nodes tá lá criado beleza mas vamos dar uma olhada aqui no docker container LS se você reparar aqui agora no coner da do load balance aqui ó o proxy ele tem ó o bind da porta 80 80 com a porta 30.000 Então beleza é isso que eu queria agora eu posso vir aqui de novo Cub C Opa apply os F k8s deployment executo Ele criou Se eu vir aqui Cub CTL get All eu tenho aqui todos os meus objetos

sendo criados aqui o contêiner ainda tá em criação mas daqui a pouco ele vai ser criado beleza só que eu tenho um um outro problema né tenho um outro problema eu expus aqui eu fiz o bind de porta da minha máquina com a porta 30.000 Mas putz olha só aqui Ele tá utilizando a 3.179 ele não tá usando a mesma porta aqui que eu declarei ali que eu fiz o bind ele tá pegando a porta aleatória entre aquele Range Então agora eu vou V voltar aqui no meu manifesto e eu vou fazer o seguinte eu

vou aqui junto no porte eu vou adicionar mais um cara eu vou adicionar aqui o node port porque aí eu forço ele a utilizar uma porta que eu quero eu especifico a porta que ele vai utilizar no caso aqui ele vai usar a 30.000 E aí eu faço esse Force aqui de novo é importante também ter em mente que você não pode colocar ali uma porta que já esteja em uso se já tiver sendo utilizada vai dar erro certo bom legal vou vir aqui agora vou executar o apply ele vai configurar E se eu vir

aqui agora ó Cub setl get All agora el tá utilizando aqui ó a porta 30.000 e aí agora eu posso vir aqui 8080 executar e lá ó ele tá funcionando recebendo aqui as requisições então que que eu fiz aqui fiz o bind de porta da porta 80 do da minha máquina com a porta 30.000 do contêiner e aqui eu Forcei o uso aqui da 30.000 ah Fabrício mas eu no ambiente de cloud que que eu vou fazer e tal cara no ambiente de cloud você vai ver que é muito mais fácil eu vou tirar o

node port vou botar lo balance aí vai funcionar a gente vai ver isso na próxima aula certo E aí beleza op Quase que eu fiz besteira aqui dou um Clear e Ah um ponto importante eu vou fazer o seguinte aqui ó eu falei com vocês ó vou tirar aqui vou botar diferente e vou aplicar vamos ver o que que vai acontecer ah lá ele funciona funciona mas se eu viro aqui ó get também funciona tá tudo certo mas se eu viro aqui agora opa ele não funciona então é importante o selector tá igualzinho aqui com

a Label da aplicação do spod senão dá ruim certo eu vou vir aqui vou dar um apply beleza ah lá consigo acessar de novo Agora vamos fazer um outro teste aqui vamos testar aqui essa nossa aplicação ver se ela tá tendo escalabilidade resiliência e ver algumas coisas que a gente pode fazer aqui para gerenciar a aplicação eu tenho aqui a quantidade de réplicas coloquei aqui uma réplica eu vou fazer o seguinte vou botar aqui seis réplicas botar aqui seis réplicas e agora eu vou vir aqui e vou dar um apply CTL apply F k8s deployment

certo tá aqui lá beleza agora eu vou acessar aqui a minha aplicação vamos lá ah lá se você reparar aqui embaixo ó ele vai alternando por quê Porque agora eu tô utilizando o service então como eu tenho várias réplicas e o service é o ponto único de comunicação Onde eu consigo acessar todas essas réplicas e ele faz o balanceamento de carga eu consigo ter uma alta disponibilidade real da minha aplicação porque aqui ó quantas réplicas tiverem aqui o Service ele vai ter ali a lista de endereços e vai utilizar se eu botar aqui de novo

para um né ele vai ter um só apenas e vai todo mundo receber ali a mesma carga vai receber ali a mesma quantidade eh de vai receber todas as requisições ali eh do Service se eu tiver um só agora pra gente encerrar aqui eh a gente conseguiu ver escalabilidade resiliência ponto único de acesso agora vamos atualizar essa aplicação Vamos fazer uma alteração aqui de versão na aplicação eu vou vir aqui agora no meu projeto e eu vou alterar esse cara eu vou botar ele aqui certo e aqui embaixo Aqui ó eu tenho o servidor que

processou a requisição Pará né esse rodapé eu vou botar aqui na frente um V2 da vida botar aqui versão 2.0 certo dessa forma E aí eu vou subir esse cara eu vou criar uma nova imagem certo vamos ver aqui botar aqui pelo vs code mesmo certo e eu vou executar o docker build Men T Fabrício Veronez barra conversão distância E aí eu vou botar aqui um V2 Vou botar aqui para ele já enviar eu posso botar aqui o PP já enviar botar aqui o meu contexto e vou subir isso tudo a gente fez na aula

um né Aqui eu só tô mudando a versão tô botando uma nova versão aqui para rodar deixa aí terminar E aí agora o que que eu vou fazer eu assim que ae terminar eu vou atualizar a versão e a gente vai ver como é que esse cara vai se comportar a gente vai ver essa troca de versão aqui da aplicação deixa ele terminar aqui de processar né de fazer o envio ele na verdade ele tá construindo ali né que ele tá pegando aqui a imagem e tal e tá subindo ali paraa pra minha aplicação pro

meu ambiente deixa aí terminar aqui vamos lá deixa aí terminar aqui OK vamos lá aqui termino tá já tá terminando de executar ele vai subir ali agora mais um [Música] pouquinho vamos lá beleza Tá quase acabando Acabou acabou vamos lá acabou e aí que que eu vou fazer aqui agora vou voltar aqui pro meu Manifesto eu vou mudar aqui de oito vou botar de seis eu vou botar oito e aí eu vou aplicar aqui de novo e agora eu vou fazer o seguinte eu vou alterar aqui no Manifesto a versão da minha aplicação Vou botar

aqui a versão do e eu vou executar de novo o apply só que colocando aqui o Watch botando aqui ó watch Cub C get pod certo executar ele vai aplicar atualização e a gente vai ver a alteração rolando lá olha o que que acontece ele vai matando os Pods antigos e vai criando Pods novos ah lá vai matando vai criando vai matando vai criando e quando a gente vê já tá ali com a versão 2 funcionando e aí se eu vir aqui agora no projeto ah lá versão 2.0 então ele fez essa alteração ele atualizou

a versão da minha aplicação E aí vamos dar uma olhada aqui no cruster kubernetes Cub get All n a gente vai ver aqui todos os Pods rodando certo todos os Pods aqui rodando service tudo certo tenho aqui o meu deployment tudo certo também e olha só que legal tenho aqui o repc eu tenho doc por isso porque agora eu tenho o replica 7 com a versão Opa com a versão 2.0 né que foi o que eu subi agora e a versão um que foi o anterior então Lembra que eu falei que o deployment a gerenci

o réplica 7 toda vez que tem uma atualização da minha aplicação ele cria um novo réplica 7 para garantir a troca de versão automática e você viu que ele foi trocando ali a versão para mim então aqui por isso que ele mostra que up to date né atualizado porque eu tenho essa troca de versão vamos ver aqui ó eu vou mostrar aqui um exemplo de novo eu vou vir aqui e vou botar a versão um de novo e a gente vai aplicar aqui de novo só que agora eu vou listar o pod vou listar O

deployment opa o deployment e vou botar aqui também o RCA set executo ah lá ele vai listar os meus Pods Opa deixa eu diminuir aqui ah lá ele vai estar os meus Pods e aqui foi muito rápido né mas você vê que aqui ó ele trocou já de novo ó lá o repica 7 que antes estava desabilitado sem nada ele voltou ali a ter eh todos os Pods em execução e o mais novo tá aqui Inativo porque ele deu um rollback eu voltei a versão E aí eu tenho aqui também vamos tentar aqui de novo

né botar aqui dois de novo e eu acho que assim deixa eu diminuir um pouquinho vai ficar pequeno aí na tela mas vai a gente vai conseguir ver eu vou botar aqui de novo vamos lá ah lá ó ele vai terminando e aqui ó up to date ele tava quatro e depois foi e aumentando é porque agora o processo é muito rápido você vê que ele é muito rápido então eu consigo fazer esse gerenciamento então o o deployment aí vai ter aqui um Store das versões anteriores é claro que isso tem limite de quantidade e

você consegue fazer esse rollback e eu posso fazer dessa forma aqui alterando O Manifesto certo direto e aí eu consigo aqui ver a versão ó 2.0 ou eu posso executar aqui com um outro comando aqui ó que é o Cub C rollout Opa rollout History E aí eu vou u aqui do deployment e conversão distância aí ele vai mostrar aqui Opa Ah botei aqui um l só né são dois a certo dá certo rollout ah lá ó ele mostra para mim as duas últimas versões ele mostra aqui as duas últimas revisions e eu posso vir

aqui ó tô com a versão 2.0 certo eu posso vir aqui e executar e de novo o cubc rollout só que agora um cubc rollout andu passando aqui o deployment deployment conversão e distância certo e aí ele vai voltar uma última versão Se eu vir aqui ó botar o Watch é Cub C get pode a gente consegue ver lá ó ele fazendo o HB aqui de versão E aí ele vai terminar se a gente olhar aqui versão Á tá com a 1.0 E aí se eu vir aqui de novo eu consigo executar Cub CTL get

All eu vou ver aqui o repc 7 com a versão 1.0 aqui rodando e de forma ativa e o mais recente inativo então a gente conseguiu aqui fazer né o Deploy da nossa aplicação no kubernetes utilizando os principais objetos da maneira correta garantindo escalabilidade resiliência troca eficiente de versão garantindo aí um downtime zero da nossa aplicação Porque como você viu ele vai trocando ali a versão conforme vai atualizando e e atualiza um vai removendo o antigo atualiza um vai removendo o antigo E é claro que a gente pode gerenciar isso mas por hoje aqui a

gente conseguiu atingir o nosso objetivo cara o kubernetes é sem dúvida uma ferramenta que merece uma atenção maior porque são várias as funcionalidades que facilitam muito o nosso dia a dia e tornam a aplicação cada vez mais escalável e confiável tanto que no devops pro os nossos alunos possuem um módulo bem extenso de kubernetes destrinchando ali cada detalhe dessa ferramenta fantástica por exemplo Imagina que uma aplicação tá com pode consumindo muito recurso e comprometendo todo o funcionamento do ambiente eu ensino no curso a limitar CPU e memória de cada contêiner que é executado no kubernetes

para não rolar mais nenhum problema e um outro ponto importante como eu faço para definir quantas máquinas e Qual configuração necessária para criar o seu kubernetes eu também mostro isso e outros detalhes que garantem segurança na hora de trabalhar com essa ferramenta iradíssima Mas enfim são muitas as funcionalidades e você deve se aprofundar nele porque muda o nosso jogo então nós concluímos aqui o segundo passo da nossa solução mas agora que você já conhece os fundamentos básicos para se ter o Deploy de uma aplicação no seu kubernetes a gente pode avançar até agora o objetivo

era você entender os principais conceitos do Dock e do kubernetes com cenários mais simples agora a parada vai começar a ficar F mais séria nós vamos de fato iniciar os trabalhos com a aplicação Desse nosso evento a gente vai fazer isso tudo direto em um ambiente de nuvem então na próxima aula eu vou te mostrar como criar um cluster kubernetes na WS que é o principal Cloud provider do mercado você vai ver como rodar a sua aplicação na nuvem é bem mais simples do que você imagina e vai entender porque esse é o ambiente mais

utilizado pelas grandes empresas no mercado vai até se perguntar por que você não estudou isso antes é sério a aula tá iradíssima você não pode perder te vejo na próxima aula