Aula Prática Infraestrutura como Código

Veja o Manual / Enunciado Completo

Roteiro
Aula Prática

INFRAESTRUTURA COMO CODIGO

Público

ROTEIRO DE AULA PRÁTICA

NOME DA DISCIPLINA: INFRAESTRUTURA COMO CODIGO

Unidade: U2_FERRAMENTAS INFRAESTRUTURA COMO CÓDIGO
Aula: A5_Utilização da computação em nuvem e container

OBJETIVOS

Definição dos objetivos da aula prática:

O objetivo desta aula prática é compreender os conceitos de containers, identificando suas diferenças em relação às máquinas virtuais, criar e gerenciar imagens Docker customizadas para aplicações web simples utilizando Dockerfile, executar e administrar containers localmente com mapeamento de portas e volumes, entender os princípios básicos de orquestração de containers com Kubernetes (Pods, Deployments e Services), implantar aplicações em um cluster Kubernetes local com Minikube, e configurá-las para acesso externo através de um Service.

SOLUÇÃO DIGITAL:

VSCode, GitBash, DockerDesktop e Minikube

Hardware:

• Computador com no mínimo 8GB de RAM.
• 20GB de espaço livre em disco.
• Conexão estável com a Internet.

Software (todos gratuitos e de código aberto):

• Docker Desktop: Ferramenta que instala o Docker Engine e o Docker CLI. (Disponível para Windows, macOS e Linux).
• Minikube: Ferramenta para executar um cluster Kubernetes de nó único localmente.
• kubectl: Ferramenta de linha de comando para interagir com o cluster Kubernetes (já vem incluída no Docker Desktop).
• VSCode: editor de código.
• Git Bash: Para clonar o repositório da aplicação de exemplo.

Link dos Softwares Utilizados:

• Git: https://git-scm.com/downloads
• Docker Desktop: https://www.docker.com/products/docker-desktop/
• Minikube: https://minikube.sigs.k8s.io/docs/start/

PROCEDIMENTOS PRÁTICOS E APLICAÇÕES

Procedimento/Atividade nº 1

CONTEINERIZAÇÃO COM DOCKER

Atividade proposta: Nesta aula prática, o estudante irá "containerizar" uma aplicação web simples em Python. Primeiramente, será criada uma imagem Docker para a aplicação usando um Dockerfile. Em seguida, será executada essa imagem como um container em seu ambiente local. Por fim, se darão os primeiros passos na orquestração, implantando e expondo essa mesma aplicação em um cluster Kubernetes local (Minikube), simulando um ambiente de produção simplificado.

Procedimentos para a realização da atividade:

1. Instalação das Ferramentas:
   • Instale o Docker Desktop. Após a instalação, certifique-se de que ele está em execução.
   • Instale o Minikube.
   • Abra um terminal (ou PowerShell/CMD no Windows) e verifique se as instalações foram bem-sucedidas com os comandos: docker --version e kubectl version --client.
2. Clone o Repositório da Aplicação de Exemplo:
   • No terminal, navegue até um diretório de sua preferência.
   • Entre na nossa classe e Clone o projeto que contém uma aplicação web simples: https://classroom.github.com/a/-XgJM8gz

   git clone LINK HTTPS PARA CLONAR

   • Acesse o diretório da aplicação que usaremos.

   cd CAMINHO PARA A APLICAÇÃO

3. Containerizando a Aplicação com Docker
   • Criação do Dockerfile:
     • Dentro do diretório da aplicação e crie um arquivo chamado Dockerfile (exatamente com este nome, sem extensão).
     • Adicione o seguinte conteúdo ao arquivo:
       • Defina uma imagem base oficial do Python 3.9
       • Defina o diretório de trabalho dentro do container
       • Copie o arquivo de dependências para o diretório de trabalho
       • Instale as dependências da aplicação
       • Copie o restante do código da aplicação para o diretório de trabalho
       • Exponha a porta 8080, ou a porta que a aplicação escuta
       • Defina o comando para executar a aplicação quando o container iniciar

4 – Construção da Imagem Docker:

• No terminal, certifique-se de que você ainda está no diretório do projeto.
• Execute o comando abaixo para construir a imagem. Substitua seu-nome por seu nome ou um identificador único.

