Aula Prática Infraestrutura como Código

Veja o Manual / Enunciado Completo

Roteiro
Aula Prática

INFRAESTRUTURA COMO CODIGO

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.