(31)994408961- RESOLVIDO-Relatorio de Aula Pratica - Infraestrutura como Codigo

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 realizadose 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.
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
image4.jpeg
image5.png
image6.jpeg
image7.jpeg
image8.jpeg
image9.png
image10.jpeg
image11.png
image12.png
image13.png
image14.png
image15.png
image1.png
image2.png
image3.png