docker build -t seu-nome/hello-app:v1 .

5 – Verifique se a imagem foi criada com sucesso listando as imagens locais: docker images.

6 – Execução do Container Docker:

• Execute o container a partir da imagem que você acabou de criar:

docker run -d -p 8080:8080 --name minha-app seu-nome/hello-app:v1

• -d: modo "detached" (executa em segundo plano).
• -p 8080:8080: mapeia a porta 8080 da sua máquina (host) para a porta 8080 do container.
• –name: atribui um nome fácil de lembrar ao container.
• Verifique se o container está em execução: docker ps.
• Acesse a aplicação no seu navegador: http://localhost:8080. Você deve ver a mensagem "Hello, world!".

7 – Orquestrando o Container com Kubernetes (Minikube):

• Iniciando o Cluster Kubernetes Local (powershell):

minikube start

• No terminal, inicie o Minikube. Este processo pode levar alguns minutos.
• Para que o Minikube utilize as imagens Docker que você construiu localmente sem a necessidade de um registro remoto, execute o comando em um powershell:

minikube docker-env | Invoke-Expression

• Atenção: Se você fechar este terminal, precisará executar este comando novamente em um novo terminal para que o Kubernetes encontre a imagem local.

8 – Criação do Arquivo de Deployment:

• Crie um arquivo chamado deployment.yaml. Este arquivo "declara" ao Kubernetes como sua aplicação deve ser executada.
• Adicione o seguinte conteúdo ao arquivo:
  • Defina a Implantação, criando um gerenciador de aplicação chamado hello-app-deployment.
  • Especifique o Número de Réplicas, garantindo que 2 instâncias (Pods) da sua aplicação estejam sempre em execução.
  • Crie o Modelo do Pod, definindo um "molde" para as instâncias, rotulando cada uma com app: hello-app para que o Deployment saiba quais gerenciar.
  • Defina o Container, instruindo cada instância a criar um container usando a imagem Docker local seu-nome/hello-app:v1.
  • Exponha a Porta, informa ao Kubernetes que a aplicação dentro de cada container escuta na porta 8080.

9 – Criação do Arquivo de Service:

• Crie um arquivo chamado service.yaml. Este arquivo irá expor seu Deployment para que ele possa ser acessado de fora do cluster.
• Adicione o seguinte conteúdo ao arquivo:
  • Crie um Serviço de Rede, definindo um serviço chamado hello-app-service, que atuará como um "endereço" fixo para sua aplicação.
  • Encontre os Pods Corretos, usando o selector para encontrar e se conectar a todos os Pods que têm o rótulo (label) app: hello-app (os que foram criados pelo seu Deployment).
  • Mapeie as Portas, recebendo tráfego na porta 8080 e o redirecionando para a targetPort (porta de destino) 8080 dos containers dentro dos Pods.
  • Exponha a Aplicação para Fora, através do type: NodePort, ele tornará a aplicação acessível externamente, em uma porta específica em cada nó (computador) do cluster.

10 – Aplicando os Manifestos no Cluster:

• Use o kubectl para aplicar os arquivos de configuração ao seu cluster Minikube:

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml

11 – Criando a imagem agora dentro do kubernets:

docker build -t elisa/hello-app:v1 .

12 – Verificando e Acessando a Aplicação no Kubernetes:

• Verifique se os Pods (instâncias da aplicação) estão rodando: kubectl get pods. Você deverá ver 2 pods com o status "Running".
• Verifique se o Service foi criado: kubectl get services.

minikube service hello-app-service

• Este comando deverá abrir automaticamente a aplicação no seu navegador. Note que a URL será diferente de localhost.

Avaliando os resultados:

Durante esta prática, você executou o processo completo de empacotar uma aplicação com Docker e, em seguida, implantá-la em um ambiente orquestrado com Kubernetes. É importante refletir sobre a evolução entre essas duas etapas, analisando os novos conceitos e as vantagens que surgiram.

Agora, sua atividade é:

