Kubernetes: orquestrar aplicações, escalabilidade e segurança

Fundamentos e Arquitetura do Kubernetes - Introdução

Apresentando o instrutor e sua experiência

Olá! Sejam todos bem-vindos ao curso de Kubernetes Fundamentos. Meu nome é Felipe Santos e sou Staff DevOps. Atualmente, tenho 20 anos de carreira na área de tecnologia. Iniciei minha trajetória como Sysadmin, atuando em ambientes on-premises e datacenters. Nos últimos 10 anos, tenho trabalhado com cloud, containers, DevOps e SRE, acumulando experiência em diversas áreas.

Audiodescrição: Felipe é um homem branco, de cabelo curto castanho e olhos castanhos. Ele veste uma camisa azul e está em um ambiente de escritório com uma estante ao fundo.

Deixo aqui meus contatos, incluindo meu LinkedIn. Será um prazer receber vocês por lá, aceitar conexões e responder a mensagens, sejam críticas ou elogios sobre o curso.

Compartilhando atividades e contribuições na comunidade

Ao longo desses 20 anos, também atuei como instrutor em cursos de pós-graduação e cursos livres, além de oferecer mentorias gratuitas para profissionais que desejam trocar de área ou evoluir na carreira DevOps. Fiquem atentos ao meu LinkedIn para informações sobre novas turmas e mentorias.

Sou escritor e participo da comunidade Jornada Colaborativa, onde escrevemos livros cujos royalties são doados para instituições carentes. Fui líder de três livros: Cloud Native, Jornada da Observabilidade e o mais recente, Jornada Kubernetes, que será lançado em março de 2026. Se desejarem ler um bom conteúdo e ajudar quem precisa, podem encontrar mais informações no meu LinkedIn.

Introduzindo o curso de Kubernetes Fundamentos

Foi um prazer receber o convite da Alura para estar com vocês neste curso. Vamos começar com os fundamentos do Kubernetes, realizando nosso primeiro deploy. Abordaremos o que é Kubernetes, por que utilizá-lo, seus principais componentes e faremos nosso primeiro deploy utilizando o cluster kind. A ideia é que possamos realizar todas as práticas do curso em nosso ambiente local.

Para iniciar nosso primeiro deploy, utilizaremos o comando kubectl apply -f. Este comando é fundamental no Kubernetes, pois permite aplicar configurações a partir de arquivos YAML, que definem os recursos que queremos criar ou atualizar no cluster.

kubectl apply -f

Explorando os tópicos do curso

Em seguida, passaremos para a parte de objetos do Kubernetes, discutindo pod, deployment, service, ingress e muito mais. Também abordaremos persistência e stateful set, falando sobre volumes no Kubernetes, storage class e dados persistentes.

O próximo assunto será outscaling e resiliência, onde discutiremos HPA, VPA, PDB, escalonamento e como automatizar a escalabilidade do cluster em situações de alta demanda.

A segurança é um tema crucial, e no Kubernetes não é diferente. Falaremos sobre RBAC, Network Policy e ferramentas como o Kiverna. Também teremos um módulo sobre Realm Customizing, que trata do gerenciamento de pacotes e templates dentro do Kubernetes.

Nos encontramos na próxima aula!

Concluindo com práticas e aplicações no mercado

Troubleshooting, boas práticas e utilização de IA são os temas que abordaremos. Além da parte de troubleshooting e boas práticas, vamos mostrar como podemos utilizar IA no nosso dia a dia de DevOps SRE, com foco em Kubernetes. Para encerrar o curso, realizaremos um deploy de um cluster Kubernetes na AWS. Optamos pela AWS, mas os conceitos e a forma de implementação são semelhantes em outras nuvens.

A ideia é concluir o curso demonstrando como realizar esse deploy, qual é a configuração necessária e como trabalhar no dia a dia com clusters operando em nuvem. O curso será bastante prático, com muitas atividades práticas. Em quase todas as aulas, haverá scripts, arquivos YAML e comandos. Todo esse material será disponibilizado para que vocês possam replicar e editar os laboratórios. Vocês terão os arquivos e poderão fazer alterações, explorar outros cenários e opções, e modificar configurações.

