Aula Prática Infraestrutura como Código (3 Atividades)

Aula Prática Infraestrutura como Código (3 Atividades)

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úblico3
• 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).
o Adicione o seguinte conteúdo ao arquivo:
• Defina uma imagem base oficial do Python 3.9
Público4
• 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úblico5
 –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úblico6
• 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:
o Defina a Implantação, criando um gerenciador de aplicação chamado hello-appdeployment.
o Especifique o Número de Réplicas, garantindo que 2 instâncias (Pods) da sua
aplicação estejam sempre em execução.
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.
o Defina o Container, instruindo cada instância a criar um container usando a
imagem Docker local seu-nome/hello-app:v1.
o 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:
o 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.
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úblico7
o Mapeie as Portas, recebendo tráfego na porta 8080 e o redirecionando para a
targetPort (porta de destino) 8080 dos containers dentro dos Pods.
o 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úblico8
• 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):
Passo 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]
Checklist:
✓ Preparar o Ambiente: Instalar o Git Bash, Docker Desktop e o Minikube.
Público9
✓ 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úblico
INFRAESTRUTURA COMO CODIGO
Roteiro
Aula Prática
Público2
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úblico3
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:
o Quando um commit é enviado para a branch main, a automação é acionada
automaticamente.
o O workflow roda em uma máquina virtual Ubuntu fornecida pelo GitHub Actions.
o 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).
o 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 O workflow então realiza um commit automático deste arquivo modificado
(version.txt) diretamente no repositório, usando o usuário “CI Bot”.
o 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úblico4
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úblico5
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úblico
INFRAESTRUTURA COMO CODIGO
Roteiro
Aula Prática
Público2
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:
Público3
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:
o 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.
o 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úblico4
docker run -d -p 3000:3000 grafana/Grafana
 Abra o navegador e acesse: http://localhost:3000.
 Use as credenciais padrão para login:
o Usuário: admin
o 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úblico5
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úblico6
 Clique em New alert rule.
 Configure um alerta simples, por exemplo:
o 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):
Passo 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]
Público7
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

Aula Prática Infraestrutura como Código (3 Atividades)

O seu trabalho é disponibilizado pronto, respondido e nas normas já na mesma hora aqui em nosso site na sua área de downloads e também no seu e-mail.

Em quanto tempo recebo o portfólio?

Os envios são imediatos. Após sua compra, o trabalho já é disponibilizado instantaneamente aqui em nosso site e no seu e-mail.

E se o portfólio que comprei precisar de correção?

Caso haja alguma solicitação de correção/alteração por parte do tutor, basta entrar em contato conosco pelo WhatsApp que providênciaremos sem custo algum.

Qual o formato do arquivo?

Os arquivos são enviados em formato Word e são editáveis.

Caso eu tiver alguma dúvida, terei suporte no pós venda?

Sim, com certeza. Basta clicar no ícone do WhatsApp no cantinho da tela. Será um prazer atendê-lo(a).