1. Descrever, com suas próprias palavras, quais foram os desafios encontrados e o que aprendeu ao realizar a transição da execução de um container local com Docker para uma implantação orquestrada com Kubernetes.
2. Utilize esta tabela para organizar os passos realizados e adicionar capturas de tela (contendo data e horário do relógio do computador na captura de tela):

Checklist:

• ✓ Preparar o Ambiente: Instalar o Git Bash, Docker Desktop e o Minikube.
• ✓ Containerizar a Aplicação: Criar o Dockerfile para definir a imagem da sua aplicação.
• ✓ Construir e Rodar com Docker: Usar o comando docker build para criar a imagem e docker run para executá-la localmente.
• ✓ Iniciar o Cluster Kubernetes: Subir seu ambiente Kubernetes local com o comando minikube start.
• ✓ Definir a Implantação: Criar os arquivos deployment.yaml e service.yaml para descrever como a aplicação deve rodar no Kubernetes.
• ✓ Implantar e Acessar no Kubernetes: Aplicar os arquivos .yaml com kubectl apply e acessar sua aplicação com minikube service.

RESULTADOS

Resultados do experimento:

O aluno deverá submeter um relatório técnico conciso EM PDF contendo:

1. Capturas de tela (prints) para cada item do Checklist de Execução, evidenciando a execução bem-sucedida dos comandos e o acesso às aplicações.
2. O conteúdo final dos arquivos Dockerfile, deployment.yaml e service.yaml criados.
3. Um breve parágrafo (de 5 a 10 linhas) com suas próprias palavras, descrevendo os desafios encontrados e o que aprendeu ao realizar a transição da execução de um container local com Docker para uma implantação orquestrada com Kubernetes.
4. O material deve ser compilado em um único arquivo PDF.

Resultados de Aprendizagem:

Após concluir esta atividade, você terá aprendido:

• A diferença fundamental entre empacotar uma aplicação em uma imagem (Docker) e executar/gerenciar múltiplas instâncias dessa imagem em um ambiente orquestrado (Kubernetes). Entenderá a relação entre Imagem, Container, Pod, Deployment e Service.
• Comandos do Docker (build, run, ps, images) e do kubectl (apply, get pods, get services, version), além de aprender a estrutura básica de arquivos de manifesto declarativos do Kubernetes.

ROTEIRO DE AULA PRÁTICA

NOME DA DISCIPLINA: INFRAESTRUTURA COMO CODIGO

Unidade: U3_GERENCIAMENTO DE INFRAESTRUTURAS COMO CÓDIGO
Aula: A11_Gerenciamento repositórios com GitHub e GitLab

OBJETIVOS

Definição dos objetivos da aula prática:

O objetivo desta aula prática é compreender os fundamentos da automatização do versionamento em projetos de software; implementar práticas de versionamento automático utilizando ferramentas de Integração Contínua e Entrega Contínua (CI/CD) e integrar versionamento com pipelines de CI/CD para otimizar processos de desenvolvimento e entrega.

SOLUÇÃO DIGITAL:

GitBash

• Computador com sistema operacional Windows/Linux/MacOS;
• Conta no GitHub ou GitLab;
• Git instalado: https://git-scm.com/downloads
• Ferramenta CI/CD: GitHub Actions ou GitLab CI.

PROCEDIMENTOS PRÁTICOS E APLICAÇÕES

Procedimento/Atividade nº 1

AUTOMATIZANDO SUA PIPELINE

Atividade proposta: Nesta atividade prática, o estudante irá configurar um projeto para automatizar o versionamento utilizando pipelines CI/CD. A versão do software será automaticamente incrementada ao realizar commits, e o código será automaticamente construído e testado a cada push realizado no repositório.

Procedimentos para a realização da atividade:

1- Configuração inicial

• Crie um repositório no GitHub/GitLab com o nome auto-version-ci-cd.
• Clone o repositório localmente: git clone <url>.

2- Preparação do projeto

• Crie um arquivo inicial chamado version.txt com o conteúdo: v0.0.1.
• Adicione o arquivo ao Git e faça o primeiro commit inicial.

3- Automatização do versionamento com CI/CD