O conteúdo é voltado para a realidade do mercado, pensado para quem deseja aplicar no trabalho ou concorrer a vagas. Não se trata de um preparatório para certificações como CKA ou CKD, mas sim de um curso que aborda os conceitos do Kubernetes com foco no que é utilizado no dia a dia. Como instrutor, trarei sempre exemplos práticos e reais, destacando o que é efetivamente utilizado no mercado.

Convidando para a jornada prática no curso

Começaremos do básico e evoluiremos até a nuvem, sempre trabalhando no terminal, inicialmente com kind, até chegarmos ao final, onde conheceremos o funcionamento dentro da AWS. O curso é composto por cerca de oito módulos e mais de 40 aulas, com muita prática e conteúdo, sempre acompanhados de scripts para replicação.

Por fim, faço um convite para encararmos essa jornada juntos. Do primeiro deploy ao deploy na AWS, tudo na prática, com muitos exemplos reais e muito uso do terminal. Vamos começar com um kubectl apply -f e avançar para o nosso primeiro módulo. Espero vocês na próxima aula.

Fundamentos e Arquitetura do Kubernetes - Conceitos de kubernetes

Introduzindo o curso e os conceitos de Kubernetes

Hola a todos, bem-vindos ao nosso primeiro módulo do curso Fundamentos de Kubernetes. Neste módulo, entenderemos por que o Kubernetes existe e também faremos nosso primeiro deploy (desdobramento). Dentro deste primeiro módulo, trabalharemos e conheceremos os conceitos de Kubernetes, Docker, Nuvem, as versões de Kubernetes na nuvem. Também falaremos sobre arquitetura, ou seja, sobre o Control Plane e os Workers.

Abordaremos os objetos fundamentais de Kubernetes, discutindo os conceitos principais e os objetos que veremos no dia a dia e também durante nosso curso. Trabalharemos com cada um deles, por isso é importante que conheçamos esses nomes e comecemos a nos familiarizar com eles e seus conceitos.

Levantando o ambiente Kubernetes

Por último, para encerrar nosso módulo, levantaremos nosso ambiente Kubernetes que usaremos durante o curso. Neste caso, será um cliente que instalaremos localmente e faremos nosso primeiro deploy, o desdobramento de um NGINX, o servidor de páginas, dentro do nosso cluster.

Explorando cenários antes e depois do Kubernetes

Para começar, vamos falar um pouco sobre os cenários antes e depois do Kubernetes. Mesmo hoje em dia, vemos cenários como o ilustrado aqui na imagem, no canto esquerdo, onde temos o host, que seria o servidor, a máquina, o servidor que vamos adquirir, e temos o hypervisor. O hypervisor nada mais é do que o sistema operacional que está rodando, então temos um sistema operacional instalado nesse servidor, para o qual existem algumas ferramentas; o VMware, acredito, é o mais conhecido do mercado. Adquirimos esse servidor, instalamos o VMware e, sobre o VMware, configuraremos e instalaremos nossas máquinas virtuais.

O hypervisor tem a função de compartilhar os recursos desse servidor, podendo alocar memória, CPU, disco, rede, todos os recursos desse servidor, para que possamos criar várias máquinas virtuais, pequenas máquinas virtuais, aproveitando melhor esses recursos disponíveis. Antes do hypervisor, simplesmente pegávamos a máquina e instalávamos o sistema operacional, comprávamos uma máquina com muitos recursos e instalávamos o sistema operacional ali dentro, funcionando com esse sistema. Assim, antes, o hypervisor era usado dessa maneira, onde adquiríamos o servidor e instalávamos o sistema operacional nele, com suas configurações, aplicações e tudo mais dentro do próprio sistema operacional.

Discutindo desafios na gestão de máquinas virtuais

