Aula 2 - Kubernetes Eficiência de clusters na Prática | DevOps 4 Devs

Opa seja muito bem-vindo e muito bem-vinda à segunda aula do devops for Dev sou Fabrício Veronez E durante essa semana eu tô te mostrando as habilidades que transformam seu jeito de criar sistemas para fazer a sua carreira Decolar mas se você ainda não assistiu a aula um faz o seguinte pausa essa aula aqui e vai lá assistir a aula 1 primeiro porque você vai precisar entender mais sobre contêiners e sobre para acompanhar O conteúdo de hoje fechado 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 até dizer que essa é uma das Ferramentas mais importantes da sua carreira a dobradinha docker e kubernetes realmente muda o jogo de qualquer desenvolvedor quer ver uma prova disso é muito possível que você já tenha passado por uma situação semelhante a essa aí que eu tinha na Época para trabalhar era Pascal fiz as apis dele tudo dentro do do apach 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 10 se eu tinha 10 acesso simultâneo uma beleza se eu tinha 100 acesso simultâneo uma beleza chegava a 1600 caía tudo eu não eu 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é estava perdido porque eu tava preso numa estrutura que que não era escalável quando esse meu amigo começou aers começamos a conversar ele falou assim meu conheço o cabetes Cabernet ficou entrou na minha vida para ficar isso é meu inquestionável hoje eu tenho

1000 se acrescentar mais El ele escala eando 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 que eu devo fazer que eu devo me concentrar que é o código em si a qualidade do código qualidade do código aumentou muito até assim conversando com os amigos que já são da área tudo eles eles me vem até de outra forma hoje né que eles me chamam

de dinossauro da informática que o cara que tá lá ão né Hoje é o dinossauro que fica em cima né se marcar ele cai 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 por isso não dá mais para ficar estagnado fazendo ali só o arroz com feijão só pensando em código eu mesmo quando atuei em processo seletivos pude ver na prática que paraa grande maioria dos

Profissionais a falta de conceitos básicos e de conhecimentos para resolver problemas e tomar decisões importantes Ou pelo menos sugerir soluções que realmente impactam os projetos é gritante mas cara para você se diferenciar no mercado e ser valorizado por isso não basta só fazer o básico você precisa ir além e se adequar as necessidades do mercado senão você acaba perdendo a sua empregabilidade quer ver um exemplo do que eu tô falando três Quatro últimas empresas que eu trabalho Ei era esse sempre foi esse arroz com feijãozinho ali e eu comecei a perceber que as melhores vagas

os melhores salários as melhores oportunidades não tava no arroz com feijão tanto que ano pass final do ano passado eu fiz uma entrevista pro mas eu agarrei na parte técnica quando fiz quando eu fiz a entrevista técnica o cara começou a conversar comigo né Ele percebeu que eu tava no feijão com arroz do doker eu só Sabia de ouvir falar Nunca tinha mexido com d nunca tinha feito nada nada nada nada então assim eu senti que naquele dia eu perdi uma boa oportunidade porque o meu conhecimento era zer zer zer cara Precisava mudar precisava investir

não tinha como passar não tinha mais como passar no meio do ano para cá cara as os caras estav procurando direto as empresas nod assediando mesmo toda semana tinha uma empresa ligando ligando ligando ligando aqui eu achei mais Interessante é que eu consegui a vaga eu tenho mais de 15 anos já de experiência em ti né mas de uma certa forma me acomodei parei no tempo o mercado se atualizando e eu não me atualizei dois 2 anos e meio atrás eu me via estagnado no mercado sem aumento de salário e sem novas perspectivas né o

o mercado pesou e eu fiquei desempregado E aí eu decidi me especializar inicialmente somente em Cloud mas ainda não era aquilo ainda Faltava algo mais foi qu quando saiu o devops pro e o curso dele me ajudou a chegar onde eu tô hoje né eu tô muito bem empregado numa multinacional uma empresa grande Eu já entrei como como devops 2 reunião de projeto me apresentaram pra equipe né a minha função é engenheiro devol esses alunos sentiram na pele que estavam ficando para trás e decidiram se dedicar para sair do arroz com feijão e com o

direcionamento certo puderam I alizar as Suas habilidades técnicas sendo capazes de debater e tomar decisões importantes e é claro conquistaram novas oportunidades então não tem mais essa de ficar procurando desculpas para não cair dentro e se especializar porque o que mais tem por 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ô fazendo esse evento para te ajudar a evoluir cada dia mais fechado Nessa aula nós vamos avançar na orquestração dos contêineres para garantir alguns atributos fundamentais

para todos os sistemas de autod desempenho 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 irado não é e mesmo que você nunca tenha ouvido falar em kubernetes Ou não tem a mínima ideia do que ele faz Fica tranquilo que você vai conseguir acompanhar comigo beleza então bora lá até agora nós vimos como as tecnologias de contêiners e docker facilitam a execução de processos de forma isolada

permitindo rodar diversas aplicações sem conflitos e comunicando apenas os processos que eu quero isso funciona muito bem em cenários simples mas quando nós precisamos de escalabilidade resiliência e disponibilidade 24x 7 o DOC é 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 e balancear a carga durante os Picos de uso entre essas réplicas o DOC É sozinho Não faz isso Além disso recursos como o service de covery onde cada réplica de um microsserviço tem um endereço diferente e a gente precisa de um ponto

único de comunicação e acesso a essas Ricas o docker também não faz isso Sozinho Outro ponto importante é gerenciar a atualização das aplicações de forma que a gente consiga garantir um Down time zero pro usuário Além disso gerenciar configurações das aplicações e muito mais coisas e o DOC é sozinho também não vai resolver é aí que entra o kubernetes ele é um orquestrador de contêiners que gerencia todos os contêiners do seu ambiente independente da tecnologia que você tá utilizando nesse momento com kubernetes você pode Criar um ambiente único de gerenciamento de aplicações garantindo escalabilidade resiliência

atualização da sua aplicação gerenciamento de configuração e isso é essencial quando a gente fala em 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 uma Fundação que tá abaixo da Linux foundation também conhecido como Cncf e hoje o kubernetes é amplamente utilizado no mercado como a principal ferramenta para ambientes escaláveis e resilientes o kubernetes funciona com uma arquitetura de clusters onde eu tenho um conjunto de máquinas e cada máquina

vai exercer um de dois papéis possíveis control Plane e work node o control plane orquestra o cluster enquanto o work node Executa os contêineres como se fosse ali um Maestro e a orquestra o control plane ele possui Alguns componentes o Api server que é o Ponto Central de comunicação com o kubernetes é através dele que eu vou me comunicar com kubernetes um etcd que é o banco chave valor que armazena as informações do cluster O scheduler que é responsável por definir em qual nó os contêiners vão ser executados ele vai ver ali a especificação do

contêiner e Vai eleger aonde vai ser executado e o controler Manager que gerencia os controladores que mantém o estado Desejado ali do cluster kubernetes já os work Notes possuem dois componentes O kuet que é responsável por garantir a execução dos contêiners se comunicando com o contêiner runtime ou seja com a ferramenta que vai executar o contêiner e o Cub proxy que gerencia a comunicação de rede no cluster e um ponto importante aqui você já deve ter ouvido que o docker não é mais compatível com o kubernetes como container runtime e pode ter ouvido já algo

como esquece o Dock Não utiliza mais esse negócio mas calma que não é bem assim por mais que o docker não seja mais utilizado como contêiner runtime no kubernet o kubernet utiliza outros contêiners runtimes como o container d e o cryo que seguem um padrão definido pela Open container initiative que define práticas e padrões para execução de contêiners e também criação de imagens e veja só o docker também segue esse padrão Isso significa que você pode criar imagens no Dock e Usar no kubernetes Sem problema nenhum não tem essa de ah esquece o docker que

você não precisa não ele complementa ali o uso do kubernetes Sem problema nenhum você pode utilizar e Existem algumas formas de você criar um cluster kubernetes a primeira forma é a forma on premise onde você gerencia todo o ambiente você vai ter um maior controle Mas você também tem maior complexidade porque você vai ter que gerenciar tudo no cluster kubernetes instalação do Linux atualização configuração do cluster e ainda se preocupar com as aplicações sendo executadas Ou seja você vai cuidar da configuração do cluster e também das aplicações já o kubernetes como um serviço kubernetes a

