Kubernetes: como usá-lo para gerenciar suas aplicações

Oi, pessoa! Vamos entender como o Kubernetes pode nos ajudar no gerenciamento de aplicações em containers?

Imagine um cenário em que suas aplicações rodem em containers presentes numa única máquina.

No início, isso funciona super bem. Porém, à medida que a demanda referente às aplicações cresce, você adiciona mais containers, aproveitando ao máximo os recursos dessa máquina.

Consequentemente, ela chega ao seu limite e começa a ficar lenta, reiniciar inesperadamente e até mesmo falhar, impactando diretamente no desempenho das aplicações.

Nessa situação, uma solução comum seria comprar uma máquina mais potente, certo? No entanto, isso resolveria o problema apenas temporariamente. Com o passar do tempo, até mesmo essa máquina nova chegaria ao seu limite.

Além de todo esse processo ser financeiramente custoso, ficaria cada vez mais complicado adicionar mais máquinas e gerenciar manualmente a distribuição dos containers entre elas.

É aqui que entra o Kubernetes. Em vez de você precisar gerenciar a compra de máquinas com mais recursos e ainda gerenciar a alocação dos recursos manualmente, o Kubernetes coordena automaticamente a distribuição de containers entre várias máquinas.

Dessa forma, garantimos que tudo funcione corretamente e sem interrupções, mesmo diante de falhas ou de alta demanda, aumentando a confiabilidade e disponibilidade de suas aplicações.

Neste artigo, vamos explorar:

• O que é Kubernetes e para que serve;
• As principais funcionalidades;
• Conceitos essenciais da ferramenta;
• KubeCon;
• Containers no Kubernetes;
• Kubernetes vs Docker;
• Componentes do Kubernetes;
• Benefícios do Kubernetes;
• Seu primeiro projeto com Kubernetes.

Então, aperte o cinto e vamos nessa!

O que é Kubernetes e para que serve?

Kubernetes, palavra que em grego significa timoneiro ou piloto, tem esse nome por um motivo. Assim como um piloto é responsável por guiar através de diferentes condições e manter tudo em curso, o Kubernetes faz algo parecido.

Ele orquestra containers, ajudando a lidar com aplicações que podem ser compostas por centenas deles, e permite gerenciar esses containers em diferentes ambientes, como máquinas físicas, virtuais, ambientes na nuvem ou em configurações híbridas.

Containers são como unidades de software independentes que contêm tudo o que é necessário para executar uma aplicação: o código, as bibliotecas do sistema, as dependências e as configurações.

Podemos pensar nos containers como "caixas" que empacotam aplicações e suas dependências, garantindo que elas funcionem de maneira consistente em qualquer ambiente, seja no notebook, em um servidor de teste, em um link da internet ou até mesmo no celular.

O Kubernetes também facilita:

• o deploy de aplicações,
• a realização de atualizações,
• o ajuste do tamanho das aplicações conforme a demanda,
• o monitoramento do desempenho,
• e mais!

Isso torna o gerenciamento de aplicações muito mais fácil, fazendo com que elas se adaptem rapidamente às mudanças e continuem funcionando sem interrupções. Muito bom, né?

Quais são as principais funcionalidades do Kubernetes?

Quando a nossa aplicação começa a crescer e precisamos rodar em múltiplos containers, surge a necessidade de garantir que tudo funcione de maneira fluida, sem sobrecargas e sem que as pessoas usuárias sejam afetadas por falhas.

O Kubernetes brilha justamente nesse ponto: ele automatiza o gerenciamento dos containers e proporciona várias funcionalidades que tornam esse processo mais tranquilo.

Bora lá conferir essas funcionalidades?

Orquestração de armazenamento

O Kubernetes automatiza a integração com sistemas de armazenamento locais e na nuvem, o que facilita o uso e a organização dos dados.

Essa tecnologia é muito utilizada para gerenciar o armazenamento de imagens em um serviço de nuvem como o Amazon S3, enquanto mantém os dados transacionais em um banco de dados local.

