Acessar Aplicação Web Docker: Guia Completo

Introdução

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.

Compreendendo o Docker e Executando um Container de Teste

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.

Verificando a Instalação do Docker

Primeiramente, vamos verificar se o Docker está corretamente instalado no seu sistema:

docker --version

Você deve ver uma saída semelhante a esta, mostrando a versão do Docker:

Docker version 20.10.21, build baeda1f

Compreendendo Imagens e Containers Docker

Na terminologia Docker:

Uma imagem Docker (Docker image) é um template contendo o código da aplicação, bibliotecas e dependências.
Um container Docker (Docker container) é uma instância em execução de uma imagem.

Pense numa imagem Docker como um projeto e num container Docker como um edifício criado a partir desse projeto.

Executando seu Primeiro Container Docker

Vamos executar um container simples para verificar se o Docker está funcionando corretamente:

docker run hello-world

Você 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.

Comandos Docker Básicos

Aqui estão alguns comandos Docker essenciais que você deve conhecer:

Para listar todos os containers em execução:

docker ps

Para listar todos os containers (incluindo os parados):

docker ps -a

Para listar todas as imagens Docker no seu sistema:

docker images

Experimente 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).

Criando uma Aplicação Web Simples

Nesta etapa, criaremos uma aplicação web simples usando Python e Flask que podemos implantar num container Docker.

Configurando os Arquivos da Aplicação

Primeiro, vamos criar um novo diretório para nossa aplicação web:

mkdir -p ~/project/my-web-app
cd ~/project/my-web-app

Agora, vamos criar uma aplicação Flask simples. Crie um arquivo chamado app.py usando o editor nano:

nano app.py

Adicione 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.txt

Adicione a seguinte linha ao arquivo:

flask==2.0.1

Pressione Ctrl+O seguido de Enter para salvar o arquivo, depois Ctrl+X para sair do nano.

Criando um Dockerfile

Agora, vamos criar um Dockerfile para definir como nossa aplicação deve ser containerizada:

nano Dockerfile

Adicione 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:

Usa uma imagem Python 3.9-slim leve como base
Define o diretório de trabalho como /app
Copia o arquivo de requisitos e instala as dependências
Copia o código da aplicação
Expõe a porta 5000 para conexões de entrada
Especifica o comando a ser executado quando o container inicia

Pressione Ctrl+O seguido de Enter para salvar o arquivo, depois Ctrl+X para sair do nano.

Construindo a Imagem Docker

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:latest

Agora, verifique se sua imagem foi criada:

docker images | grep my-flask-app

Você deve ver sua imagem recém-criada na lista.

Executando a Aplicação Web em um Container Docker

Agora que construímos nossa imagem Docker, vamos executá-la como um container e acessar a aplicação web.

Executando o Container

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-app

Este 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 container
my-flask-app: Especifica a imagem a ser usada

Verificando se o Container está em Execução

Vamos verificar se nosso container está em execução:

docker ps

Você 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-container

Acessando a Aplicação Web

Agora, você pode acessar a aplicação web de duas maneiras:

Usando curl a partir da linha de comando:

curl http://localhost:5000

Você deve ver a resposta HTML:

<h1>Hello from Docker!</h1><p>This is a simple web application running in a Docker container.</p>

Usando um navegador web:
- Clique no ícone do navegador web no ambiente de trabalho
- Digite http://localhost:5000 na barra de endereço
- Você deve ver "Hello from Docker!" seguido pelo texto da descrição

Compreendendo o Mapeamento de Portas

Quando executamos um container com -p 5000:5000, estamos criando um mapeamento entre:

A porta do host (primeiro número): 5000
A porta do container (segundo número): 5000

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.

Inspecionando os Logs do Container

Se você precisar ver os logs do container (o que pode ser útil para depuração), use:

docker logs my-web-container

Você deve ver as mensagens de inicialização da aplicação Flask.

Parando e Removendo o Container

Para parar o container, use:

docker stop my-web-container

Para remover o container parado, use:

docker rm my-web-container

Você também pode parar e remover um container em um único comando:

docker rm -f my-web-container

Isso é útil durante o desenvolvimento quando você deseja reconstruir e reexecutar seu container rapidamente.

Gerenciamento Avançado de Containers Docker

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.

Executando Múltiplas Instâncias

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-container

Agora, 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-app

Verifique se ambos os containers estão em execução:

docker ps

Você 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-1

Agora você pode acessar a mesma aplicação em duas portas diferentes:

Limites de Recursos do Container

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-2

Agora, 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-app

Este comando cria um container com:

Um máximo de 512MB de memória
Um máximo de 0.5 núcleos de CPU

Verifique se o container está em execução:

docker ps

Variáveis de Ambiente do Container

Variá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-container

Crie uma nova versão do arquivo app.py:

cd ~/project/my-web-app
nano app_env.py

Adicione 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-env

Adicione 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-env

Acesse a aplicação web:

curl http://localhost:5000

Você 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.

Resumo

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:

Compreensão de imagens e containers Docker
Criação de uma aplicação web simples com Flask
Construção de uma imagem Docker com um Dockerfile
Execução e acesso a uma aplicação web containerizada
Gerenciamento de containers Docker com vários comandos
Execução de múltiplas instâncias de container em diferentes portas
Definição de limites de recursos para containers
Uso de variáveis de ambiente para configuração de containers

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.

Como acessar uma aplicação web em execução em um container Docker

Introdução

Compreendendo o Docker e Executando um Container de Teste

Verificando a Instalação do Docker

Compreendendo Imagens e Containers Docker

Executando seu Primeiro Container Docker

Comandos Docker Básicos

Criando uma Aplicação Web Simples

Configurando os Arquivos da Aplicação

Criando um Dockerfile

Construindo a Imagem Docker

Executando a Aplicação Web em um Container Docker

Executando o Container

Verificando se o Container está em Execução

Acessando a Aplicação Web

Compreendendo o Mapeamento de Portas

Inspecionando os Logs do Container

Parando e Removendo o Container

Gerenciamento Avançado de Containers Docker

Executando Múltiplas Instâncias

Limites de Recursos do Container

Variáveis de Ambiente do Container

Resumo