a service ele é utilizado em serviços de cloud providers onde você vai criar um cluster kubernet gerenciado pelo Cloud provider como o Eks o aks e o gke aqui você solicita a criação do cluster e ele faz tudo para você Te Entregando o cluster Pronto e você vai ter que se preocupar com o gerenciamento das suas aplicações no kubernetes toda aquela parte de configuração do cluster atualização do Linux e tudo mais quem vai fazer é o cloud provider e a terceira forma é o ambiente local que é ideal para estudos e criação de provas de

conceito criação de pox onde você vai utilizar ferramentas como o mini cube o kind ou o k3d onde essas ferramentas criam o seu cluster kubernetes baseado em contêiners Docker É isso aí cara ao invés dele criar uma máquina ali no seu ambiente ele vai criar um contêiner que vai representar essa máquina montando todo o seu ambiente local cada abordagem tem as suas vantagens e desvantagens mas se você tá começando com uma equipe pequena e tá começando nesse mundo de kubernetes Eu recomendo que você use o serviço gerenciado para simplificar a criação e a gestão do

seu cluster kubernetes show de bola então agora que você sabe como Funciona o cluster kubernetes para que que ele serve vamos pra prática nós vamos criar aqui um cluster kubernetes utilizando o k3d uma solução leve e fácil de utilizar ideal para dar os primeiros passos e montar o seu ambiente de estudo local o k3d ele utiliza contêiners Dock para simular os nós do cluster permitindo criar ambientes locais com pouco recurso computacional você pode criar ali com um nó apenas e você vai consumir muito pouco recurso Certo então vamos lá Criar o cluster e entender como

fazer o Deploy de uma aplicação bom antes da gente começar aqui a utilizar e criar o kubernetes vamos falar sobre os pré-requisitos para você começar aqui a aula prática primeira coisa você tem que ter o docker instalado na sua máquina mas se você já veio da aula 1 Provavelmente você já tem segundo ponto tem que ter instalado também o k3d que é a ferramenta que a gente vai usar para criar o cluster Kubernetes aqui local para fazer a instalação dele é tranquilo é só você entrar em k3d io.io e seguir ali todo o passo a

passo de instalação ele funciona tanto em Windows Linux e Mac como eu já disse aqui na aula um Eu recomendo você fortemente utilize o Linux o Mac ou o wsl em ambiente Windows que aí você vai est trabalhando com ambiente Linux então se você tiver usando o wsl você vai Fazer instalação em ambiente Linux se tiver usando mesmo o Windows faz a instalação vai funcionar da mesma forma mas vai utiliza o wsl que é melhor experiência que nas aulas vai ser muito melhor depois que você instalar o k3d você precisa precisa ter também o Cub

CTL instalado que é a ferramenta de linha de comando que você vai usar para se comunicar com o kubernetes qualquer cluster kubernetes que você tiver trabalhando você vai ter que ter o Cub CTL então instala que vai te ajudar muito na verdade você vai ter que utilizar não tem jeito então faz a instalação também ele funciona também em Windows Linux e Mac a o RL tanto do k3d quanto do CUB CTL para fazer instalação com todo o vai tá no ridm do repositório do nosso projeto vai tá lá no ridm aula 2 eu vou colocar

todos os links lá importante para fazer a instalação é só seguir o passo a passo lá você vai conseguir Fazer a instalação Sem problema nenhum outra dica se você tiver utilizando o vs code para editar ali os arquivos que a gente vai trabalhar aqui do kubernet Eu recomendo que você utilize a extensão kubernets da Microsoft ele vai ter ali um autoc complete vai ter ali uma validação ele vai mostrar ali alguns erros caso tenha sugestões ajuda bastante na hora de trabalhar com os arquivos do kubernetes também então se você tiver utilizando o vscode faz a

Instalação dessa extensão Ah não tô utilizando vest code tô utilizando VM tô utilizando bloco de notas não tem problema você pode utilizar Só não vai ter as facilidades do vs code e da extensão do kubernetes certo Tendo isso tudo em instalado agora a gente pode ir pra prática legal então agora que você tem aí tudo instalado todos os pré-requisitos na na sua máquina no seu ambiente vamos começar aqui criando o cluster kubernetes só para conferir aqui Ó eu tenho o k3d instalado Tem aqui o docker instalado também e tenho o Cub CTL certo então agora

eu vou criar aqui o cluster kubernetes com k3d a forma mais simples de criar esse cluster kubernetes com k3d é utilizando aqui o comando k3d cluster Create certo vou executar aqui e ele vai fazer a criação do cluster kubernetes para mim ele vai fazer ali a criação do container vai criar aqui todas as Networks tudo que é Necessário tá para criar aqui o cluster kubernetes para mim ele vai fazer automaticamente vai fazer a configuração do CUB CTL tudo que é necessário eu executo aqui o k3d cluster Create e ele prepara tudo para mim deixa tudo

configurado é só utilizar Então esse processo demora um pouquinho principalmente porque tá baixando a imagem e tudo mais e aí beleza terminou agora eu vou vir aqui e vou executar o comando Cub CTL get noes Esse comando Ele serve para você listar os nós do seu cluster kubernetes para você se comunicar com o cluster kubernetes e ele vai mostrar quantas máquinas quantos nos eu tenho nesse momento no meu cluster se eu executar aqui o enter ele mostra aqui para mim lá eu tenho um cluster kubernetes criado com um nó apenas e você vê que ele

mostra aqui que ele é o control plane pô Fabrício Mas você falou que o control plane ele orquestra ele não Executa os contêiners quem executa é o work node nesse caso aqui com o k3d e ele vai vai criar contêiners também ele vai criar ali os meus Pods que a gente vai ver daqui a pouquinho então você pode utilizar aqui para esse cenário local para você estudar fazer suas potes um no só que não vai ter problema nenhum certo mas e se eu quiser criar mais calma eu vou mostrar para você mas antes eu tenho

aqui o cluster kubernetes criado mas eu tenho aqui alguns outros Comandos importantes no k3d para você gerenciar os clusters o primeiro aqui é o k3d cluster list aqui ó com esse comando você vai listar os clusters kubernetes que você tem criado aqui no seu ambiente com o k3d ele mostra aqui ó ele tem o nome né do do cluster a quantidade de servers que no caso aqui é o control plane a quantidade de Agents que no caso são os worker nodes e aqui é o load balancer o load balancer aqui é um Balanceador de carga

que fica na frente do cluster Então como a ideia aqui é mostrar um cenário próximo de da criação de um ambiente de produção para você simular um ambiente ele cria também um load balanc na frente do cluster kubernetes certo então aqui você vai conseguir listar esses clusters que foram criados com k3d agora se você quiser deletar esse cluster kubernetes aqui você pode vir aqui ó e executar o K3d cluster delete certo e aí coloca aqui o nome ou não coloca porque foi o nome Def ele vai deletar aqui para mim á vai deletar todo o

cluster se eu executar aqui agora Cub CTL get noes ah lá eu não tenho conectividade eu não consigo me conectar com o cluster kubernetes mais porque ele foi deletado legal agora para você entender como otimizar essa criação melhor do cluster kubernetes com k3d a gente vai criar aqui de uma outra forma a gente vai Executar aqui o k3d cluster Create mas agora passando alguns parâmetros a mais o primeiro que eu vou passar aqui é o nome do cluster Se eu colocar aqui ó meu cluster Eu agora tô dando um nome para esse cluster kubernetes que

eu tô criando e eu posso passar passar aqui também o parâmetro servers que vai definir quantos servers quantos control Planes eu quero aqui nesse cluster kubernetes no caso aqui eu vou botar três servers eu quero três control Planes eu quero trabalhar num cenário de alta disponibilidade e em seguida eu posso colocar aqui o Agents né que são os agentes ou seja os worker nodes no k3d assim como no k3s que é o que é baseado e ao invés de ter control Plane e worker node ae trabalha com o nome servers e Agents mas na prática