Assim, há a garantia de que ambos os tipos de dados estejam sempre disponíveis e sincronizados para todas as instâncias da aplicação.

Lançamentos e reversões automatizadas

O Kubernetes permite definir o estado ideal para os nossos containers e faz as alterações necessárias para atingir esse estado de forma controlada.

Isso significa que ele pode automatizar a criação de novos containers, remover antigos e transferir todos os recursos, garantindo que a transição seja suave e sem interrupções.

E caso algo dê errado, é possível reverter para uma versão anterior e manter tudo funcionando corretamente.

Por exemplo, ao lançar uma nova versão de um aplicativo, o Kubernetes pode implantar gradualmente a atualização, testando-a com um pequeno grupo de pessoas usuárias antes de expandi-la para toda a base.

Se forem detectados problemas, ele pode reverter automaticamente para a versão anterior, minimizando o tempo de inatividade.

Empacotamento automático

Com o Kubernetes, podemos informar ao sistema a quantidade de CPU e memória (RAM) que cada container precisa e ele se encarrega de distribuir esses containers pelos nós disponíveis.

Assim, ele organiza as tarefas de modo que os recursos de seu cluster sejam aproveitados da melhor maneira possível, evitando desperdícios e maximizando o uso das máquinas.

Isso é muito utilizado em plataformas de streaming de vídeo, por exemplo, onde o Kubernetes pode alocar mais recursos para os servidores durante horários de pico de acessos, e reduzir esses recursos durante períodos de baixo uso, otimizando custos e desempenho.

Autorrecuperação

O Kubernetes monitora os containers e age automaticamente ao detectar falhas, reiniciando ou substituindo aqueles que apresentarem problemas.

Em um sistema de monitoramento de saúde, como de registro e acompanhamento de sinais vitais de pacientes em tempo real em hospitais e UTIs, por exemplo, é crucial garantir a continuidade, precisão e segurança dos dados sensoriais.

Se um container responsável por processar dados de sensores falhar, o Kubernetes pode detectar isso e iniciar um novo container automaticamente, garantindo que nenhum dado crítico seja perdido.

Gerenciamento de segredos e configurações

O Kubernetes armazena e gerencia dados sensíveis, como senhas e tokens, de maneira segura e sem precisar reconstruir os containers.

Em aplicações financeiras essa funcionalidade tem alto impacto, pois o Kubernetes pode gerenciar as credenciais de acesso a diferentes APIs de processamento de pagamento, permitindo que essas credenciais sejam atualizadas sem necessidade de reimplantar a aplicação.

Descoberta de serviço e balanceamento de carga

Quando há um aumento repentino no tráfego, o Kubernetes cuida de redistribuir esse tráfego entre os containers para que a aplicação continue estável.

Durante a Black Friday por exemplo, uma época de alta demanda para várias empresas, o Kubernetes pode automaticamente escalar os serviços de carrinho de compras e checkout, distribuindo o tráfego entre múltiplas instâncias para manter o tempo de resposta baixo, mesmo com milhares de usuários simultâneos.

Muita informação e sopa de letrinhas, né? Mas calma! A seguir, vamos entender mais sobre sobre orquestração de containers e como essas tecnologias podem facilitar seu trabalho.

Kubernetes 101 – principais conceitos

"101" (one oh one), em inglês, é uma forma divertida de indicar a introdução a um tema, ou seja, que falaremos sobre seus principais conceitos.

Agora que você já entende o que é o Kubernetes e como ele facilita o gerenciamento das aplicações em containers, vamos mergulhar nos principais conceitos que tornam essa tecnologia tão popular e utilizada no mercado, conforme podemos conferir nesta pesquisa de 2023 do Stack Overflow.

Bora lá explorar as ideias de cluster, nó, Pod e outros, para você ter um panorama claro sobre como cada peça se encaixa nesse grande quebra-cabeça da orquestração de containers?