No caso do hypervisor, podemos compartilhar esses recursos, o que resulta em uma utilização mais eficiente. No entanto, enfrentávamos algumas situações: uma aplicação por máquina virtual, o que gerava uma quantidade muito grande de máquinas virtuais para administrar. Um dos grandes problemas também era a gestão de configuração. Embora, mesmo naquela época, contássemos com algumas ferramentas para automatizar essa gestão, como Ansible, Puppet e Chef, tínhamos ferramentas disponíveis para realizar essa gestão de configuração, garantindo que o servidor nascesse com essas configurações mínimas, com essas parametrizações, etc.

A gestão diária de máquinas virtuais pode ser bastante complexa, pois a quantidade de máquinas tende a aumentar significativamente. Além disso, quando precisamos realizar alguma ação específica em uma máquina virtual, essa ação pode ser única para aquela máquina. Mesmo que tenhamos seguido um passo a passo ou uma automatização, cada sistema operacional é único, o que gera dificuldades para atualizar pacotes, versões e até mesmo ações manuais que não se propagam para outros servidores ou para o próprio playbook ou script de automatização. Esse ambiente, portanto, pode se tornar precário.

Abordando problemas de provisionamento e eficiência de recursos

Além da questão das muitas máquinas virtuais, há também o desafio de gerenciar várias delas simultaneamente. O aproveitamento de recursos é outro ponto crítico. Mesmo que tenhamos máquinas pequenas, não há garantia de que todos os recursos estejam sendo utilizados. Por exemplo, ao alocar 1 GB de memória e meio CPU, pode haver recursos ociosos durante o dia ou em períodos sem acesso. Isso torna a gestão mais complicada.

Outro ponto a considerar é o provisionamento, que era lento. O que queremos dizer com provisionamento lento? Para provisionar uma máquina virtual completa com tudo o que precisamos, levava-se vários minutos. Dependendo do ambiente, se estivermos em um ambiente crítico e precisarmos de uma máquina adicional para suportar a carga, o tempo de provisionamento pode causar a queda da aplicação.

Introduzindo contêineres e o impacto do Docker

Por volta de 2013, surgiram os contêineres, iniciando uma discussão sobre essa nova possibilidade. O Docker se tornou muito conhecido e foi o mais utilizado na época de seu surgimento. Ele surgiu como um facilitador, permitindo a instalação com poucos cliques ou através de um script simples, tanto no Windows quanto no Linux. O Docker trouxe a questão principal da portabilidade. No cenário anterior, cada máquina era única, e frequentemente ouvíamos a frase "funciona na minha máquina". Os desenvolvedores enfrentavam o problema de algo funcionar em suas máquinas, mas não no servidor.

O Docker resolveu essa questão com a solução de contêineres, garantindo portabilidade. O contêiner gerado funcionará da mesma forma, seja em um computador pessoal, servidor, AWS ou qualquer outra nuvem. Com o Docker, podemos criar imagens de contêiner que vêm empacotadas com tudo o que precisamos: sistema operacional, bibliotecas e nossa própria aplicação. Assim, geramos uma versão do contêiner, por exemplo, a versão 1.0 da nossa aplicação, já totalmente empacotada.

Explicando a idempotência e a eficiência dos contêineres

A partir do momento em que geramos essa imagem, utilizamos o conceito de idempotência, ou seja, o estado da imagem não mudará. Ela foi gravada com aquele estado e, independentemente de onde a utilizarmos, será iniciada da mesma maneira. Isso melhora significativamente nosso dia a dia, além de ser leve e rápido de iniciar. Com máquinas virtuais, levamos minutos para iniciar; com o Docker, levantamos a imagem rapidamente, permitindo criar novos contêineres de forma ágil. Isso facilita a disseminação para outras equipes.

Concluindo a primeira aula e introduzindo a próxima

Esta é nossa primeira aula; esperamos que tenham gostado. Na segunda aula, continuaremos discutindo sobre o Docker. Esperamos vê-los na próxima aula.

Fundamentos e Arquitetura do Kubernetes - Praticando com docker

Introduzindo a aula e o uso do Linux

Olá a todos, esta é nossa segunda aula do módulo 1 do curso de fundamentos para Kubernetes. Nesta aula, continuaremos discutindo sobre Docker e traremos um exemplo prático de uma imagem Docker e como podemos executar essa imagem em nosso computador.