e os servers são control Planes e os Agents são worker noes Então vou colocar aqui Agents 3 beleza e eu vou executar de novo e ele Vai demorar um pouco mais por quê Porque é um cenário mais complexo ele tá criando aqui um cluster kubernetes com muito mais elementos com muito mais nós vai ter que criar ali os control Planes os worker nodes né ou servers e Agents vai criar aqui o load balance vai fazer a conectividade com todos esses caras então demora um pouquinho aqui o processo vamos esperar a terminar aqui de criar show

de bola aqui ó ele terminou de criar o meu cluster Kubernetes se eu vir aqui agora ó deixa eu dar um Clear aqui e se eu executar o k3d cluster list ele vai listar aqui agora o cluster kubernetes com o nome meu cluster e agora eu tenho três servers e três engin fora o load balance se eu executar agora o Cub CTL get nodes Olha lá o meu cenário já mudou eu tenho agora um cluster kubernet com seis nos sendo que três são control Planes e os outros três são o worker noes beleza nesse setup

aqui mesmo assim o k3d ele Vai criar né os seus Pods ou os contêiners também no control planin o k3s por padrão ele coloca ali eh agendado né ele Executa os contêiners em qualquer ambiente então se você executar aí depois a criação dos seus contêiners como a gente vai fazer aqui e tiver rodando no server não tem problema não fica com medo porque acontece o k3d e o k3s funciona dessa forma agora a gente tem o cluster kubernetes criado a gente pode começar a pensar em fazer aqui o Deploy da nossa aplicação mas antes eu

quero fazer o seguinte eu quero mostrar para você aqui com o docker container LS como fica aqui né a criação do meu cluster kubernetes em relação aos contêiners Ó você vê que para cada nó para cada máquina né entre aspas aqui do cluster kubernetes ele utiliza aqui um contêiner e ele cria aqui um contêiner mais que é oad balance aqui o k3d proxy e ele tem um contêiner adicional que é o k3d Tools que é um contêiner auxiliar Aqui na criação do cruster kubernetes com o k3d qual a dica que eu dou aqui para você

você pode criar o cruster kubernet da forma que eu mostrei aqui com três servers e três Agents não tem problema nenhum mas quanto mais nós quanto mais máquinas você coloca no cluster kubernetes mas vai exigir aqui da sua máquina se você tem uma máquina que aguenta que tem bastante memória que tem um processador legal beleza você pode colocar aí é mais nós Ah não tem Minha máquina é mais enxuta não tem tanta memória e tal também não tem problema você pode criar o cluster kubernetes aqui é da forma simples com um nó apenas que vai

funcionar da mesma forma isso não vai impactar aqui para você aprender a trabalhar com kubernetes beleza agora que a gente terminou aqui de de criar o cluster kubernetes você sabe criar o cluster kubernetes com k3d vamos fazer o Deploy da nossa aplicação aqui com versão temperatura e entender Os componentes de Deploy do kubernetes agora que a gente tem o cluster kubernetes criado vamos fazer o Deploy da nossa aplicação para executar um contêiner no cluster kubernetes mas antes da gente botar a mão na massa é importante você entender o seguinte existem alguns objetos no cluster kubernetes

que estão relacionados ao Deploy a Executar a aplicação corretamente no kubernetes e é importante você entender cada um deles Para você saber a função deles e caso aconteça algum problema aonde você vai verificar primeiro não simplesmente copiar e colar aqui o modo de fazer e executar quando a gente fala em Deploy no kubernetes São três objetos envolvidos aqui na maioria das vezes tem outros mas na maioria das vezes vão ser esses três O primeiro é o pod o pod ele é o menor objeto do cluster kubernetes é nele que eu executo os meus containers agora

você executar uma aplicação só com O pod não garante a escalabilidade e a resiliência que você quer no cluster kubernetes então acima do pod eu vou ter um controlador que vai gerenciar os meus Pods E aí entra o replica 7 o replica 7 ele vai garantir que a a quantidade de réplicas que eu defino ali que tenha em execução dos meus Pods no cluster vai ser a realmente que vai tá em execução então se eu criar lá um RCA set com um template do pod com um pod que deve ser executado e falar cara eu

quero duas Réplicas aqui desse pod eu quero duas cópias ele vai fazer o possível para executar esses dois Pods essas duas réplicas se um pod for deletado for eliminado por qualquer motivo Ele vai criar outro no lugar se eu aumentar para quatro ele vai aumentar para quatro se eu diminuir para dois ele vai diminuir ali para dois então ele vai gerenciar essa quantidade de réplicas depois acima do réplica 7 eu tenho o deployment o deployment aí vai gerenciar o rplica 7 Mas por que isso por que que eu vou ter esse Deploy gerenciando o replica

7 porque o deployment aí vai ser responsável pela a atualização da minha aplicação Se eu mudar ali por exemplo a imagem que eu tô executando no meu pod e atualizar a minha aplicação o deployment ele vai criar um novo RCA set com essa nova versão que vai gerenciar os Pods com essa nova versão E aí gradativamente por padrão ele vai eliminar um pod do repica 7 antigo e criar um pod novo lá No novo Rep Cass 7 com a nova versão vai fazer isso gradativamente até ter todos os Pods ali e com a nova versão

em execução E aí esse RCA 7 antigo ele vai ficar lá desabilitado inativo enquanto o com a nova versão vai est gerenciando os novos Pods E por que ele faz isso porque caso tenha algum problema na execução da dessa nova versão da sua aplicação e você tenha que fazer um holback é muito mais simples você com um simples comando executa o rollback e esse replica set Que tava ali inativo vai voltar a ficar ativo e vai fazer todo o processo de troca dos Pods de novo então dessa forma você consegue garantir escalabilidade resiliência e também

uma troca de versão muito mais eficiente garantindo que você consegue trocar a versão da sua aplicação sem Down time pro usuário Então agora que você entendeu esses objetos e a função de cada um deles Vamos criar aqui na prática o nosso deployment com o RCA 7 e também com o Pod vamos lá então o que eu preciso ter aqui para criar o meu deployment meu replica set e o meu pod no kubernetes e Executar a minha aplicação primeiro ponto você tem que ter aí a imagem da aplicação já pronta Porque como você vai Executar a

aplicação em contêiners você precisa ter a imagem base com tudo que é necessário para executar as sua aplicação aqui a gente vai fazer um Deploy simples utilizando a aplicação conversão temperatura a mesma aplicação Que eu utilizei na aula um aqui com você onde a gente executou no nosso ambiente com Dock criamos imagem pegamos lá no repositório criamos o docker file e tudo mais então o repositório conversão temperatura que você criou com o seu docker file para executar local na sua máquina com o docker a gente vai utilizar aqui também depois depis você entender aqui os

conceitos do kubernetes de Deploy no kubernetes a gente vai pra nossa aplicação a Vera certo mas aqui Vamos focar no conversão temperatura então a imagem ela já tá pronta a gente criou na aula passada agora para eu declarar esses objetos no kubernet eu preciso de alguma forma falar olha kubernetes eu quero que você crie aí esses objetos e faça o Deploy da minha aplicação para isso nós vamos utilizar o padrão do kubernetes que é o arquivo de Manifesto o arquivo de Manifesto nada mais é do que um arquivo no formato emo onde eu vou colocar

ali todos os campos Bases né de um Manifesto com todas as especificações do que eu quero criar no kubernetes E aí depois eu vou utilizar um comando do kubernetes para avisar pro kubernetes olha aplica esse arquivo com tudo que tiver dentro dele declarado E cria aí para mim o kubernetes Ele trabalha de forma declarativa eu declaro que eu quero que seja criado aplico lá no cluster kubernetes e ele cria para mim qual que é a alteração que eu queira fazer nesses objetos eu altero o arquivo Aplico de novo e ele faz as alterações e isso

para mim é muito bom porque eu consigo pegar esse arquivo de Manifesto versionar num repositório Git e sempre que eu quiser fazer a ali uma alteração eu consigo pegar desse repositório e aplicar ou utilizar uma pipeline C icd que a gente vai fazer também nas próximas aulas Então vamos lá vamos entender como criar esse arquivo de Manifesto como eu vou trabalhar aqui com um arquivo né na verdade é um TXT no Formato iemo e eu vou utilizar um editor de texto como eu disse aqui recomendo que você utilize o vs Code com a extensão do

