(31)994408961- RESOLVIDO-Aula Pratica Infraestrutura como Codigo (3 Atividades)

Prévia do material em texto

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/
Públic2o
	· 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:
o 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
Públic3o
	· 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.
Públic4o
	· --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
Públic5o
	
· 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).
Públic6o
	· 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
Públic7o
	· 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 adicionarcapturas 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.
Públic8oPasso a Passo Realizado
Print Correspondente
Arquivo Dockerfile criado na raiz do projeto.
[Insira o Print]
Resultado do comando docker images
mostrando a imagem seu-nome/hello-app:v1.
[Insira o Print]
Resultado do comando docker ps mostrando o
container minha-app em execução.
[Insira o Print]
Aplicação acessível em http://localhost:8080
(fase Docker).
[Insira o Print]
Cluster Minikube em execução (saída do
comando minikube status).
[Insira o Print]
	· 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.
Públic9o
Roteiro Aula Prática
INFRAESTRUTURA COMO CODIGO
Público
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:
Públic2o
	
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 .
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.
Públic3o
	
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):
	
	Passo a Passo Realizado
	Print Correspondente
	
	
	Repositório criado
	[Insira o Print]
	
	
	Repositório clonado.
	[Insira o Print]
	
	
	Arquivo version.txt e workflow/versioning.yml
criados e commitados
	[Insira o Print]
	
	
	Execução da pipeline;
	[Insira o Print]
	
Públic4o
	
	Incremento automático da versão funcionando
corretamente.
	[Insira o Print]
	
	
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.
Públic5o
Roteiro Aula Prática
INFRAESTRUTURA COMO CODIGO
Público
ROTEIRO DE AULA PRÁTICA
NOME DA DISCIPLINA: INFRAESTRUTURA COMO CODIGO
Públic2o
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çãobá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:
Públic3o
	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.
Públic4o
	
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.
Públic5o
	· 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):
Públic6oPasso a Passo Realizado
Print Correspondente
Prometheus executando corretamente.
[Insira o Print]
Grafana executando corretamente.
[Insira o Print]
Data source criado com uma métrica básica.
[Insira o Print]
Alerta configurado.
[Insira o Print]
	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.
Públic7o
image4.jpeg
image5.png
image6.jpeg
image7.jpeg
image8.jpeg
image9.png
image10.jpeg
image11.png
image12.png
image13.png
image14.png
image15.png
image16.jpeg
image17.jpeg
image18.jpeg
image19.jpeg
image20.jpeg
image21.jpeg
image22.jpeg
image23.png
image24.jpeg
image25.jpeg
image26.jpeg
image27.jpeg
image28.png
image29.png
image1.png
image2.png
image3.png