Cluster

Um cluster no Kubernetes funciona como uma equipe organizada, executando aplicações em containers.

Ele é formado por várias máquinas, sejam físicas ou virtuais, sendo que o Master Node (ou nó mestre) coordena as atividades, enquanto os Worker Nodes (ou trabalhadores) são responsáveis por executar as aplicações.

Imagine que há um grupo de servidores rodando a mesma aplicação. Se um deles falhar, isso pode causar interrupções e frustrações para as pessoas usuárias.

A solução é utilizar clusters, pois eles permitem que, mesmo em caso de falhas, outros nós assumam as funções necessárias, evitando que o serviço fique fora do ar.

Nó

No Kubernetes, cada máquina física ou virtual é chamada de nó. Um nó pode ser um servidor local ou uma instância na nuvem, e ele é responsável por rodar os pods, que são unidades compostas por um ou mais containers.

Cada nó inclui componentes essenciais como o kubelet, que garante que os containers estejam rodando corretamente, o runtime de containers (como Docker ou containerd) para gerenciar os containers, e o kube-proxy, que controla as regras de rede para permitir a comunicação dentro e fora do cluster.

Se um nó falhar ou ficar indisponível, o Kubernetes redistribui automaticamente os pods daquele nó para outros disponíveis, mantendo a alta disponibilidade e o funcionamento contínuo da aplicação. Essa redistribuição é controlada pelo control plane, que monitora a saúde e o status de cada nó no cluster.

Container em nuvem

Um container em nuvem é uma imagem que contém o software e suas dependências. Eles permitem empacotar aplicações de maneira que possam ser executadas em diferentes plataformas, como AWS, Azure ou Google Cloud.

Essa abordagem facilita a escalabilidade das aplicações e simplifica o gerenciamento, já que não é necessário lidar com servidores individuais, mas sim com containers que podem ser replicados com facilidade.

Pod

Dentro do Kubernetes, o Pod é a menor unidade de execução. Ele pode conter um ou mais containers que compartilham recursos como rede e armazenamento. Essa estrutura faz com que containers que trabalham juntos possam se comunicar e operar de maneira mais fluida.

A imagem abaixo ilustra a relação entre Pods, nós e containers em um cluster Kubernetes. Observe que cada nó pode hospedar um ou mais Pods, enquanto, como comentamos, cada Pod pode conter um ou mais containers.

Implementação (Deployments)

Para gerenciar como as aplicações são executadas, o Kubernetes utiliza implementação (ou deployment), que fornece atualizações declarativas, gerencia o estado desejado dos Pods e assegura que o número correto de réplicas esteja sempre em execução, facilitando atualizações e reversões contínuas.

ReplicaSet

O ReplicaSet complementa o Deployment, assegurando que um número específico de réplicas de um Pod sempre esteja ativo.

Se um Pod falhar ou for removido, o ReplicaSet cria automaticamente novos Pods para garantir que o número adequado de instâncias continue a rodar.

Serviço

O serviço (ou service) é uma abstração que expõe as aplicações em um ou mais Pods e possibilita a comunicação entre eles, fornecendo um IP fixo que não muda. Os serviços também proveem um DNS que ajuda na comunicação entre Pods.

Por exemplo, se tivermos uma aplicação web rodando com várias réplicas em diferentes Pods, o Kubernetes cria um serviço que recebe todas as requisições dos clientes e as direciona para os Pods disponíveis.

Mesmo que os novos Pods sejam criados ou antigos sejam removidos, o cliente sempre se conecta ao mesmo IP ou DNS fornecido pelo serviço.

Como tudo se conecta

Exploramos os principais componentes do Kubernetes, mas você pode estar se perguntando: como eles trabalham juntos?

O fluxo funciona assim:

• Você cria um Deployment para sua aplicação web.
• O Deployment cria um ReplicaSet.
• O ReplicaSet cria os Pods necessários.
• Os Pods são distribuídos entre os Nós disponíveis.
• Um Serviço é criado para expor esses Pods.
• Se um Pod falha, o ReplicaSet cria um novo automaticamente.
• Se você atualiza o Deployment, ele cria um novo ReplicaSet e gradualmente move o tráfego para os novos Pods.

Dessa forma, o Kubernetes automatiza muitas das tarefas de gerenciamento de aplicações, permitindo que você foque no desenvolvimento e na lógica de negócios em vez de se preocupar com a infraestrutura — que, ao usar o Kubernetes, fica disponível 24/7.

Características de containers do Kubernetes

Já entendemos o básico sobre containers, e agora vamos nos aprofundar um pouco mais.

Primeiramente, devemos entender que os containers são isolados. Ou seja, eles não dependem diretamente do ambiente em que estão sendo executados, seja em máquinas físicas, virtuais, nuvem ou ambientes híbridos.

Isso faz com que o gerenciamento de aplicações seja mais simples porque elas não ficam presas à infraestrutura base.

Imagine que temos uma aplicação web desenvolvida com Python 3.8. Quando empacotada em um container, essa aplicação pode ser executada:

• no notebook de uma pessoa desenvolvedora rodando Windows;
• em um servidor Linux no data center da empresa;
• em uma instância EC2 da AWS;
• em um cluster Kubernetes no Google Cloud.

E em todos esses ambientes, a aplicação vai funcionar de maneira idêntica, pois o container inclui o Python 3.8 e todas as bibliotecas necessárias.

Isso traz benefícios como portabilidade, já que facilita a movimentação de aplicações entre diferentes ambientes, além de acabar com o “Mas na minha máquina ‘tá rodando” ;).

Imagens de container

Já as imagens de container são pacotes prontos para uso que contêm o código da aplicação e tudo o que ela precisa para rodar corretamente.

Ao criar ou modificar uma aplicação, o processo ideal é construir uma nova imagem e, em seguida, reiniciar o container a utilizando. Isso garante que o container permaneça estável e previsível ao longo de seu ciclo de vida.

Outro ponto importante é usar tags específicas para versionar as imagens, como minha-app: v1.2.3, evitando o uso da tag latest, porque ela pode levar a inconsistências – uma vez que a tag latest sempre aponta para a última imagem enviada para o repositório, mas não garante uma versão fixa.

Runtimes de container

Outro ponto importante é o runtime de container, responsável por gerenciar a execução e o ciclo de vida dos containers no Kubernetes. Ele cuida para que os containers sejam iniciados, monitorados e finalizados conforme necessário.

Alguns exemplos de runtimes compatíveis com o Kubernetes são:

• containerd: runtime que cuida do ciclo de vida de um container, é leve e focado em desempenho e simplicidade;

• CRI-O: uma alternativa leve ao uso do Docker como runtime para Kubernetes, pois permite a execução de containers sem a necessidade de muitas ferramentas externas.

Imutabilidade dos containers

Os containers são projetados para ser imutáveis. Isso significa que uma vez em execução, o código dentro do container não deve ser alterado.

Se for preciso atualizar ou corrigir algo, a prática recomendada é criar uma nova imagem com essas modificações e reiniciar o container.

As vantagens da imutabilidade incluem:

• previsibilidade, porque garante um comportamento estável em diferentes ambientes;
• segurança, pois minimiza a superfície de ataque ao impedir modificações em tempo de execução;
• facilidade de reversão (ou rollback), pois voltar para uma versão anterior se torna tão simples quanto implantar a imagem anterior.

Entender essas características fundamentais dos containers - isolamento, imagens, runtimes e imutabilidade - é essencial para trabalharmos de forma adequada com Kubernetes, pois esses conceitos foram a base para desenvolver aplicações resilientes, escaláveis e simples de gerenciar.

Kubernetes versus Docker

Quando falamos de Kubernetes e Docker, é comum pensar que estamos diante de uma escolha entre um e outro.