kubernetes que vai te ajudar bastante Assim como a gente fez na aula de Doc então aqui no caso eu já tenho o repositório do conversão temperatura eu vou utilizar aqui o mesmo repositório que eu utilizei na aula passada aqui no caso eu já tenho o dockerfile mas eu não vou mexer aqui no dockerfile porque eu já tenho lá a imagem pronta e eu vou Simplesmente aqui junto no meu na minha pasta CCE aqui na raiz eu vou criar uma pasta chamada a8s eu vou colocar o meu arquivo de Manifesto aqui como esse arquivo ele segue

o padrão emo eu vou vir aqui e vou criar ele com o nome de deployment pemo ou IML yml é dá na mesma certo eu gosto sempre de utilizar aqui o Emo Ok então agora eu criei o arquivo e agora eu vou colocar todos os campos necessários para declarar esse Manifesto primeiro campo que eu vou colocar aqui é O Api version Ou seja a versão da api que eu vou utilizar para criar o objeto que que acontece quando eu trabalho com o kubernetes todos os recursos do kubernetes são agrupados em apis Então sempre que você

vai criar um objeto você tem que definir qual é a versão da api que você vai utilizar E por que isso é importante e é legal na organização dos recursos do kubernetes porque muitas vezes principalmente quando você tiver e Consumindo ali um recurso novo ou uma nova feature que tá em desenvolvimento do kubernet pode acontecer de você ter duas versões de apis diferentes para mesmo objeto Principalmente quando tá tendo transição de uma versão Alfa para Beta ou da Beta para uma versão final para manter a compatibilidade e a transição né na adoção desses objetos numa

mesma versão do kubernetes eu posso ter o mesmo objeto em versão Beta e em versão final que vai mudar é o Api Version é o grupo de api que você vai utilizar no nosso caso aqui como são objetos que já são utilizados no kubernet São nativos ali do kubernetes em versão final api não vai mudar mas eu tô falando isso porque caso você esteja utilizando algum outro recurso alguma novidade que você esteja adotando no kubernetes isso pode acontecer e como é que você você faz para saber qual é o Api version aqui no caso eu

já tenho o cluster kubernetes rodando certo com k3d Eu vou executar o comando Cub CTL api resources certo ele vai listar aqui para mim todos os recursos de api aqui do kubernetes e se você olhar aqui ele tem o nome do objeto o short name que é o apelido desse objeto e olha só que legal o Api version ele mostra aqui também se ele é names spaced se ele é separado por ele é separável por namespace eu não vou entrar aqui em namespace nessa semana e aqui o kind que é o tipo do objeto como

eu vou criar Aqui o deployment que que eu vou procurar aqui o meu objeto com o nome deployments Ó tá aqui ó deployment el tem um shortname Deploy ele tem aqui o Api version e Apps Apps bar v1 ele é separável por namespace mas eu não vou abordar isso aqui e o kind o tipo de objeto dele no kubernetes é o deployment Mas você pode ver que cara tem muita coisa aqui para ser vista tem muito objeto no kubernet cada um tem as suas responsabilidades e recursos cara é é Realmente aqui bastante objeto tanto que

na formação devops pro cara tem dois módulos só para falar falar de kubernetes por conta desse dessa dessa quantidade de recursos e objetos envolvidos no kubernetes Então cara vale a pena depois você se aprofundar Então a gente vai utilizar aqui o deployments certo então aqui o meu api version vai ser apps bar v1 meu grupo de api vai ser exatamente esse certo em seguida eu tenho que declarar Aqui o o kind Qual é o tipo de objeto que eu vou trabalhar aqui né já tem uma cola que no caso aqui é o deployment né então

eu vou pegar aqui o nome e vou colar aqui beleza ele vai e já entender que eu vou criar um objeto deployment utilizando esse grupo de api certo então declarei a pay version declarei aqui o kind agora eu vou botar o metadata o metadata são os metadados desse objeto aqui eu vou botar nome labels que a gente vai ver depois então Eu vou colocar todos os metadados aqui do meu objeto e no caso aqui eu só vou botar o nome desse objeto do meu Deploy no caso vou botar conversão Opa temperatura que vai ser o

nome aqui da aplicação que eu vou executar ok então declarei aqui o nome da minha aplicação deixa eu ver o que que ele tá mostrando aqui ah não Beleza não tem problema OK agora eu vou declarar o meu spec eu vou Declarar a especificação aqui do meu do meu deployment qual o que que eu quero configurar aqui nesse deployment a primeira coisa que eu vou configurar o CoPilot já tá soltando aqui um spoiler calma CoPilot não mostra essa parada agora eh mas a primeira coisa que eu quero declarar aqui é a quantidade de réplicas que

eu quero ter aqui do meu pod certo Eh quantas Quanto qual qual a quantidade de Pods que eu quero ter ali em execução que o réplica 7 que vai ser Criado aqui pelo deployment vai gerenciar no caso eu quero aqui uma réplica só só vou colocar aqui eh uma réplica OK Agora eu preciso declarar o seguinte eu preciso declarar o selector o seletor de objetos do deployment que que é isso que que é esse lance de selectors toda vez que eu tô trabalhando com kubernetes e os objetos que fazem parte do kubernetes o deployment o

replica 7 e o meu pod toda vez que eu preciso interagir e selecionar objetos Um objeto selecionando o outro eu vou utilizar o conceito de labels e selectors label nada mais mais é do que um par de chave e valor onde eu vou colocar ali uma chave e um valor ou mais de uma chave e mais um valor um conjunto de chaves e valores vai e o selector é justamente eh qual é a regra de seleção baseada em labels que eu vou utilizar para selecionar um objeto por exemplo aqui no nosso caso eu tenho o

deployment e eu Vou criar um template que vai definir Quais são os Pods que esse deployment e o replica 7 vão gerenciar então eu vou definir um par de chave valor né no meu no meu pod certo e aqui eu preciso colocar o seletor para definir que baseado nessas labels que eu vou definir lá no pod eu quero selecionar para quê pro meu replica set o meu deployment gerenciem eh parece até estranho que eu primeiro coloco aqui o seletor né e antes do template ali do meu pod Mas não Tem problema o objetivo aqui é

que o selector e a Label tem ali os as mesmas os mesmos valores mesma chave e o mesmo valor então aqui eu vou definir o selector vai ficar mais se você não entendeu vai ficar mais claro aqui em seguida a gente vai ver isso aqui na prática eu vou criar aqui o seletor a regra de seleção é baseada em mat Label ou seja garantir que o a Label e o selector tenham aqui a mesma chave e o mesmo valor E aí eu vou colocar aqui a Chave app e o valor conversão temperatura beleza dessa forma

aqui então eu defini quais são a qual é a chave e qual é o valor que eu vou tá trabalhando aqui que eu vou est selecionando os meus p Beleza agora que eu declarei aqui e o meu o meu selector e a quantidade de réplicas eu vou definir aqui o meu template e o que que tem aqui no template é justamente a estrutura do meu Pod o que que eu vou declarar ali do meu pod e para ser executado no kubernetes lembrando o pod ele é o menor objeto do cluster kubernetes é nele que eu

vou executar o meu contêiner Então o que eu vou ter aqui declarado no meu pod o meu contêiner que eu vou Executar a minha aplicação então aqui no template eu vou declarar o conteúdo do meu pod assim como o deployment eu deveria né colocar também o Api version kind metadata todas essas informações no pod Mas como eu tô Definindo aqui o template dentro do deployment ele já entende que aqui dentro do template eu tô criando um pod então o Api version o kide eu não preciso colocar o metadata sim porque eu preciso colocar os metadados

do meu pod E aí eu vou colocar aqui o nome do meu pod não por quê Porque esse cara vai ser criado dinamicamente o RCA 7 ele vai gerenciar ali os meus Pods e garantir que eu vou ter a quantidade de réplicas então não faz sentido colocar aqui o Nome porque esse nome vai ser criado dinamicamente Agora eu preciso definir aqui o meu par aqui de chave e valor para definir a minha Label para definir que o meu deployment e o replica 7 vão gerenciar aqui esses Pods Então eu preciso declarar aqui a minha Label