• No repositório, crie um diretório .github/workflows (GitHub) ou .gitlab-ci.yml (GitLab).
• Adicione um arquivo de workflow (por exemplo, versioning.yml) para automatizar a leitura, incremento e commit da versão.
• Crie este arquivo (versioning.yml), da seguinte forma:
  • Quando um commit é enviado para a branch main, a automação é acionada automaticamente.
  • O workflow roda em uma máquina virtual Ubuntu fornecida pelo GitHub Actions.
  • O script verifica o conteúdo do arquivo chamado version.txt, que contém a versão atual do projeto (por exemplo, v0.0.1).
  • Em seguida, ele quebra o número de versão em partes separadas por pontos (.), incrementa a última parte da versão em uma unidade, e salva o novo valor no arquivo version.txt. Por exemplo, se a versão atual é v0.0.1, após o incremento será v0.0.2.
  • O workflow então realiza um commit automático deste arquivo modificado (version.txt) diretamente no repositório, usando o usuário "CI Bot".
  • Finalmente, ele faz um push da nova versão incrementada novamente para a branch main.

4 – Execução e Testes

• Realize alterações e commits no projeto e verifique se a versão é automaticamente incrementada pelo pipeline. Por exemplo, altere o arquivo README.md.

Avaliando os resultados:

Durante esta prática, você executou o processo automatização de uma pipeline.

Agora, sua atividade é:

1. Explicar com suas palavras como a automatização do versionamento com CI/CD pode beneficiar a colaboração em projetos de software.
2. Utilizar esta tabela para organizar os passos realizados e adicionar capturas de tela (contendo data e horário do relógio do computador na captura de tela):

Checklist:

• ✓ Preparar o Ambiente: Instalar o Git Bash.
• ✓ Repositório criado e clonado com sucesso.
• ✓ Arquivo version.txt criado e commit inicial realizado corretamente.
• ✓ Arquivo de workflow criado na pasta .github/workflows/versioning.yml.
• ✓ Workflow configurado corretamente conforme instruções fornecidas.
• ✓ Commit realizado diretamente via interface web do GitHub/GitLab.
• ✓ Incremento automático de versão funcionando corretamente após commits e push no repositório.
• ✓ Captura de tela do pipeline em execução adicionada ao relatório.
• ✓ Breve relatório contendo reflexão entregue corretamente.

RESULTADOS

Resultados do experimento:

O aluno deverá submeter um relatório técnico conciso EM PDF contendo:

1. Capturas de tela (prints) para cada item do Checklist de Execução, evidenciando a execução bem-sucedida dos comandos e o acesso às aplicações.
2. URL do repositório GitHub/GitLab com histórico claro de commits e execução do pipeline (do passo anterior);
3. Breve relatório descrevendo o que foi questionado para reflexão.

Resultados de Aprendizagem:

Após concluir esta atividade, você terá aprendido:

• Implementação de pipelines CI/CD;
• Automatização do versionamento e incremento automático de versões;
• Melhor compreensão do fluxo de versionamento automatizado integrado ao processo de desenvolvimento contínuo.

ROTEIRO DE AULA PRÁTICA

NOME DA DISCIPLINA: INFRAESTRUTURA COMO CODIGO

Unidade: U4_ DESENVOLVIMENTO SEGURO
Aula: A15_ Melhoria contínua com automação segura

OBJETIVOS

Definição dos objetivos da aula prática:

Os objetivos desta aula prática são:

• Compreender conceitos de monitoramento com Prometheus e Grafana.
• Realizar configuração básica de monitoramento utilizando Prometheus.
• Criar dashboards e visualizar dados utilizando Grafana.
• Configurar alertas para automação de respostas simples.

SOLUÇÃO DIGITAL:

Docker.

• Computador com pelo menos 4GB de RAM.
• Sistema operacional Linux ou Windows com Docker instalado.
• Navegador de internet atualizado.

PROCEDIMENTOS PRÁTICOS E APLICAÇÕES

Procedimento/Atividade nº 1

MONITORANDO COM GRAFANA

Atividade proposta: O estudante irá realizar uma configuração básica de monitoramento usando Prometheus para coletar métricas de um serviço simples e Grafana para visualizá-las em tempo real. Além disso, irá configurar um alerta simples para notificação quando uma métrica ultrapassar determinado limite.