Estamos utilizando uma máquina Linux. No nosso caso, usamos Windows com o WSL. Atualmente, o Windows permite levantar um subsistema, que é essa tecnologia chamada WSL. Através desse subsistema, podemos criar um sistema operacional Linux dentro do próprio Windows. Sugerimos que quem está acompanhando o curso utilize Linux. Embora exista o Docker e possamos instalar o Docker Desktop e fazer a configuração do Kind, que também vamos usar, é possível levantar no Windows. No entanto, como toda a base do Docker e do Kubernetes é Linux, recomendamos que se familiarizem com o Linux. Usem este curso também para isso, para se acostumarem mais com Linux.

Por isso, no nosso curso, todos os comandos, ferramentas e tudo o que utilizaremos serão em sistema operacional Linux. Sugerimos que criem um ambiente assim para que possam se familiarizar com um ambiente mais próximo da realidade do mercado, mais próximo do que é usado diariamente nas empresas.

Criando e configurando o Dockerfile

Criamos uma pasta no sistema chamada "docker exemplo", e dentro dela temos o arquivo Dockerfile. Esse é o arquivo base para criar nossa imagem. Sempre precisamos ter um Dockerfile, que é um arquivo onde passamos os parâmetros de criação do contêiner. Vamos abri-lo para mostrar.

Para listar os arquivos dentro da pasta, utilizamos o comando:

ls

No Dockerfile, temos vários comandos para passar certas informações. O primeiro comando é FROM. O que seria o FROM? Baseamo-nos em uma imagem base, ou seja, precisamos ter uma imagem, uma base de imagem, para poder injetar nosso serviço, configurações, arquivos, etc. Neste caso, estamos usando uma imagem nginx:alpine.

vi Dockerfile

Dentro do Dockerfile, começamos com o seguinte código:

FROM nginx:alpine

# Remove a config padrão
RUN rm /etc/nginx/conf.d/default.conf

# Copia a nossa config do nginx
COPY nginx.conf /etc/nginx/conf.d/default.conf

# Copia o HTML que vamos usar na demo
COPY index.html /usr/share/nginx/html/index.html

# Expondo a porta 8084
EXPOSE 8084

# Start do nginx
CMD ["nginx", "-g", "daemon off;"]

Explicando o uso do Docker Hub e repositórios privados

De onde estamos obtendo essa imagem? Quando não passamos nada, o Docker busca no repositório chamado Docker Hub. Quando não especificamos nada, ele termina buscando no Docker Hub, que é um repositório de imagens onde há imagens de todas as ferramentas, sistemas operacionais, ferramentas comunitárias e até ferramentas pagas. As pessoas também o utilizam para publicar suas imagens. É um repositório global de imagens.

Quando trabalhamos com imagens privadas, por exemplo, queremos subir uma aplicação dentro de uma imagem e ter uma imagem privada, utilizamos repositórios privados. Acabamos utilizando o repositório da própria nuvem que usamos. Se usamos AWS ou GCP, eles têm soluções para armazenar nossas imagens. Toda imagem criada é armazenada em um repositório privado, onde apenas quem tem acesso a esse ambiente pode baixar, modificar, etc.

Vamos mostrar o site do Docker Hub para que se familiarizem. Durante o curso, as imagens que forem criando podem ser armazenadas no Docker Hub. O Docker Hub permite criar um usuário e senha para que possam guardar suas imagens lá. Se criarem uma imagem e quiserem armazená-la, podem fazer isso também.

Além do código, claro, esse código que vamos criar aqui também pode ser armazenado no GitHub. Podem criar repositórios das aulas que formos fazendo e usar o GitHub no dia a dia para guardar essas configurações. Durante o curso, também mostraremos como criar esse fluxo para que se familiarizem tanto com a parte do GitHub quanto com a do Docker Hub, para quem ainda não conhece.

Configurando o Nginx e criando o HTML

Sempre começamos com FROM, onde passamos a imagem base. Neste caso, é uma imagem de Nginx, que é um servidor de páginas que vamos levantar. O que estamos fazendo? Vamos eliminar a configuração padrão, porque quando instalamos o Nginx, ele já vem com uma imagem, com um index.html e uma configuração padrão. Vamos remover o arquivo default.conf, copiar nosso arquivo local nginx.conf para o local onde estava o padrão e também copiar um HTML. Vamos criar um HTML para colocar dentro dessa pasta.

