Este tutorial irá guiá-lo através do processo de acesso a uma aplicação web em execução num container Docker. Você aprenderá os fundamentos dos containers Docker, implantará uma aplicação web simples e descobrirá como acessá-la a partir da sua máquina host. Este conhecimento é essencial para o desenvolvimento e teste de aplicações web utilizando Docker.
Docker é uma plataforma que utiliza a containerização para empacotar aplicações e suas dependências em conjunto. Isso permite que as aplicações sejam executadas de forma consistente em diferentes ambientes.
Primeiramente, vamos verificar se o Docker está corretamente instalado no seu sistema:
docker --versionVocê deve ver uma saída semelhante a esta, mostrando a versão do Docker:
Docker version 20.10.21, build baeda1fNa terminologia Docker:
Pense numa imagem Docker como um projeto e num container Docker como um edifício criado a partir desse projeto.
Vamos executar um container simples para verificar se o Docker está funcionando corretamente:
docker run hello-worldVocê deve ver uma saída como esta:
Hello from Docker!
This message shows that your installation appears to be working correctly.
To generate this message, Docker took the following steps:
1. The Docker client contacted the Docker daemon.
2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
3. The Docker daemon created a new container from that image which runs the
executable that produces the output you are currently reading.
4. The Docker daemon streamed that output to the Docker client, which sent it
to your terminal.
...Isso confirma que o Docker está funcionando corretamente no seu sistema.
Aqui estão alguns comandos Docker essenciais que você deve conhecer:
docker psdocker ps -adocker imagesExperimente estes comandos e observe as saídas. Após executar o container hello-world, você deverá vê-lo listado quando executar docker ps -a (mas não em docker ps, pois ele sai imediatamente após exibir a mensagem).
Nesta etapa, criaremos uma aplicação web simples usando Python e Flask que podemos implantar num container Docker.
Primeiro, vamos criar um novo diretório para nossa aplicação web:
mkdir -p ~/project/my-web-app
cd ~/project/my-web-appAgora, vamos criar uma aplicação Flask simples. Crie um arquivo chamado app.py usando o editor nano:
nano app.pyAdicione o seguinte código Python ao arquivo:
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello():
return "<h1>Hello from Docker!</h1><p>This is a simple web application running in a Docker container.</p>"
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000)Pressione Ctrl+O seguido de Enter para salvar o arquivo, depois Ctrl+X para sair do nano.
Em seguida, crie um arquivo requirements.txt para especificar as dependências da nossa aplicação:
nano requirements.txtAdicione a seguinte linha ao arquivo:
flask==2.0.1Pressione Ctrl+O seguido de Enter para salvar o arquivo, depois Ctrl+X para sair do nano.
Agora, vamos criar um Dockerfile para definir como nossa aplicação deve ser containerizada:
nano DockerfileAdicione o seguinte conteúdo ao arquivo:
FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app.py .
EXPOSE 5000
CMD ["python", "app.py"]Este Dockerfile faz o seguinte:
/appPressione Ctrl+O seguido de Enter para salvar o arquivo, depois Ctrl+X para sair do nano.
Agora, vamos construir uma imagem Docker a partir do nosso Dockerfile:
docker build -t my-flask-app .A flag -t marca nossa imagem com o nome my-flask-app. O . no final especifica que o Dockerfile está no diretório atual.
Você deve ver uma saída semelhante a esta:
Sending build context to Docker daemon x.xxxkB
Step 1/6 : FROM python:3.9-slim
---> xxxxxxxxxx
Step 2/6 : WORKDIR /app
---> Using cache
---> xxxxxxxxxx
...
Successfully built xxxxxxxxxx
Successfully tagged my-flask-app:latestAgora, verifique se sua imagem foi criada:
docker images | grep my-flask-appVocê deve ver sua imagem recém-criada na lista.
Agora que construímos nossa imagem Docker, vamos executá-la como um container e acessar a aplicação web.
Para executar o container e mapear a porta para que possamos acessar a aplicação web, use o seguinte comando:
docker run -d -p 5000:5000 --name my-web-container my-flask-appEste comando faz o seguinte:
-d: Executa o container em modo detached (em segundo plano)-p 5000:5000: Mapeia a porta 5000 do container para a porta 5000 no host--name my-web-container: Atribui um nome ao containermy-flask-app: Especifica a imagem a ser usadaVamos verificar se nosso container está em execução:
docker psVocê deve ver uma saída semelhante a esta:
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
xxxxxxxxxxxx my-flask-app "python app.py" xx seconds ago Up xx seconds 0.0.0.0:5000->5000/tcp my-web-containerAgora, você pode acessar a aplicação web de duas maneiras:
curl http://localhost:5000Você deve ver a resposta HTML:
<h1>Hello from Docker!</h1><p>This is a simple web application running in a Docker container.</p>http://localhost:5000 na barra de endereçoQuando executamos um container com -p 5000:5000, estamos criando um mapeamento entre:
Isso significa que qualquer tráfego enviado para a porta 5000 na máquina host será encaminhado para a porta 5000 dentro do container.
Também poderíamos usar números de porta diferentes. Por exemplo, -p 8080:5000 mapearia a porta 8080 do host para a porta 5000 do container, permitindo que você acessasse a aplicação em http://localhost:8080.
Se você precisar ver os logs do container (o que pode ser útil para depuração), use:
docker logs my-web-containerVocê deve ver as mensagens de inicialização da aplicação Flask.
Para parar o container, use:
docker stop my-web-containerPara remover o container parado, use:
docker rm my-web-containerVocê também pode parar e remover um container em um único comando:
docker rm -f my-web-containerIsso é útil durante o desenvolvimento quando você deseja reconstruir e reexecutar seu container rapidamente.
Agora que você executou com sucesso sua aplicação web em um container Docker, vamos explorar alguns recursos e técnicas adicionais para gerenciar containers Docker.
Você pode executar múltiplas instâncias da sua aplicação web em diferentes portas. Isso é útil para testes ou para executar diferentes versões do seu aplicativo simultaneamente.
Primeiro, vamos parar e remover nosso container anterior:
docker rm -f my-web-containerAgora, vamos executar duas instâncias da nossa aplicação web em diferentes portas:
docker run -d -p 5000:5000 --name web-app-1 my-flask-app
docker run -d -p 5001:5000 --name web-app-2 my-flask-appVerifique se ambos os containers estão em execução:
docker psVocê deve ver dois containers em execução:
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
xxxxxxxxxxxx my-flask-app "python app.py" xx seconds ago Up xx seconds 0.0.0.0:5001->5000/tcp web-app-2
xxxxxxxxxxxx my-flask-app "python app.py" xx seconds ago Up xx seconds 0.0.0.0:5000->5000/tcp web-app-1Agora você pode acessar a mesma aplicação em duas portas diferentes:
O Docker permite que você defina limites de recursos para seus containers. Isso é útil para evitar que um container consuma muitos recursos do sistema.
Vamos parar e remover nossos containers anteriores:
docker rm -f web-app-1 web-app-2Agora, vamos executar um container com limites de memória e CPU:
docker run -d -p 5000:5000 --name limited-container --memory=512m --cpus=0.5 my-flask-appEste comando cria um container com:
Verifique se o container está em execução:
docker psVariáveis de ambiente são uma maneira comum de configurar aplicações em containers Docker. Vamos modificar nossa aplicação Flask para usar uma variável de ambiente:
docker rm -f limited-containerCrie uma nova versão do arquivo app.py:
cd ~/project/my-web-app
nano app_env.pyAdicione o seguinte código:
import os
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello():
app_name = os.environ.get('APP_NAME', 'Default App')
return f"<h1>Hello from {app_name}!</h1><p>This is a simple web application running in a Docker container.</p>"
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000)Pressione Ctrl+O seguido por Enter para salvar o arquivo, depois Ctrl+X para sair do nano.
Crie um novo Dockerfile:
nano Dockerfile-envAdicione o seguinte conteúdo:
FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app_env.py ./app.py
EXPOSE 5000
CMD ["python", "app.py"]Pressione Ctrl+O seguido por Enter para salvar o arquivo, depois Ctrl+X para sair do nano.
Construa uma nova imagem:
docker build -t my-flask-app-env -f Dockerfile-env .Agora, execute o container com uma variável de ambiente:
docker run -d -p 5000:5000 --name env-container -e APP_NAME="Customized App" my-flask-app-envAcesse a aplicação web:
curl http://localhost:5000Você deve ver:
<h1>Hello from Customized App!</h1><p>This is a simple web application running in a Docker container.</p>Isso demonstra como passar a configuração para suas aplicações em container usando variáveis de ambiente.
Neste laboratório, você aprendeu como acessar uma aplicação web em execução em um container Docker. Você criou uma aplicação web Flask simples, a containerizou usando o Docker e a acessou da sua máquina host usando o mapeamento de portas.
Conceitos-chave abordados:
Essas habilidades fornecem uma base sólida para trabalhar com aplicações containerizadas e o ajudarão a implantar e testar aplicações web de forma eficiente usando o Docker.