No entanto, essas tecnologias são diferentes e trabalham em harmonia para executar aplicativos conteinerizados.

A partir do momento em que começamos a utilizar o Docker para organizar nossas aplicações, surge a necessidade de gerenciá-las de forma eficaz.

Então, o Kubernetes entra em cena – não como uma alternativa ao Docker, mas como um complemento.

O Kubernetes pode ser utilizado independentemente do Docker, mas a combinação das duas tecnologias proporciona uma gestão sólida e escalável para aplicações em containers.

Enquanto o Docker se destaca no empacotamento e distribuição de aplicativos, o Kubernetes se especializa na orquestração, gestão e escalonamento desses containers.

Para resumir, a tabela abaixo reúne as principais diferenças e complementos entre essas duas tecnologias:

Importância e benefícios do Kubernetes

Já aprendemos bastante sobre o Kubernetes até aqui e, com base em tudo isso, pode-se dizer que ele tem sido uma peça chave na operação de sistemas, principalmente com o aumento das aplicações distribuídas e da necessidade de gerenciar múltiplos containers.

Mas como ele pode ser importante para o dia a dia de desenvolvimento? Vamos conferir alguns de seus benefícios:

• Adoção de microsserviços: com o crescimento da arquitetura de microsserviços, o Kubernetes passa a desempenhar um papel importante gerenciando partes de uma aplicação que funcionam independentemente. Ele organiza e coordena esses diferentes serviços, permitindo que tudo opere em conjunto sem grandes dificuldades.

• Eficiência operacional: uma das grandes vantagens do Kubernetes é a capacidade de automatizar tarefas que antes demandavam muito esforço manual. Ele simplifica a implantação de novas versões de software e diminui o tempo de resolução de problemas.

• Comunidade ativa: a comunidade é composta por pessoas desenvolvedoras do mundo inteiro, que estão sempre aprimorando e criando novas ferramentas para o ecossistema. Isso é sinônimo de constante inovação e suporte.

• Padronização: o Kubernetes também se tornou um padrão confiável para orquestração de containers, facilitando assim a colaboração entre equipes e adoção das melhores práticas.

• Escalabilidade: com o Kubernetes, as aplicações podem crescer ou diminuir automaticamente, ajustando o número de réplicas conforme a demanda. Isso ajuda a garantir que os recursos sejam usados conforme necessário, sem desperdícios ou falta de capacidade.

• Gerenciamento de containers: o Kubernetes facilita o gerenciamento de containers, orquestrando a implantação, atualização e monitoramento de aplicações containerizadas.

• Alta disponibilidade: manter as aplicações sempre no ar é uma prioridade e o Kubernetes ajuda nessa tarefa, pois direciona automaticamente o tráfego para instâncias saudáveis e reinicia containers que falham.

Quais os principais desafios de usar Kubernetes?

Nem tudo são flores! Usar Kubernetes pode ser super empolgante, mas também traz alguns desafios para quem está começando e até para quem já tem experiência com essa tecnologia.

O principal desafio é a sua curva de aprendizagem e os diversos termos específicos, como Pods, services, cluster e assim por diante. É como aprender uma nova língua de tecnologia – mas é claro que, com prática e paciência, tudo começa a fazer sentido.

Fora isso, o escalonamento de aplicações pode resultar em um aumento considerável de custos se não for bem gerido.

Outro fator importante a considerar é que o Kubernetes não implanta código-fonte e não constrói a aplicação — ele lida com containers.

Isso significa que, se você precisar de funcionalidades como registro de logs, monitoramento e configuração, será necessário integrar outras ferramentas ao seu ambiente.

Isso pode parecer um pouco assustador, mas o Kubernetes tem uma alta capacidade de expansão, permitindo sua aplicação em diversas áreas, desde de aviões a jato – como descrito nesta matéria da O3S sobre o uso de Kubernetes pela Força Aérea Americana –, até experimentos com aprendizado de máquina.