Para criar o arquivo HTML, utilizamos o comando:

vi index.html

E o conteúdo do index.html é o seguinte:

<!DOCTYPE html>
<html lang="pt-BR">
<head>
    <meta charset="UTF-8">
    <title>Demo Nginx</title>
    <style>
        body {
            font-family: Arial, sans-serif;
            background: #f4f4f4;
            display: flex;
            align-items: center;
            justify-content: center;
            height: 100vh;
        }

        .box {
            background: white;
            padding: 40px;
            border-radius: 10px;
            text-align: center;
            box-shadow: 0 4px 12px rgba(0,0,0,0.1);
        }

        h1 {
            color: #2c3e50;
        }
    </style>
</head>
<body>
    <div class="box">
        <h1>Nginx rodando em Docker!</h1>
        <p>Curso fundamentos Kubernetes.</p>
        <p><strong>Porta: 8084</strong></p>
    </div>
</body>
</html>

Os comandos são RUN. Sempre que queremos executar algum comando que use comandos de Linux, colocamos um RUN na frente. Por exemplo, RUN rm, que já é o comando que usaríamos no Linux. RUN rm significa que vamos eliminar. O COPY é o comando para copiar arquivos, então COPY e colocamos o que queremos copiar e para onde queremos copiar.

Para configurar o Nginx, criamos o arquivo nginx.conf:

vi nginx.conf

E o conteúdo do nginx.conf é:

server {
    listen 8084;

    location / {
        root   /usr/share/nginx/html;
        index  index.html;
    }
}

Exposição de portas e execução de contêineres

A exposição é o porto que vamos expor. Neste caso, vamos expor o porto 8084, diferente do normal, que geralmente é 80 ou 443. Como estamos trabalhando em localhost, preferimos usar um porto alto, neste caso, 8084. Abaixo está o comando que usaremos para executar esse contêiner, pois, caso contrário, ele morrerá. Imaginem que copiamos um arquivo, apagamos um arquivo, fazemos essa ação e o contêiner morre. Precisamos de um comando que garanta que o contêiner se mantenha em execução, que não morra. Neste caso, estamos executando um cmd, que seria um comando, e passamos nginx -g 'daemon off;'. Ou seja, nginx é o serviço, e nginx -g 'daemon off;' manterá o processo do nginx em execução, e o contêiner não se deterá, assim ele se levantará e continuará executando esse processo de Linux.

Dentro da nossa pasta, temos nosso index, que é um HTML que criamos para simular. Colocamos aqui uma mensagem: "nginx rodando em docker, curso fundamentos Kubernetes". Assim, colocamos uma mensagem e utilizamos um HTML padrão para usarmos durante a aula como demonstração. Depois, temos nosso nginx, nginx-conf, cuja configuração basicamente escuta no porto 8084, que é o porto que estamos expondo, e vai buscar nosso index.html, que é o arquivo que estamos copiando para que possamos abrir a página.

Construção do contêiner

Mas não é só isso, precisamos fazer o build do nosso contêiner. Por exemplo, vamos mudar algo, "rodando em docker". Colocamos aqui a mensagem e adicionamos algumas exclamações para mostrar que está funcionando. Temos um comando que é docker build. Quando instalamos o Docker no nosso sistema operacional, ele vem com alguns comandos, um deles é docker build. O que faz o docker build? Ele busca o arquivo dockerfile. Como o arquivo dockerfile está na raiz, colocamos um ponto. Fazemos docker build . Ele busca o arquivo dockerfile e realiza a execução. Sempre toma isso, load, default dockerfile. Ou seja, quando fazemos docker build ., ele busca o arquivo com esse nome e faz o build desse contêiner para nós.

docker build .

Em seguida, executamos esse contêiner. Executamos o comando docker run, que também é um comando, "-d", "-p", ou seja, "-d" para que não morra também, para que continue executando. O "-p" usamos para mapear seu porto. Então, estamos passando o porto 8084. E aqui damos um nome, nginx-demo, nginx-demo.

