Trabalhos práticos Avançado Gratuito
Trabalhos práticos Kubernetes
Cinco oficinas: fundações, configuração, Traefik, Helm e Argo CD num cluster local.
- 5 oficinas
- 59 etapas
Fundamentos de Kubernetes
Criar um cluster, implementar os cinco serviços e compreender a sua comunicação.
3h30 Fundamentos 12 etapas
Cinco Deployments e Services disponíveis; uma página HTML apresenta a mensagem da API; as ferramentas MariaDB e Mailpit são consultáveis.
Pré-requisitos
- Docker Engine e k3d funcionais
- kubectl instalado
- Aplicação Docker do TP anterior
Preparar o cluster e as imagens
-
Etapa 1 : Verificar as ferramentas
Verificar que Docker, k3d e kubectl respondem; explicar o papel de cada um.
docker version && k3d version && kubectl version --clientOs três comandos executam-se sem erro.
-
Etapa 2 : Arrancar o cluster
Executar o script fornecido; identificar o nó de controlo e o nó worker.
bash scripts/01-setup-cluster.sh && kubectl get nodesOs nós estão Ready.
-
Etapa 3 : Construir as imagens
Retomar os Dockerfiles PHP e Node/SCSS do projeto anterior; construir e carregar as imagens no k3d.
bash scripts/02-build-images.shAs imagens tp-lab-api:1.0 e tp-lab-app:1.0 estão disponíveis nos nós.
-
Etapa 4 : Criar o Namespace
Ler o manifesto Namespace e criar depois o perímetro tp-devops.
kubectl apply -f niveau-01/00-namespace.yamlO Namespace tp-devops aparece em kubectl get ns.
Implementar os objetos Kubernetes
-
Etapa 5 : Identificar os objetos YAML
Ler apiVersion, kind, metadata e spec; explicar a ligação entre labels e seletores.
cat niveau-01/10-app.yamlCada recurso tem um papel identificado.
-
Etapa 6 : Reconstituir os Deployments em falta
A partir dos Services fornecidos, criar api, app, phpmyadmin e mailpit e atribuir as imagens, portas e variáveis.
kubectl apply -f etudiants/niveau-01/10-app.yamlTodos os Deployments existem sem InvalidImageName nem seletor incoerente.
-
Etapa 7 : Arrancar os cinco serviços
Aplicar o manifesto completado. Utilizar os comandos get e describe para analisar eventuais erros.
kubectl get deploy,pods,svc -n tp-devopsOs cinco Services estão presentes e os Pods passam a Ready.
-
Etapa 8 : Compreender a resolução DNS
Explicar porque a API contacta a base de dados através de mariadb:3306, e não de localhost.
kubectl get svc -n tp-devopsOs endereços DNS internos correspondem aos nomes dos Services.
Testar e observar
-
Etapa 9 : Abrir o frontend
Estabelecer um túnel de porta para Service/app e visitar com o navegador.
kubectl port-forward -n tp-devops service/app 8080:80A página HTML responde em http://localhost:8080.
-
Etapa 10 : Testar a API e o MariaDB
Apresentar Hello World e o contador de mensagens. Se 503, aguardar durante a inicialização do MariaDB.
curl http://localhost:8080/api/helloUma resposta JSON contém database_connected e messages_count.
-
Etapa 11 : Inspecionar o phpMyAdmin e o Mailpit
Estabelecer dois túneis em terminais separados e testar depois o envio de uma mensagem.
kubectl port-forward -n tp-devops svc/phpmyadmin 8081:80A mensagem aparece na base de dados e o e-mail no Mailpit (porta 8025).
-
Etapa 12 : Diagnosticar os contentores
Ler os registos e descrever o estado de um Pod; identificar as fases do ciclo de vida.
kubectl logs -n tp-devops deployment/api --tail=40Os estudantes explicam um erro provável e o seu método de diagnóstico.
Recursos
- Pods — documentação Kubernetes — Compreender o que executa realmente os contentores
- Deployment — documentação — Controlador de implementação e réplicas
- Service — documentação — Acesso de rede estável aos Pods
- k3d — guia de arranque — Cluster Kubernetes local
- kubectl port-forward — Expor temporariamente um serviço
Configuração e exploração
Separar a configuração, manter os dados e observar a saúde dos serviços.
3h30 Exploração 12 etapas
Base de dados persistente após a recriação do Pod, configuração externalizada, réplicas operacionais e sondas de saúde observáveis.
Pré-requisitos
- Nível 1 concluído
- Namespace tp-devops ativo
- Manifestos corrigidos N2 disponíveis
Externalizar a configuração
-
Etapa 1 : Observar os limites do nível 1
Identificar as informações codificadas diretamente e distinguir a configuração aplicacional das palavras-passe.
Listar pelo menos três parâmetros a externalizar.
-
Etapa 2 : Criar um ConfigMap
Implementar os valores DB_HOST, DB_NAME, SMTP_HOST e outros parâmetros não secretos.
kubectl apply -f niveau-02/10-config.yamlkubectl get cm tp-config -n tp-devops apresenta o ConfigMap.
-
Etapa 3 : Criar um Secret pedagógico
Ler secretKeyRef; explicar que um Secret Kubernetes não é um cofre e que os valores do TP são fictícios.
kubectl get secret tp-db-auth -n tp-devopsO segredo contém as duas chaves esperadas sem revelar nenhum dado real.
-
Etapa 4 : Referenciar a configuração
Ligar a API a envFrom ConfigMap e a secretKeyRef para DB_PASSWORD.
kubectl describe deployment api -n tp-devopsO Pod lê as variáveis de ambiente certas.
Armazenamento e estado
-
Etapa 5 : Eliminar o Deployment MariaDB do N1
Evitar dois controladores concorrentes antes de criar o StatefulSet.
kubectl delete deployment mariadb -n tp-devops --ignore-not-foundApenas um controlador gere os Pods MariaDB.
-
Etapa 6 : Escrever o StatefulSet
Reconstituir o manifesto com volumeClaimTemplates, serviceName e a montagem /var/lib/mysql.
O YAML passa a validação e especifica 1Gi de armazenamento.
-
Etapa 7 : Criar o PVC
Aplicar os manifestos e examinar o StatefulSet, o Pod e o PersistentVolumeClaim.
kubectl get sts,pod,pvc -n tp-devopsO PVC está Bound e mariadb-0 está Ready.
-
Etapa 8 : Testar a persistência
Criar uma mensagem, eliminar o Pod mariadb-0 e verificar o contador após o reinício.
kubectl delete pod mariadb-0 -n tp-devopsOs dados são conservados; o PVC permanece presente.
Observabilidade e manutenção
-
Etapa 9 : Identificar as sondas
Distinguir readiness, liveness e startup. Examinar as sondas acrescentadas na solução.
kubectl describe pod -l app=api -n tp-devopsA readiness é visível e atua sobre a disponibilidade do Pod.
-
Etapa 10 : Avaliar os recursos
Ler requests/limits e explicar uma situação de falta de memória.
kubectl describe deployment api -n tp-devopsO papel de cada valor está corretamente formulado.
-
Etapa 11 : Modificar as réplicas
Passar temporariamente o frontend para três Pods e voltar depois a dois.
kubectl scale deployment app --replicas=3 -n tp-devopsO Service distribui por vários Pods.
-
Etapa 12 : Analisar as atualizações
Observar rollout status/history e depois uma alteração de imagem simulada, se disponível.
kubectl rollout status deployment/app -n tp-devopsO estudante distingue uma atualização progressiva de um reinício de Pod.
Recursos
- ConfigMaps — Variáveis não sensíveis
- Secrets — Gestão dos dados sensíveis
- StatefulSet — Identidade e persistência
- PVC e volumes — Armazenamento duradouro
- Probes — Saúde e disponibilidade
- Gestão de recursos — Requests e limits
Traefik e exposição de rede
Encaminhar os pedidos HTTP para os serviços certos e introduzir o isolamento de rede.
3h30 Rede 11 etapas
Uma entrada HTTP na porta 8088 distribui corretamente o frontend, /api, o phpMyAdmin e o Mailpit.
Pré-requisitos
- Nível 2 concluído
- Traefik K3s disponível
- Porta 8088 livre
Compreender o percurso dos pedidos
-
Etapa 1 : Identificar o Traefik integrado
Controlar o controlador instalado com o K3s; não lançar um segundo Traefik.
kubectl get pods -n kube-systemUm controlador Traefik K3s está a funcionar.
-
Etapa 2 : Verificar a porta publicada
Compreender a publicação no anfitrião 8088 → balanceador de carga K3d → porta 80 do Traefik.
curl -I http://127.0.0.1:8088A porta responde, mesmo que o código HTTP ainda não seja 200.
-
Etapa 3 : Comparar port-forward e Ingress
Distinguir o acesso temporário para diagnóstico de uma entrada HTTP partilhada.
Explicar a utilização de cada mecanismo.
Configurar as rotas
-
Etapa 4 : Reconstituir o Ingress principal
Definir Host tp.localhost, caminho /api para o Service api:8000, caminho / para o Service app:80.
O manifesto respeita o esquema networking.k8s.io/v1.
-
Etapa 5 : Implementar os três Ingress
Acrescentar também db.tp.localhost e mail.tp.localhost.
kubectl apply -f niveau-03/30-ingress-policy.yamlOs três objetos Ingress aparecem no kubectl.
-
Etapa 6 : Testar o frontend e a API
Abrir o navegador e analisar as respostas HTTP com um cabeçalho Host explícito.
curl -H "Host: tp.localhost" http://127.0.0.1:8088/api/helloO front-end e o JSON da API passam pelo Traefik.
-
Etapa 7 : Testar as ferramentas
Verificar os dois outros domínios; explicar a diferença entre host e path.
Os dois painéis respondem na porta 8088.
Isolar e proteger
-
Etapa 8 : Estudar a NetworkPolicy
Examinar a regra que limita a entrada TCP 3306 para o MariaDB aos Pods API e phpMyAdmin.
kubectl describe networkpolicy mariadb-access -n tp-devopsAs fontes autorizadas estão identificadas.
-
Etapa 9 : Compreender os limites da NetworkPolicy
Identificar a necessidade de um CNI que aplique as políticas e os limites de isolamento do laboratório.
Os estudantes não confundem NetworkPolicy com uma firewall de Internet.
-
Etapa 10 : Explicar o TLS
Constatar que um nome .localhost não obtém automaticamente um certificado público reconhecido.
Um plano de certificação real é formulado sem ativar um falso HTTPS.
-
Etapa 11 : Resolver um cenário de encaminhamento
Testar deliberadamente uma rota errada e identificar depois Host, path, Service e porta no diagnóstico.
kubectl describe ingress tp-web -n tp-devopsUm 404 ou 502 é analisado metodicamente.
Recursos
- Ingress Kubernetes — Regras de encaminhamento
- Traefik e Kubernetes Ingress — Controlador HTTP
- Rede do K3s — Traefik fornecido por omissão
- NetworkPolicies — Filtragem de rede entre Pods
- TLS e Ingress — Condições da cifragem HTTPS
Helm — Empacotamento e reutilização
Transformar os manifestos num Chart parametrizável e gerir o ciclo de vida de uma release.
3h30 Industrialização 12 etapas
Um Chart Helm validado pode instalar, atualizar e restaurar a stack, com values distintos.
Pré-requisitos
- Manifestos Kubernetes dos níveis 1 a 3 dominados
- Helm instalado
- Cluster pronto para uma instalação limpa
Compreender um Chart
-
Etapa 1 : Preparar o cluster sem conflitos
Não voltar a aplicar os manifestos manuais aos mesmos recursos. Recomeçar de um cluster limpo, se necessário.
Nenhum controlador concorrente gere os mesmos recursos.
-
Etapa 2 : Criar o Secret de demonstração
O Chart referencia um Secret externo tp-db-auth; não armazena nenhuma palavra-passe em values.yaml.
kubectl create secret generic tp-db-auth -n tp-devops --from-literal=DB_PASSWORD=tp_demo_password --from-literal=MARIADB_ROOT_PASSWORD=tp_root_demoO Secret existe e permanece fora do Chart GitOps.
-
Etapa 3 : Explorar Chart.yaml e values.yaml
Identificar a versão do Chart, a versão aplicacional, as imagens e as réplicas.
Distinguir appVersion e a versão do Chart.
-
Etapa 4 : Ler os templates
Compreender .Values, .Release.Namespace, os pipelines quote e as diretivas if.
O estudante sabe explicar uma expressão Helm.
Construir e validar
-
Etapa 5 : Reconstituir o template Ingress
Utilizar as variáveis de anfitrião e a opção ingress.enabled para ativar ou desativar as rotas.
O template renderiza três Ingress válidos.
-
Etapa 6 : Validar o Chart
Executar helm lint e apresentar os manifestos gerados com helm template.
helm lint niveau-04/charts/tp-stackSem erros de Chart.
-
Etapa 7 : Instalar a release
Instalar o Chart com values-dev.yaml no namespace tp-devops.
helm upgrade --install tp niveau-04/charts/tp-stack -n tp-devops -f niveau-04/charts/tp-stack/values-dev.yamlA release existe e os serviços respondem.
-
Etapa 8 : Distinguir template e objeto aplicado
Comparar um template Helm gerado com os recursos efetivamente criados.
helm template tp niveau-04/charts/tp-stack -n tp-devopsA ligação entre values e o manifesto final está estabelecida.
Evoluir e restaurar
-
Etapa 9 : Simular um ambiente mais carregado
Utilizar values-prod-simule.yaml para aumentar as réplicas do frontend.
helm upgrade tp niveau-04/charts/tp-stack -n tp-devops -f niveau-04/charts/tp-stack/values-prod-simule.yamlO número de Pods app varia.
-
Etapa 10 : Observar o histórico
Listar as revisões Helm e explicar a noção de release.
helm history tp -n tp-devopsPelo menos duas revisões visíveis.
-
Etapa 11 : Efetuar um rollback
Voltar à revisão anterior e comparar o número de réplicas.
helm rollback tp 1 -n tp-devopsO número de Pods volta ao seu valor anterior.
-
Etapa 12 : Verificar a reutilização
Modificar um valor sem reescrever os templates e explicar o interesse para dev / produção simulada.
Chart parametrizável e hipóteses de segurança explicitadas.
Recursos
- Charts Helm — Estrutura Chart.yaml / values.yaml / templates
- Guia dos templates Helm — Funções e expressões Go
- Comandos Helm — install, upgrade, history e rollback
- Helm values — Prioridades e ficheiros de valores
Argo CD — GitOps e reconciliação
Pôr o Git no centro da implementação e observar a convergência automática do Kubernetes.
3h30 GitOps 12 etapas
O Chart é implementado a partir de um repositório Git acessível, as suas alterações são sincronizadas e um desvio manual é corrigido.
Pré-requisitos
- Chart Helm operacional
- Um repositório Git realmente acessível ao Argo CD
- Cluster com imagens disponíveis
- Nenhuma release Helm concorrente
Instalar e preparar o Git
-
Etapa 1 : Reservar o Git como fonte de verdade
Copiar o Chart para um repositório Git acessível; não fazer commit de palavras-passe reais.
git status && git remote -vUm repositório remoto autêntico está identificado.
-
Etapa 2 : Eliminar as ferramentas concorrentes
Eliminar a release Helm CLI antes de entregar os recursos ao Argo CD; conservar ou recriar o Secret pedagógico.
helm list -n tp-devopsA mesma aplicação não é controlada por duas ferramentas.
-
Etapa 3 : Instalar o Argo CD
Instalar os manifestos oficiais, verificar os Pods e anotar a disponibilidade.
kubectl apply -n argocd --server-side --force-conflicts -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yamlTodos os controladores necessários arrancam.
-
Etapa 4 : Abrir o Argo CD localmente
Utilizar o port-forward HTTPS da interface; não publicar a interface com as credenciais iniciais.
kubectl port-forward svc/argocd-server -n argocd 8443:443A interface do Argo CD está disponível através de https://localhost:8443.
Declarar a aplicação
-
Etapa 5 : Construir o manifesto Application
Acrescentar o repoURL real, targetRevision, path, valores Helm e destino Kubernetes.
O YAML já não contém marcadores de posição Git.
-
Etapa 6 : Implementar a Application
Aplicar o recurso no namespace argocd e verificar as suas condições.
kubectl apply -f niveau-05/gitops/argocd/application.yamlO objeto Application aparece.
-
Etapa 7 : Observar a sincronização
Controlar o estado Synced / Healthy e compreender as condições que podem atrasar o estado Healthy.
kubectl get applications -n argocdA aplicação converge para o estado desejado.
-
Etapa 8 : Verificar o percurso do utilizador
Aceder ao front-end, enviar uma mensagem, verificar a base de dados e o Mailpit.
curl -H "Host: tp.localhost" http://127.0.0.1:8088/api/helloA stack continua funcional após a migração GitOps.
Testar a reconciliação e concluir
-
Etapa 9 : Modificar as réplicas no Git
Modificar app.replicas em values-dev.yaml, enviar o commit e aguardar o Argo CD.
git add . && git commit -m "tp: augmenter replicas" && git pushO Deployment app adota o valor do Git.
-
Etapa 10 : Criar deliberadamente um desvio
Modificar manualmente as réplicas através do kubectl enquanto o selfHeal está ativado.
kubectl scale deploy app --replicas=4 -n tp-devopsO Argo CD deteta e corrige o desvio.
-
Etapa 11 : Restaurar a partir do Git
Voltar a um commit anterior, enviar e verificar a sincronização.
git revert <identifiant-du-commit> && git pushO estado desejado anterior é reposto.
-
Etapa 12 : Apresentação técnica
Apresentar os papéis respetivos do Docker, Kubernetes, Helm e Argo CD; citar os riscos e os limites do TP.
Uma demonstração de 5 minutos valida a autonomia.
Recursos
- Arranque do Argo CD — Instalar e aceder ao Argo CD
- Argo CD + Helm — Renderização Helm e gestão do ciclo de vida
- Sincronização automatizada — Prune, self-heal, sync
- Application declarativa — Recurso Application e estado desejado
- Conceitos GitOps — Princípios básicos do GitOps
Na mesma série Etapa 2 de 2
- 1 Curso Kubernetes — O curso
-
2 TP Trabalhos práticos Kubernetes Está aqui
Na mesma categoria
Infra · Intermédio
Docker e Docker Compose — O curso
Imagens, contentores, volumes, redes e Compose: o léxico, os comandos essenciais e as boas práticas.
Infra · Intermédio
Kubernetes — O curso
Pods, implementações, serviços, configuração e armazenamento: orquestrar contentores, da teoria ao kubectl.
Infra · Intermédio
Terraform e Ansible — O curso
Descrever a infraestrutura com o Terraform e configurá-la com o Ansible: providers, playbooks, papéis e idempotência.