O que é a KubeCon?

A KubeCon é um evento anual que reúne pessoas desenvolvedoras e usuárias do Kubernetes em um grande encontro para trocar ideias e aprendizado, além de ser o lugar perfeito para descobrir as novidades que estão rolando no mundinho Kubernetes.

Desde que estreou em 2015, com 500 participantes, o evento cresceu e se tornou um ponto de encontro para a comunidade.

Participar de eventos como a KubeCon é ótimo para entrar em contato com quem está passando pelas mesmas experiências que você, encontrar respostas para problemas e também construir conexões valiosas para a sua carreira.

A cada ano o público aumenta e você pode conferir informações sobre o evento na página da KubeCon.

Criando seu primeiro deployment no Kubernetes

Agora chegou o momento de colocar em prática o que aprendemos e conhecer os principais comandos do Kubernetes.

Para isso, vamos criar um deployment que conterá um Pod com um container que exibirá uma mensagem genérica, como "Hello, world", em um servidor web. Vamos lá?

Pré-requisitos

Antes de começarmos, você precisará de algumas ferramentas instaladas na sua máquina:

• Docker: para criar e gerenciar containers;
• kubectl: a ferramenta de linha de comando do Kubernetes;
• Minikube: um ambiente local para criar clusters do Kubernetes.

Criando o arquivo YAML

No Kubernetes, os objetos são definidos em arquivos no formato YAML. Cada objeto tem uma estrutura hierárquica baseada em indentação, o que facilita a leitura e compreensão, por ser mais amigável à pessoa usuária.

A principal vantagem desse formato é a simplicidade e a organização dos dados, onde cada linha define uma chave ou valor.

Se quiser saber mais sobre melhores práticas de configuração, acesse a documentação do Kubernetes.

Vamos começar!

Primeiro, criaremos uma pasta chamada “hello-world” na área de trabalho e a abriremos no nosso editor de código.

Em seguida, vamos criar um arquivo chamado hello-world-deployment.yaml, contendo as seguintes configurações:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-world-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: hello-world
  template:
    metadata:
      labels:
        app: hello-world
    spec:
      containers:
      - name: hello-world
        image: nginx:latest
        ports:
        - containerPort: 80

Definimos alguns valores importantes nesse arquivo. Vamos conferir o que cada um deles significa:

• apiVersion: define a versão da API do Kubernetes que estamos utilizando;
• kind: especifica que estamos criando um Deployment;
• metadata: inclui informações sobre o Deployment, como o seu nome no exemplo acima;
• spec: especificação do Deployment;
• replicas: número de cópias (pods) que queremos rodar;
• selector: como o Kubernetes identifica os pods gerados por esse Deployment;
• template: define a estrutura do pod – no exemplo, especificamos o container que usará a imagem nginx:latest e irá expor a porta 80.

Além disso, precisaremos criar um arquivo chamado hello-world-service.yaml, contendo o código abaixo. Esse arquivo será responsável por expor o pod criado, permitindo que ele seja acessível via navegador:

apiVersion: v1
kind: Service
metadata:
  name: hello-world-service
spec:
  selector:
    app: hello-world
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: LoadBalancer

Iniciando o serviço

Com os arquivos criados, vamos iniciar o serviço. Para isso, abrimos o terminal – recomendamos o Power Shell, mas você pode usar o terminal de sua preferência – e executamos o comando abaixo:

minikube start --no-vtx-check

Esse comando pode levar alguns minutos para ser concluído, pois ele é responsável por criar o nosso cluster. Aproveite para tomar um cafezinho enquanto isso.

Se tudo der certo, a mensagem “Done! kubectl is now configured to use ‘minikube’” aparecerá na tela.

Feito isso, navegamos pelo terminal até a pasta em que criamos os arquivos YAML e rodamos o comando abaixo para criar os recursos definidos no arquivo de configuração:

kubectl apply -f hello-world-deployment.yaml