então aqui eu vou botar labels certo e Vou definir aqui o app conversão temperatura igual eu fiz aqui em cima Beleza se eu botar isso aqui diferente que que vai acontecer vai dar erro ele Nem vai deixar criar o deployment Porque vão tá aqui diferente então é esse é o conceito de labels e select eu coloco aqui o meu meus dois elemento chave e valor posso colocar aqui vários e o selector aqui vai ter que bater para eu interagir com esse objeto Então beleza defini aqui o meu metadata e aqui eu preciso definir também o

spec qual é a especificação desse meu pod então coloco aqui o spec Opa fiz besteira aqui aqui ó vou botar aqui ó spec certo Opa botei Aqui na identação errada tem que botar aqui certinho senão ele não funciona E aí na especifica aqui do meu pod eu vou colocar o meu contêiner certo ah Fabrício mas aí tá contêiners pô tem Tá certo isso aí tá certo por quê Porque o pod ele pode executar um ou mais contêiners certo mas aqui no nosso cenário eu vou utilizar aqui só um contêiner E aí como é uma lista

eu posso ter vários contêiners eu tenho que colocar aqui como uma lista mas no nosso Caso aqui a gente vai trabalhar com com um só onde é que eu vou utilizar cenários com mais de um contêiner no meu pod Principalmente quando você tá trabalhando com um padrão de projeto chamado Side car no kubernetes ferramentas como e o linker service MH utilizam bastante mas de uma forma geral você vai ter ali eh um contêiner dentro do pod E aí agora eu vou declarar o nome desse meu contêiner E aí eu vou botar aqui simplesmente com versão

em seguida Eu coloco aqui o nome da imagem que eu vou utilizar E aí a gente vai utilizar a mesma imagem que a gente criou na primeira aula então deixa eu até abrir aqui o meu dockerhub pra gente ver certinho no caso você vai entrar também no seu dockerhub visualizar Aí eh qual foi o nome da imagem corretamente que você fez e utilizar aqui sem problema nenhum aqui no caso ó eu tenho minha lista de imagens meu repositório e eu tenho aqui ó conversão temperatura que Foi a imagem que eu criei junto com você na

primeira aula eu tenho aqui ó a latest e a V1 lembrando é uma boa prática sempre definir aqui a tag para você garantir que vai tá utilizando sempre a mesma versão de imagem então eu vou pegar aqui o nome da minha imagem conversão Fabrício verones conversão temperatura e eu vou definir aqui a tag Vou definir que eu vou utilizar a versão um aqui do meu da minha imagem doc com a Minha aplicação então agora defini aqui a imagem agora eu vou definir as portas que eu vou utilizar né quis portas eu vou expor desse contêiner

aqui no meu pod a aplicação conversão temperatura utiliza a porta 8080 então aqui eu vou colocar que o Meu Container port vai ser 8080 também certo para você se você tiver utilizando o vs code vai est aqui esse amarelo aqui esse warning né Falando que ah tem algum problema aqui e Tal mas que que acontece tem muito mais coisas que a gente pode configurar no nosso pod eu posso colocar aqui Liv prob tem posso colocar redness probe para verificar saúde ficar se o meu contêiner tá pronto posso definir aqui recurso computacional né quanto de de

CPU quanto de memória o meu pod vai est consumindo Ou melhor aqui o meu contêiner vai est consumindo que inclusive aqui ó é exatamente isso que ele tá reclamando né que eu não defini a quantidade de Recurso mas eu não vou entrar nesses tópicos porque como eu disse são tópicos mais avançados eh por isso que como eu de novo na na formação da bops pro cara tem dois módulos só sobre kubernetes kubernetes aplicações e kubernetes administração porque realmente tem muita coisa para se aprender do kubernetes mas como aqui o objetivo é dar os primeiros passos

eu não vou entrar aqui eh nesses outros recursos isso aqui pr pra nossa semana vai atender tranquilamente então Criei aqui o meu arquivo de Manifesto com o meu Deploy e também min especificação do meu pod agora eu vou executar esse cara vou dar um Clear aqui deixa eu limpar aqui o meu terminal e agora eu vou aplicar né esse meu Manifesto no kubernetes e para fazer isso eu vou utilizar o comando Cub CTL deixa eu aumentar aqui um pouquinho Cub CTL apply certo para aplicar essa configuração passando aqui o Men F Onde Eu Vou definir

qual arquivo que eu vou Utilizar Qual é o file que eu vou utilizar no caso é o arquivo que tá dentro da pasta k8s o arquivo Deploy pemo executo e ele vai criar aqui para mim ele aplicou isso lá para mim no cluster kubernetes E aí como é que eu sei que ele realmente fez isso como é que eu sei que ele realmente eh fez essa essa criação dos objetos né no caso aqui do deployment vamos dar uma olhada eu vou executar aqui ó o comando Cub CTL Get deployment ou Deploy não tem problema Posso

usar deployment que é o nome do objeto ou short name então executo aqui e ele vai listar aqui para mim ó o meu objeto que foi criado agora deployment certo conversão temperatura tá aqui ó conversão temperatura e aí né Eu posso também executar o Cub CTL get replica 7 Lembra que eu falei que o deployment ele cria o replica set para mim olha lá ele criou aqui um repc set para gerenciar os Meus Pods inclusive ele mostra aqui ó no deployment é quantos container ou melhor quantos Eh quantos Pods eu tenho aqui em execução né

quantos eu tenho aqui definidos e quantos eles estão realmente prontos né Quantos estão atualizados ão com a versão ali que eu especifiquei Quantos estão disponíveis E H quanto tempo foram criados certo e aqui é mesma coisa no repica 7 mas ele mostra outras informações ele mostra aqui ó Quantos são desejados né quantas réplicas Eu Desejo que tenha em execução aqui quantas réplicas Eh quantos tem aqui realmente sendo executados no kubernetes quanto estão prontos né Quantos estão in Ready e aqui há quanto tempo eh ele foi criado e aí percebe o seguinte como o RCA 7

ele é criado também dinamicamente se eu alterar a versão ali da minha aplicação né e aplicar de novo ele vai criar um novo RCA set para fazer toda aquela atualização o nome do meu RCA set Ele é gerado aqui dinamicamente ó ele pega o nome do meu deployment e coloca aqui esse conjunto de caracteres né esse conjunto de de números e letras e aí quando eu criar se eu atualizar aqui ele vai criar aqui dinamicamente também a gente vai ver isso daqui a pouquinho mas aí ele cria aqui o replica set E se eu executar

aqui Cub CTL get pod eu vou listar o meu pod E aí eu tenho aqui ó a mesma coisa ó ele cria de dinamicamente o nome você vê que ele pega como base o Nome do replica set coloca aqui também um conjunto de caracteres e aqui eu também tenho algumas informações esse Ready aqui ele não é igual o Ready aqui do deployment às vezes até confunde né você vê que na hora que eu fui falar ali eu quase falei como se fosse o pod mas o que acontece esse Ready aqui é quantos podes eu tenho

prontos né porque tá referenciando aqui o deployment e a ele ele vai informar isso para mim aqui no caso esse Red do pod ele tá falando em Relação a quantidade de contêiners dentro do pod lembra que eu tenho ali e a capacidade de ter mais de um contêiner dentro do pod então aquele mostra quantos contêiners eu tenho e quantos estão aqui prontos estão Ready e aqui eu tenho o status dele no caso tá em execução quantas vezes eles foram Restart ados os meus contêiners e aqui o tempo dele eu posso também executar aqui ó o

Cub CTL get All E aí ele vai trazer tudo para mim ele vai mostrar aqui ó o Meu pod o meu deployment e o meu RCA set ele mostra aqui o service Mas calma a gente daqui a pouco vai falar sobre service mas ele mostra aqui as informações dos três se eu quiser ver mais informação sobre o meu pod se eu quiser ver mais informação sobre o meu deployment ou sobre o meu repc 7 eu posso pegar aqui o nome de qualquer um deles e executar o comando Cub C describe colocar o nome do objeto