Procedimentos para a realização da atividade:

1- Preparação do ambiente

• Baixe e instale o Docker (https://docs.docker.com/get-docker/).
• Verifique a instalação com o comando:

docker --version

2 – Configuração do Prometheus

• Crie uma pasta no seu computador chamada monitoramento;
• Dentro desta pasta, crie um arquivo de texto chamado prometheus.yml, contendo:
  • Definição do intervalo padrão de coleta de métricas (“scrape”) para todos os jobs. Aqui, o Prometheus irá buscar novos dados a cada 15 segundos.
  • Definição da lista de “jobs” que o Prometheus vai monitorar. Cada job agrupa um ou mais alvos (“targets”) de onde ele buscará métricas.
• Salve o arquivo.
• Abra um terminal (powershell) dentro da pasta que você criou (monitoramento).
• Execute o comando abaixo para iniciar o Prometheus:

docker run -d -p 9090:9090 -v ${PWD}prometheus.yml:/etc/prometheus/prometheus.yml prom/prometheus

• Abra o navegador e acesse: http://localhost:9090. Verifique se está funcionando.

3 – Ainda no terminal, dentro da mesma pasta, digite o comando:

docker run -d -p 3000:3000 grafana/Grafana

• Abra o navegador e acesse: http://localhost:3000.
• Use as credenciais padrão para login:
  • Usuário: admin
  • Senha: admin

4 – Adicionando o Prometheus como Data Source no Grafana

• No Grafana, vá ao menu lateral esquerdo e clique em Connections > Data sources.
• Clique em "Add data source".
• Selecione Prometheus.
• No campo URL digite: http://host.docker.internal:9090 (ou http://localhost:9090 se estiver no Linux).
• Clique em "Save & Test" para verificar se o Grafana conectou ao Prometheus corretamente.

5 – Criação do Dashboard no Grafana

• Clique em " Dashboard " (menu lateral esquerdo).
• Clique em "Add new panel".
• Seleciona o Prometheus.
• No campo Metrics browser selecione alguma métrica como exemplo:

100 - (avg by (instance)(irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

• Clique em Save Dashboard (no topo ao lado direito) para adicionar o painel.

6 – Configuração de Alertas

• Ainda no painel criado, clique em Edit.
• Vá até a aba Alert.
• Clique em New alert rule.
• Configure um alerta simples, por exemplo:
  • Condição: Quando a métrica exceder um valor definido (ex.: 80% de uso de CPU).
• Crie e configure as etapas obrigatórias.
• Salve e aplique o alerta.

Avaliando os resultados:

Durante esta prática, você executou o processo de configuração básica para monitoramento usando Prometheus e Grafana para visualização em dashboards.

Agora, sua atividade é:

1. Explique, em suas próprias palavras, qual é o papel do Prometheus e qual é o papel do Grafana no processo de monitoramento realizado nesta atividade prática. Em seguida, descreva brevemente como você configurou e testou o alerta no Grafana.
2. Utilizar esta tabela para organizar os passos realizados e adicionar capturas de tela (contendo data e horário do relógio do computador na captura de tela):

Checklist:

• ✓ Docker instalado e verificado;
• ✓ Arquivo prometheus.yml criado na pasta correta;
• ✓ Prometheus executando corretamente;
• ✓ Grafana executando corretamente;
• ✓ Data source configurado e testado no Grafana;
• ✓ Dashboard criado com uma métrica básica;
• ✓ Alerta configurado e funcional.
• ✓ Breve relatório contendo reflexão entregue corretamente.

RESULTADOS

Resultados do experimento:

O aluno deverá submeter um relatório técnico conciso EM PDF contendo:

1. Capturas de tela (prints) para cada item do Checklist de Execução, evidenciando a execução bem-sucedida dos comandos e o acesso às aplicações.
2. Um relatório breve (com ascapturas de tela das etapas realizadas – dashboard funcionando, configuração de alerta), e a resposta da questão de reflexão proposta.

Resultados de Aprendizagem:

Após concluir esta atividade, você terá aprendido:

• A configurar ambientes básicos de monitoramento.
• A criar e interpretar dashboards.
• A configuração de alertas simples.