Feito isso, devemos receber uma mensagem confirmando que o deployment foi criado!

Após aplicar o arquivo, o Kubernetes criará o pod com base na especificação. Você pode verificar se o pod está rodando com o comando abaixo:

kubectl get pods

Abrindo a aplicação no navegador

Finalmente, para acessar o nosso "Hello, World" via navegador, vamos expor o pod criando um serviço. Para isso, executamos:

kubectl apply -f hello-world-service.yaml

Depois precisamos rodar o comando abaixo para obter o endereço de IP para acessar a aplicação:

minikube service hello-world-service

Quando executamos esse comando, uma tabela será exibida no terminal, com algumas especificações do serviço em inglês. Esse comando também abrirá automaticamente a página do Nginx no navegador, confirmando que a aplicação está rodando.

Muito legal, né?

Dashboard e outros comandos

Uma curiosidade é que é possível acessar um dashboard do Kubernetes para verificar a situação dos containers, Pods, ReplicaSets e assim por diante. Podemos fazer isso com o seguinte comando:

minikube dashboard

Outros comandos que podem ser úteis no seu dia a dia usando Kubernetes são:

• kubectl describe: esse comando mostra detalhes completos sobre um recurso específico no cluster. Ele é útil para entender o que está acontecendo com o pod ou deployment.

kubectl describe pod <nome-do-pod>
kubectl describe deployment <nome-do-deployment>

• kubectl delete: se precisamos remover algum recurso do cluster, como pods, serviços ou deployments, rodamos esse comando.

kubectl delete pod <nome-do-pod>
kubectl delete service <nome-do-service>
kubectl delete deployment <nome-do-deployment>

• kubectl logs: esse comando é usado para visualizar os logs gerados por um container em um pod. É muito útil para verificar o que está acontecendo na aplicação e encontrar problemas.

kubectl logs <nome-do-pod>

Como começar a estudar Kubernetes

Agora que já falamos sobre o que é Kubernetes, suas principais vantagens e desafios, chegou a hora de você dar um mergulho profundo para aprender mais.

Abaixo, listamos algumas dicas de conteúdos que vão te ajudar a entender desde o básico até as práticas mais avançadas do Kubernetes:

• Formação: Orquestração de containers com Kubernetes: nessa formação você irá explorar como gerenciar containers de forma simples e automatizada, além de aprender a configurar um ambiente local do zero. Essa formação é ideal para quem busca entender o potencial do Kubernetes.

• Formação: Microsserviços com Kubernetes: já nessa formação, você vai aprender a gerenciar microsserviços de maneira mais prática e conseguirá entender as diferenças entre aplicações monolíticas e microsserviços.

Agora é com você!

Aprendemos bastante sobre Kubernetes nesse artigo! Agora, que tal colocar a mão na massa?

Crie seu próprio deployment no Kubernetes e confira-o rodando no seu navegador. Faça o teste com os arquivos YAML, siga os comandos e depois nos conte como foi a experiência.

Ao postar seu progresso nas redes sociais, marque os perfis da Alura e use a hashtag #AprendiNaAlura. Ficaremos felizes em conferir seus resultados!

Referências

• Kubernetes Documentação (inglês, gratuito, site): documentação completa e atualizada do Kubernetes;

• Containers, Docker e Kubernetes (português, gratuito, youtube): vídeo sobre o uso de Containers e de plataformas Open Sources como Docker e Kubernetes que são cada vez mais usadas no universo tech;

• Kubernetes 101: A beginner’s guide to container orchestration (inglês, gratuito, site): uma introdução ao mundo do Kubernetes e seus componentes;

• O que é o Kubernetes? (português, gratuito, site): artigo rápido da Google Cloud sobre Kubernetes;

• Kubernetes in a Nutshell: A Comprehensive Guide to Getting Started (inglês, gratuito, site): artigo que cobre os principais conceitos, funcionalidades e como começar a usar Kubernetes.