que no caso aqui é o pod e colocar aqui o nome Do objeto que no caso é o nome ali do meu pod Se eu der um enter ele me mostra aqui mais detalhes ele me dá toda descrição desse objeto ele fala o nome o namespace a prioridade você vê que tem muita informação para você ver aqui em relação ao pod inclusive ele mostra ó em qual nó esse cara tá sendo executado ó aí tá sendo executado no k3d meu cluster Agent 1 e eu consigo aqui ver mais informações consigo ver a imagem consigo ver

aqui bastante detalhe sobre o pod Inclusive aqui no final ele mostra os eventos de criação certo então eu consegui rodar aqui a a minha aplicação né utilizando os principais objetos do pod E aí vamos dar uma olhada aqui no seguinte e como é que eu faço para ver essa aplicação rodando né como é que eu faço para ver isso aqui rodando para acessar aqui o meu pod para acessar aqui o meu serviço rodando no meu pod eu tenho aqui um recurso né chamado Cub CTL port Forward certo esse cara ele redireciona e as chamadas em

uma porta da na minha máquina local pra porta do meu pod que tá executando lá o contêiner como se fosse um publish de porta ou um port bind lá do Dock então aqui eu vou utilizar o cubc port forward colocando aqui o meu pod o nome do meu pod e a porta da minha máquina com a porta do pod que no caso Vou acessar aqui a porta 8080 que eu declarei lá no contêiner executo aqui ó Lá ele vai é travar aqui o meu terminal mas se eu abrir aqui certo e colocar é local host

8080 ele mostra aqui para mim ó lá a minha aplicação né rodando aqui ó conversão temperatura host ele mostra aqui o nome inclusive do pod em execução E aí eu posso utilizar tranquilo aqui ó eh cel 50º C para fen ó 122 e aqui 122 fahenheit para Celsius e vai me mostrar aqui 50 então aqui eu conseguir fazer o Deploy da minha aplicação se eu mostrar Aqui para você ó se eu testar aqui ó Cub CTL get pod eu você vai ver que eu tenho na resiliência aqui em relação ao meu pod se eu vir

aqui ó e executar um Cub CTL eh lilit podde deletar aqui o meu pod ele vai deletar certo mas se eu viro aqui ó Cub CTL get pod outro ó inclusive peguei aqui ele terminando esse pod para ir criando aqui outro por quê Porque o repc 7 aí tá fazendo esse gerenciamento ele vai ver que um pod foi eliminado e vai criar a outra aqui no lugar e eu Tenho também a escalabilidade eu consigo escalar aqui e os meus Pods alterando aqui a quantidade de réplicas eu posso botar aqui ó quatro e executar aqui Cub

C apply - F k8s deployment executo Ó lá ele vai converter ele vai aplicar E se eu executar aqui agora Cub CTL get pod Ah lá ele tá criando agora e as réplicas até fazer com que fique em quatro se eu executar aqui com CTL get All ele vai listar aqui ó todos todos os meus Pods Aqui o meu service o meu deployment e aqui o repica set você vê que ele mudou aqui ó inclusive ele tá mostrando aqui ó ele tem quatro né e declarado só tem dois Ready porque ele ainda tá criando aqui

ó ele ainda tá criando eu tenho aqui dois em um aqui tá criando ainda daqui a pouco ele começa a funcionar inclusive tá aqui ó desired Cent e eu tenho aqui em Ready Eu tenho dois né Se eu vir aqui executar de novo ó lá ele ainda tá criando ó tá criando aqui o Último né E tá baixando ali a imagem pro nó e tudo mais mas ele consegue aqui escalar já tá tudo rodando legal mas pô Fabrício Beleza você conseguiu acessar a aplicação mas simplesmente ali né do pod diretamente utilizando o port forward só

que pô num cenário real eu não vou fazer isso né Principalmente quando eu tenho aqui ó várias réplicas como é que a gente vai fazer agora para acessar aqui a aplicação só que acessando como um ponto único de acesso e ele fazendo essa Esse balanceamento essa alternância né entre os meus Pods para que eu consiga escalar e balancear a carga entre as minhas réplicas para isso eu vou utilizar um outro objeto um outro recurso aqui do kubernetes que é o service que a gente vai ver agora o que que é o service o service é

o objeto do kubernetes que atua como service Discovery ou seja para cada réplica que você tem criado ali da sua aplicação para cada pod que tá rodando ali a sua Aplicação o service vai ter o endereço de cada um deles e ao invés de você quando quiser acessar a sua aplicação se preocupar com o endereço ali do pod qual pod você vai acessar você vai direto no service você vai acessar o service e ele vai redirecionar você ali para uma réplica então ele vai ter ali o catálogo de endereço vamos dizer assim dos seus Pods

e vai fazer esse balanceamento de carga sempre que chegar ali uma chamada nele ele redireciona utilizando ali a Alternância entre os endereços garantindo que as cargas vão ser sempre distribuída entre as réplicas Então sempre que você quiser acessar um pod no seu cluster kubernetes você não vai direto no pod você não vai pegar endereço do pod diretamente você vai sempre criar um service e acessar pelo service agora um ponto muito importante eu tenho alguns tipos diferentes de service eu vou falar aqui três que são os principais mas tem outros eu tenho Service do tipo cluster

IP eu tenho Service do tipo node port e eu tenho o Service do tipo load balancer o Service do tipo cluster IP ele é utilizado internamente no cluster kubernetes ou seja ele só é acessível de dentro do cluster kubernetes e onde é que você vai utilizar esse tipo de Cice Sempre que você quiser acessar um pod que só vai ser utilizado por outros Pods no cluster kubernetes Então você tem ali diversos microsserviços dentro do seu custer Kubernetes você vai criar um Service cluster IP e esses microsserviços vão conseguir se comunicar entre si internamente no kubernetes

agora se você quiser colocar esse cara é acessível externamente se você quiser colocar sua aplicação acessível externamente você pode utilizar o Service do tipo node port ou lo balance o tipo node port ele é utilizado para você tornar acessível externamente e o endereço que você vai vai utilizar para acessar esse serviço Externamente vai ser um dos IPs que dos Nós das máquinas que fazem parte do cluster kubernetes Então sempre que você cria um service node port você vai acessar esse service é utilizando qualquer um dos endereços IPs para acessar a máquina ali do que faz

parte do cluster kubernetes pode ser work node ou dos control Planes agora não é só acessar pelo IP você precisa também da porta de acesso porque sempre que você vai acessar um serviço você vai acessar Também pela porta e o Service do tipo node port por padrão ele elege uma porta ali da sua máquina para ser a porta de acesso ao service e vai ser redirecionado ali depois pro pod por padrão o node port ele elege um Range de porta entre uma porta entre o Range 30.000 até o 32.767 dá para você alterar isso mas

esse é o padrão então sempre que você cria um service node port ele vai pegar uma porta que ainda não está em uso Nesse range e vai utilizar para acessar e ali o service Então você vai colocar o IP e essa porta que ele tá utilizando já o Service do tipo load balance é diferente o Service do tipo load balance ele cria um IP de acesso externo ele cria ali um endereço público IP e você acessa ali por esse IP o service e vai redirecionar pro pod então o node port ele basicamente é mais utilizado

em ambientes onone premise onde você não tem ali e um serviço de nuvem que vai te Fornecer esse IP o load balance seria mais utilizado nos Cloud providers porque além de ter ali o endereço público criado ele tem ali um balance que é criado na frente certo dá para você trabalhar também com load balanc em ambientes on prem utilizando ferramenta como o metal LB mas por padrão o node port você vai utilizar mais em ambientes on premise e o load balance em ambientes de cloud Ok então esses são aqui os três tipos de service que

você pode utilizar Os três principais tem outros mas não vou entrar aqui nesses detalhes então agora vamos criar aqui o service que nós vamos utilizar aqui como ponto de comunicação com a nossa aplicação conversão temperatura pra gente conseguir acessar todas as réplicas da aplicação E aí para isso eu vou fazer o seguinte eu vou voltar aqui pro meu vs code vou abrir ele aqui e como ele é mais um objeto aqui no kubernetes que que eu vou ter que fazer vou ter que Criar um outro Manifesto para criar um outro objeto no meu cluster kubernetes

