Infra

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
Começar o TP

Fundamentos de Kubernetes

Criar um cluster, implementar os cinco serviços e compreender a sua comunicação.

3h30 Fundamentos 12 etapas

Resultado esperado

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

Etapas do TP

Preparar o cluster e as imagens

  1. Etapa 1 : Verificar as ferramentas

    Verificar que Docker, k3d e kubectl respondem; explicar o papel de cada um.

    docker version && k3d version && kubectl version --client

    Os três comandos executam-se sem erro.

  2. 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 nodes

    Os nós estão Ready.

  3. 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.sh

    As imagens tp-lab-api:1.0 e tp-lab-app:1.0 estão disponíveis nos nós.

  4. Etapa 4 : Criar o Namespace

    Ler o manifesto Namespace e criar depois o perímetro tp-devops.

    kubectl apply -f niveau-01/00-namespace.yaml

    O Namespace tp-devops aparece em kubectl get ns.

Implementar os objetos Kubernetes

  1. 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.yaml

    Cada recurso tem um papel identificado.

  2. 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.yaml

    Todos os Deployments existem sem InvalidImageName nem seletor incoerente.

  3. 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-devops

    Os cinco Services estão presentes e os Pods passam a Ready.

  4. 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-devops

    Os endereços DNS internos correspondem aos nomes dos Services.

Testar e observar

  1. 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:80

    A página HTML responde em http://localhost:8080.

  2. 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/hello

    Uma resposta JSON contém database_connected e messages_count.

  3. 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:80

    A mensagem aparece na base de dados e o e-mail no Mailpit (porta 8025).

  4. 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=40

    Os estudantes explicam um erro provável e o seu método de diagnóstico.

Recursos

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

Resultado esperado

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

Etapas do TP

Externalizar a configuração

  1. 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.

  2. 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.yaml

    kubectl get cm tp-config -n tp-devops apresenta o ConfigMap.

  3. 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-devops

    O segredo contém as duas chaves esperadas sem revelar nenhum dado real.

  4. Etapa 4 : Referenciar a configuração

    Ligar a API a envFrom ConfigMap e a secretKeyRef para DB_PASSWORD.

    kubectl describe deployment api -n tp-devops

    O Pod lê as variáveis de ambiente certas.

Armazenamento e estado

  1. 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-found

    Apenas um controlador gere os Pods MariaDB.

  2. 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.

  3. Etapa 7 : Criar o PVC

    Aplicar os manifestos e examinar o StatefulSet, o Pod e o PersistentVolumeClaim.

    kubectl get sts,pod,pvc -n tp-devops

    O PVC está Bound e mariadb-0 está Ready.

  4. 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-devops

    Os dados são conservados; o PVC permanece presente.

Observabilidade e manutenção

  1. 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-devops

    A readiness é visível e atua sobre a disponibilidade do Pod.

  2. Etapa 10 : Avaliar os recursos

    Ler requests/limits e explicar uma situação de falta de memória.

    kubectl describe deployment api -n tp-devops

    O papel de cada valor está corretamente formulado.

  3. 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-devops

    O Service distribui por vários Pods.

  4. 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-devops

    O estudante distingue uma atualização progressiva de um reinício de Pod.

Recursos

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

Resultado esperado

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

Etapas do TP

Compreender o percurso dos pedidos

  1. 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-system

    Um controlador Traefik K3s está a funcionar.

  2. 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:8088

    A porta responde, mesmo que o código HTTP ainda não seja 200.

  3. 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

  1. 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.

  2. 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.yaml

    Os três objetos Ingress aparecem no kubectl.

  3. 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/hello

    O front-end e o JSON da API passam pelo Traefik.

  4. 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

  1. 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-devops

    As fontes autorizadas estão identificadas.

  2. 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.

  3. 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.

  4. 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-devops

    Um 404 ou 502 é analisado metodicamente.

Recursos

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

Resultado esperado

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

Etapas do TP

Compreender um Chart

  1. 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.

  2. 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_demo

    O Secret existe e permanece fora do Chart GitOps.

  3. 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.

  4. 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

  1. 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.

  2. Etapa 6 : Validar o Chart

    Executar helm lint e apresentar os manifestos gerados com helm template.

    helm lint niveau-04/charts/tp-stack

    Sem erros de Chart.

  3. 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.yaml

    A release existe e os serviços respondem.

  4. 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-devops

    A ligação entre values e o manifesto final está estabelecida.

Evoluir e restaurar

  1. 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.yaml

    O número de Pods app varia.

  2. Etapa 10 : Observar o histórico

    Listar as revisões Helm e explicar a noção de release.

    helm history tp -n tp-devops

    Pelo menos duas revisões visíveis.

  3. Etapa 11 : Efetuar um rollback

    Voltar à revisão anterior e comparar o número de réplicas.

    helm rollback tp 1 -n tp-devops

    O número de Pods volta ao seu valor anterior.

  4. 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

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

Resultado esperado

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

Etapas do TP

Instalar e preparar o Git

  1. 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 -v

    Um repositório remoto autêntico está identificado.

  2. 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-devops

    A mesma aplicação não é controlada por duas ferramentas.

  3. 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.yaml

    Todos os controladores necessários arrancam.

  4. 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:443

    A interface do Argo CD está disponível através de https://localhost:8443.

Declarar a aplicação

  1. 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.

  2. 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.yaml

    O objeto Application aparece.

  3. 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 argocd

    A aplicação converge para o estado desejado.

  4. 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/hello

    A stack continua funcional após a migração GitOps.

Testar a reconciliação e concluir

  1. 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 push

    O Deployment app adota o valor do Git.

  2. 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-devops

    O Argo CD deteta e corrige o desvio.

  3. Etapa 11 : Restaurar a partir do Git

    Voltar a um commit anterior, enviar e verificar a sincronização.

    git revert <identifiant-du-commit> && git push

    O estado desejado anterior é reposto.

  4. 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

Na mesma série Etapa 2 de 2

  1. 1 Curso Kubernetes — O curso
  2. 2 TP Trabalhos práticos Kubernetes Está aqui

Partilhar este artigo

Na mesma categoria

Curso

Infra · Intermédio

Kubernetes — O curso

Pods, implementações, serviços, configuração e armazenamento: orquestrar contentores, da teoria ao kubectl.

3 guias · 159 noções Na mesma série

Curso

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.

3 guias · 146 noções Na mesma série