docker run -d -p 8084:8084 --name nginx-demo nginx-demo

Gerenciamento de contêineres

Como já tínhamos um contêiner, isso também está bem aqui, pois já estávamos fazendo testes e já tínhamos um contêiner rodando com esse nome. No nosso Docker local, não podemos executar dois contêineres com o mesmo nome. O que se recomenda fazer? Vamos mostrar alguns comandos. Temos um comando no Docker que podemos executar para listar. Com docker ps, vemos o que está rodando.

docker ps

E se colocarmos docker ps -a, aparece até o que não está rodando. Por exemplo, há três dias, executamos uma imagem Hello World. Quando levantamos o Docker nesta máquina, neste WSL, que é uma máquina nova, testamos um Hello World, executamos um Hello World para ver se tudo estava bem, para ver se subia, enfim. Assim, há três dias, temos um Hello World registrado na nossa máquina.

docker ps -a

Então, o que podemos fazer? Vamos eliminá-lo, então damos docker rm, podemos dar docker rm e passar o id da imagem. Aproveitamos e vamos eliminar esses dois aqui.

docker rm 97d0f40e3d72 1c3d1f29b49b

O que nos foi dito aqui? Nos foi dito que o contêiner está rodando, então não pode, esse primeiro contêiner está rodando, por isso não pode fazer rm. Então, precisamos fazer um stop. Fazemos docker stop e vamos parar esse contêiner.

docker stop 97d0f40e3d72

Perfeito, depois de pará-lo, podemos fazer o rm normalmente. A outra imagem deu como não encontrada, porque já havíamos executado o comando acima e já a havíamos eliminado. Agora podemos executar nosso run novamente e docker ps para validar.

docker run -d -p 8084:8084 --name nginx-demo
docker ps

Perfeito, já subiu aqui, ok. Abramos nossa página, nosso localhost. localhost:8084. E aqui está Nginx rodando em Docker, curso fundamentos, Kubernetes.

localhost:8084

Conclusão da aula

Nesta segunda aula, quisemos mostrar um pouco sobre alguns comandos do Docker, como usar Docker, dockerfile. Por quê? Porque essa é a base para Kubernetes. Kubernetes é um orquestrador de contêineres, como veremos a seguir. Sua base é o contêiner. Precisamos ter uma imagem, gerar essa imagem e tê-la disponível para que a executemos dentro de Kubernetes. No dia a dia, vamos trabalhar muito com imagens Docker, comandos Docker, imagens base. Poderemos trabalhar em empresas que talvez nos peçam para criar imagens personalizadas. Assim, é bom que nos familiarizemos com esses comandos do Docker, com o dockerfile e com os parâmetros do Docker, pois é uma ferramenta que vamos usar no nosso trabalho diário. E na evolução para outros temas como CI/CD e outros pontos, o Docker também é muito utilizado. Inclusive para fazer o build das aplicações, para gerar os artefatos. Por isso, é importante ter esse conhecimento de Docker.

Bem, isso é tudo para a segunda aula. Esperamos que tenham gostado. Na terceira aula, entraremos mais a fundo na arquitetura de Kubernetes e continuaremos com este estudo. Obrigado, nos vemos na próxima aula!

Sobre o curso Kubernetes: orquestrar aplicações, escalabilidade e segurança

O curso Kubernetes: orquestrar aplicações, escalabilidade e segurança possui 516 minutos de vídeos, em um total de 83 atividades. Gostou? Conheça nossos outros cursos de SRE em DevOps, ou leia nossos artigos de DevOps.

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

• Fundamentos e Arquitetura do Kubernetes
• Principais Objetos do Kubernetes
• Persistência e StatefulSets no Kubernetes
• Escalonamento e Resiliência no Kubernetes
• Segurança e Controle no Kubernetes
• Helm e Kustomize Práticas Avançadas
• Kubernetes Troubleshooting e Ferramentas Avançadas
• Kubernetes na AWS Prática
• Encerramento e Reflexão Final