eu posso criar esse OB jeto aqui com um outro arquivo Emo ou eu posso colocar aqui junto nesse mesmo arquivo para uma boa prática né o é recomendado você colocar tudo no mesmo arquivo tudo que faz parte do Deploy da sua aplicação colocar no mesmo arquivo então eu vou colocar tudo aqui nesse mesmo arquivo e para fazer isso aqui para separar um objeto do outro eu vou utilizar aqui ó Três traços E aí ele já separa em entende que agora aqui ó eu tenho a criação de um service ou ou qualquer outro objeto que eu

venha criar aqui beleza então eu vou utilizar aqui essa mesma estrutura Inicial ap version kind metadata E spec então vou colocar aqui ó api version certo que no caso aqui do Service não é o apps v1 é simplesmente v1 Vou botar aqui o kind que no caso aqui é o tipo service Vou definir aqui o metadata onde Eu vou colocar aqui o name como conversão temperatura também e vou definir aqui o spec com a onde eu vou colocar a especificação aqui do meu service a primeira coisa que eu tenho que determinar aqui no meu service

é quais Pods eu vou expor nesse service E aí eu vou ter que ser selecionar os objetos de pod que eu vou utilizar aqui para que eu vou expor aqui com o service e como é que eu faço aqui para trabalhar com Seleção de objetos no kubernetes eu vou utilizar o conceito de selectors E labels então aqui primeira coisa que eu vou declarar é o selector né Quais são os Pods que eu vou selecionar E aí como é que eu faço isso eu declaro aqui né a chave e o o valor dos Pods que eu

vou selecionar no caso aqui eu tenho app conversão temperatura então aqui o meu selector vai ser App conv versão temperatura ele vai procurar todos os Pods que tem e essa chave e esse valor e Vai expor aqui no service vai pegar o endereço de acesso de todos eles e vai colocar lá no catálogo para quando tiver uma chamada ali ele redirecionar então beleza coloquei aqui o meu selector agora eu vou declarar o tipo de serviço que eu vou utilizar como eu tô trabalhando aqui com ambiente local eu não vou utilizar o load balancer porque o

load balancer por padrão ele é utilizado em ambientes de cloud onde eu vou ter ali o serviço do Cloud provider Me fornecendo ali endereço IP load balancer e tudo mais então aqui ou eu vou utilizar o cluster pi certo ou eu vou utilizar o node port como eu tô utilizando aqui é um service que vai expor e para fora do meu cluster kubernetes eu vou utilizar aqui o node port certo beleza e aí consigo declarar aqui o meu service corretamente agora eu vou declarar aqui também e as portas que esse service vai expor então aqui

eu posso colocar várias portas Então Declaro aqui é as minhas portas com Portes e aqui eu vou passar uma lista de portas e a porta que eu vou utilizar aqui como é uma uma requisição http né uma aplicação http eu vou utilizar a porta 80 para eu poder utilizar aqui o o protocolo http poder acessar diretamente a porta padrão http que é a 80 E aí que que eu vou fazer em seguida eu tenho que declarar o meu target port o Que que é o target port o target port é a porta que eu vou

acessar do meu pod porque se você reparar aqui ó o meu pod ele utiliza a porta 8080 ele tá utilizando a porta 8080 aqui do meu pod mas eu tô utilizando a porta 80 no service então eu vou bater na porta 80 do Service por padrão se eu não coloco o target port ele vai pra porta 80 também do meu pod não vai funcionar porque eu tô utilizando a 8080 então o target port ele faz esse Redirecionamento ó target port coloco aqui 80 80 beleza então beleza Tá declarado aqui o meu o meu service agora

eu venho aqui e executo Cub CTL apply Men F k8s deployment executo Ok á e criou você vê que aqui ó como o deployment ele já foi criado ele não faz nada á el fala ó unchanged esse objeto aqui ele não foi alterado agora tem um service aqui não não tem nada dele aqui criado ainda ele vai criar então eu vou vir aqui agora ó Cub CTL get pod tá tudo aqui Cub CTL get service Opa faz certo que dá certo vamos lá Cub CTL get service tá lá ó agora eu tenho aqui o meu

Service do tipo node port E aí repara que ele tem aqui ó o uso da porta 80 Foi a que eu declarei para utilizar o http e aqui ele do lado ele tem aqui a porta 32 418 lembra que eu falei que toda vez que eu crio um Service do tipo node port ele pega uma das portas que tão naquele Range de 30.000 A 32.767 então aqui no caso ele pegou 32.41 então para eu acessar aqui agora essa minha aplicação eu tenho que pegar o IP do nó de uma das máquinas do meu cluster kubernetes

e acessar ali tranquilamente Mas aqui tem um detalhe importante eu não tô trabalhando aqui num ambiente on prem onde eu tenho as minhas máquinas virtuais eu tô trabalhando com ambiente local que eu tô utilizando aqui o k3d com o com eu tô utilizando aqui o ambiente Criado com k3d onde eu não tenho máquinas eu tenho contêiners docker que representam essas máquinas então eu não tenho como acessar diretamente ali o cont utilizando um IP E aí nesse cenário eu tenho que fazer algumas alterações primeiro eu vou ter que recriar o meu cluster kubernetes com o k3d

Então vou vir aqui e vou executar o k3d cluster list primeiro ó vou deletar esse cluster executando aqui o comando k3d cluster delete E aí eu vou esperar Aqui ele deletar Vou botar aqui ó meu cluster o nome aqui do cluster e vou esperar ele deletar aqui ó ele deletou o cluster kubernetes e eu vou criar esse cara de novo então vou vir aqui ó k3d cluster Create meu cluster vou botar aqui o servers 3 botar aqui o Agents 3 e vou recriar esse cara mas eu vou fazer um seguinte aqui aqui tem um detalhe

muito importante eu vou agora eh utilizar um recurso aqui do k3d que é muito parecido com o recurso do docker De port bind de publish de porta onde eu vou e vincular uma porta aqui da minha máquina local né da do meu desktop com a porta de um dos contêiners do cluster kubernetes que vai ser criado e aí dessa forma o que que eu vou fazer eu ao invés de ter que acessar pelo IP de um dos contêiners Eu vou acessar direto local host da minha máquina porque eu vou ter feito esse vínculo de porta

certo então eu vou utilizar aqui o Men P que é igualzinho a gente fez lá com o Dock e Vou fazer aqui a mesma coisa vou pegar uma porta da minha máquina local eu no caso vou utilizar aqui a 30.000 certo que é a primeira porta lá do node port e vou vincular com a porta 30.000 de um dos contêiners que vai ser criado aqui com o k3d e para me ajudar aqui a escolher qual contêiner eu vou utilizar realmente eu posso botar aqui logo em seguida ó um ar e definir qual vai ser o

contêiner que no caso aqui eu vou botar o load balancer Ou seja eu vou Vincular com a porta e do contêiner que vai agir como load balancer como ele faz o balanceamento de carga com todos os outros contêiners com todas as outras máquinas aqui do meu cluster ele vai fazer o balanceamento para mim também automaticamente entre a as máquinas os nós do cluster executo aqui ele vai fazer todo o processo de criação de novo De novo esse processo demora um pouquinho vamos esperar eu vou cortar pro momento que ele termina show de bola Aqui ó

ele terminou a cria aqui do cluster kubernetes E agora se a gente olhar aqui nos contêiners que ele criou docker container LS aqui ó eu tenho esse port bind feito aqui né com o coner que tá atuando como load balance Beleza agora eu posso executar aqui de novo ó Cub CTL apply - F k8s deployment beleza executo aqui agora ó Cub CTL get All para ver aqui tudo ó ele tá criando inclusive ele criou aqui o meu service Só que tem um ponto muito importante Ele Criou só que ele aqui ó ele tá utilizando a

porta 31.79 Pô cara já era botei para ele fazer o bind com a porta 30.000 que que eu vou fazer né tem um ponto aqui que eu eu posso fazer tem uma alteração que eu posso fazer aqui para me ajudar eu posso vir aqui no Manifesto e colocar aqui ó na mão para ele utilizar uma porta específica como node port eu posso botar aqui direto o 3.000 e ele vai começar a utilizar o 30.000 é importante o Seguinte eu não recomendo que você faça isso na mão sempre tá e eh só em casos como esse

aqui em que a gente tá rodando o ambiente local E aí não tem jeito Tem que fazer mesmo é e também é importante você não utilizar a mesma porta em dois Services diferentes que aí vai ter conflito de porta ele não vai criar uma delas então levando isso em consideração pode usar sem problema nenhum vamos lá agora Cub CTL apply Men F k8s deployment aplico aqui ele vai fazer Ali a alteração para mim ó lá beleza ó ele não alterou o deployment porque não teve alteração ah ó agora ele alterou o service Se eu vir

aqui agora Cub CTL get All vamos lá tá aqui vamos lá vai meu filho ah lá agora sim tá aqui ó ele agora tá com a porta 30.000 e aí eu consigo acessar e na verdade ele tá criando aqui os contêiners né o processo às vezes demora um pouquinho deixa ele terminar lá agora já tá com tudo em execução então se eu vir aqui agora e Vir em local host e botar aqui é 30.000 certo ele vai Ah lá ó acessar aqui a minha aplicação só que se eu vir aqui e for atualizando for fazendo

aqui o refresh ele também vai intercalando aqui para mim se eu vir aqui ele vai mudar em alguns momentos deixa eu pegar aqui criar uma aba anônima deixa eu pegar aqui ah lá criei aqui uma aba anônima Vou botar aqui ó ah lá ele já pegou um um host diferente ele pegou aqui um endereço diferente ó lá e Ele vai intercalando conforme eu vou abrindo aqui ele vai intercalando entre as instâncias então eu tenho agora o ponto único de acesso utilizando service ele também vai fazer esse Balan para mim agora eu quero mostrar aqui para

você um último recurso que é a atualização da aplicação Quero mostrar para você o processo de atualização aqui dessa aplicação eu vou fazer aqui agora o seguinte então eu vou executar aqui né uma alteração no meu código certo vou Botar aqui Ah deixa eu ver aqui emvs vou mudar aqui o cabeçalho onde tá lá o host eu vou botar aqui ó no caso conversão temperatura V2 Ok e vou subir aqui essa nova versão deixa eu entrar lá em src e executar docker build Men T Fabrício Veronez barra conversão temperatura Temper e botar aqui né no

caso V2 E aí eu vou botar aqui mais uma Flag que é a Flag push para ele já construir e subir Também junto e eu vou botar aqui o contexto para ele subir aqui para mim a imagem então executo aqui ele vai subir para mim como eu tô utilizando aqui e o docker file no mesmo diretório e com o padrão do nome docker file eu não preciso passar o menos F eu não preciso passar ali o o caminho do docker file ele já pega por padrão então eu vou construir aqui ele vai demorar um pouquinho

deixa ele terminar aqui ó ele Terminou de subir a imagem se eu vir aqui agora abrir aqui o Dock conversão temperatura atualizar vamos lá ó eu tenho aqui V2 agora eu vou vir aqui no meu V code e eu vou mudar aqui a versão da minha aplicação Ó tem conversão temperatura v1 eu vou botar aqui V2 E aí eu vou aplicar essa alteração e vamos ver o que que vai rolar então volto aqui pro meu terminal e eu vou executar aqui Cub CTL apply - F k8s bar Deployment só que agora eu junto com esse

comando eu vou executar aqui combinado o comando watch que vai fazer aqui um refresh nos comandos no comando e vai fazer um refresh aqui no output E aí o comando que aí vai ficar atualizando aqui constantemente vai ser o Cub CTL get pod E aí você vai ver que ele vai fazer toda a troca aqui dos meus Pods ó lá criando aqui novos Pods com a nova versão da minha aplicação e eliminando os Pods antigos Gradativamente e a minha aplicação ela não tem downtime se eu atualizar aqui ó ó lá eu não tô tendo downtime

da minha aplicação mas ele tá aqui ó fazendo esse processo de atualização ele tá aqui né demorando um pouquinho porque ele tá baixando a imagem né Então depende da onde você tiver executando vai ser mais rápido vai ser mais lento mas aqui ó já terminou aqui de encerrar o pos ele tá executando aqui os novos Pods com as novas com a nova versão E aí quando Esses caras aqui tiverem execução esses outros três aqui vão ser eliminados também gradativamente mas enquanto isso ó minha aplicação tá rodando ó inclusive ó já tá aqui ó V2 ó

esse aqui já tá rodando Esse aqui também então ele já começou aqui ó a eliminar os outros até eu ter aqui quatro réplicas só com a nova versão da minha aplicação ó lá V2 tá aqui ó funcionando corretamente então eu consigo fazer a troca de versão da minha aplicação utilizando aqui o Kubernetes e nativamente já tem isso por padrão ele faz essa troca de versão dessa forma utilizando eh aqui o os recursos do próprio kubernetes tem outras estratégias para se fazer também can deployment Blue Green e tal mas são tópicos mais avançados Eu nem vou

falar sobre isso aqui na na nossa semana mas cara eu consegui rodar aqui a minha aplicação atualizar sem downtime E se a gente olhar aqui ele aqui agora tá criando Beleza mas se a gente olhar aqui Agora Cub CTL get replica 7 eu tenho aqui os dois repc set o antigo com a versão um e e aqui o novo com a versão mais nova e eu posso fazer aqui o rollout né posso fazer ou melhor posso fazer aqui o rollback também com apenas um comando posso voltar a versão com um comando Só se eu vir

aqui agora Cub C rout History deployment Opa deployment Conversão temperatura eu consigo ver aqui ó o histórico de criação aqui da minha aplicação tenho aqui ó a versão um e a dois se eu vir aqui agora CG rollout andu deployment conversão temperatura e aí eu coloco aqui e de novo o Cub CTL get Pods eu vou ver aqui o rollback Á Ele vai matar agora as versões mais recentes e vai voltar com a versão um e vai reabilitar aquele réplica 7 anterior e o outro vai est ali Inativo se eu atualizar aqui agora ah lá

eu tô com a versão um de novo da minha aplicação ele vai fazer aqui todo o processo de novo aí já inclusive já tá com os quatro rodando tá aqui com os outros só só terminando se eu vir aqui agora Club CTL get RCA 7 ó lá ó aqui o mais antigo ele tá habilitado né E tá ativo e o outro tá Aqui Inativo se eu voltar aqui a versão botar dois ele vai voltar aqui eh com esse RCA set Então dessa forma eu consigo fazer o Deploy da minha aplicação no kubernetes garantindo escalabilidade resiliência

e fazendo a troca de versão da minha aplicação utilizando as práticas do kubernetes 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 uma Aplicação cada vez mais escalável e confiável tanto que no devops pro nossos alunos possuem um módulo extenso de kubernetes destrinchando cada detalhe dessa ferramenta que é fantástica por exemplo Imagina que uma ação tá com um pod consumindo muito recurso e comprometendo ali 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 esse problema Outro ponto Importante como eu faço para definir quantas máquinas e qual as configurações necessárias para criar o seu kubernet Pois é eu também mostro isso e outros detalhes que garantem segurança na hora de trabalhar e principalmente Como utilizar essa ferramenta fantástica da melhor maneira possível enfim são muitas as funcionalidades e você deve se aprofundar nele porque isso muda o jogo da sua carreira mas agora que você já conhece os fundamentos básicos para se Ter o Deploy de uma aplicação no kubernetes a

gente pode avançar porque até agora o objetivo era fazer você entender os principais conceitos de docker e kubernetes com cenários simples agora a parada vai começar a esquentar porque nós vamos de fato iniciar os trabalhos aqui colocando a aplicação desse evento para rodar e a gente vai fazer isso direto em um ambiente de nuvem então na próxima aula eu vou te mostrar como criar um cluster kubernetes No e um dos principais Cloud providers do mercado você vai ver que rodar sua aplicação na nuvem é bem mais simples do que você imagina e vai entender também

porque esse é o ambiente mais escolhido pelas grandes empresas do mercado vai até se perguntar porque não estudou isso antes é sério cara você vai ver então não perde a próxima aula eu te vejo lá