Node Docker App

📋 Descrição do Projeto

Aplicação web desenvolvida em Node.js que demonstra a containerização com Docker. O projeto consiste em um servidor HTTP que gera e gerencia um arquivo JSON contendo informações de data e hora do sistema.

🎯 Objetivo da Aplicação

Esta aplicação foi desenvolvida para:

• Demonstrar a criação de uma API REST simples com Node.js puro (sem frameworks)
• Ilustrar o processo de containerização de aplicações Node.js com Docker
• Gerar e manipular arquivos JSON dinamicamente
• Servir como exemplo prático de servidor web básico

🏗️ Estrutura do Projeto

node_docker_app/
├── server.js         # Código-fonte da aplicação Node.js
├── Dockerfile        # Instruções para construção da imagem Docker
├── package.json      # Metadados e dependências do projeto
├── data.json         # Arquivo gerado automaticamente (não versionado)
└── README.md         # Documentação do projeto

⚙️ Como Funciona a Aplicação

Funcionamento do Servidor

1. Inicialização: Quando o servidor inicia, ele:

   • Importa os módulos necessários (http, fs, path)
   • Define a porta 3000 como porta de escuta
   • Gera imediatamente o arquivo data.json com a data/hora atual
   • Inicia o servidor HTTP

2. Rotas Disponíveis:

   GET / - Rota principal

   • Gera um novo arquivo data.json com a data/hora atual
   • Retorna uma resposta JSON com informações completas
   • Exemplo de resposta:

   {
     "message": "Servidor Node.js rodando!",
     "data": {
       "timedate": "14/11/2025, 15:30:45"
     },
     "info": "Arquivo data.json atualizado"
   }

   GET /data.json - Rota para acessar o arquivo

   • Lê e retorna o conteúdo do arquivo data.json
   • Retorna erro 404 se o arquivo não existir
   • Exemplo de resposta:

   {
     "timedate": "14/11/2025, 15:30:45"
   }

   Outras rotas - Retorna erro 404

   {
     "error": "Rota não encontrada"
   }

Geração do Arquivo data.json

A função generateDataFile() é responsável por:

• Obter a data e hora atual do sistema
• Formatar no padrão brasileiro (DD/MM/AAAA, HH:MM:SS)
• Usar o fuso horário America/Sao_Paulo
• Escrever no arquivo data.json no formato JSON formatado (2 espaços)
• Registrar a operação no console

Formato da Data

A data é formatada usando toLocaleString() com as seguintes configurações:

• Localidade: pt-BR (português brasileiro)
• Fuso horário: America/Sao_Paulo
• Formato: DD/MM/AAAA, HH:MM:SS
• Sistema de horas: 24 horas (hour12: false)

🐳 Docker - Como Funciona

Dockerfile Explicado

FROM node:18-alpine
# Usa a imagem oficial do Node.js versão 18 baseada em Alpine Linux
# Alpine é uma distribuição Linux minimalista (apenas ~5MB)

WORKDIR /app
# Define /app como diretório de trabalho dentro do contêiner
# Todos os comandos subsequentes serão executados neste diretório

COPY server.js .
# Copia o arquivo server.js do host para /app no contêiner

EXPOSE 3000
# Documenta que o contêiner escuta na porta 3000
# Não publica a porta automaticamente, apenas documentação

CMD ["node", "server.js"]
# Define o comando padrão ao iniciar o contêiner
# Executa: node server.js

Processo de Build

docker build -t node_docker_app .

Este comando:

1. Lê o Dockerfile no diretório atual
2. Baixa a imagem base node:18-alpine (se não existir localmente)
3. Cria as camadas da imagem conforme as instruções
4. Copia os arquivos necessários
5. Gera uma imagem final com a tag node_docker_app

Processo de Execução

docker run -d -p 3000:3000 --name meu_node_app node_docker_app

Este comando:

• -d: Executa em segundo plano (detached mode)
• -p 3000:3000: Mapeia porta 3000 do host → porta 3000 do contêiner
• --name meu_node_app: Atribui um nome ao contêiner
• node_docker_app: Usa a imagem criada anteriormente

🚀 Guia de Uso Completo

1️⃣ Pré-requisitos

• Docker instalado (Download aqui)
• Porta 3000 disponível no sistema

2️⃣ Construir a Imagem

# Navegue até o diretório do projeto
cd node_docker_app

# Construa a imagem Docker
docker build -t node_docker_app .

Saída esperada:

[+] Building 15.2s (8/8) FINISHED
 => [internal] load build definition from Dockerfile
 => [internal] load metadata for docker.io/library/node:18-alpine
 => [1/3] FROM docker.io/library/node:18-alpine
 => [2/3] WORKDIR /app
 => [3/3] COPY server.js .
 => exporting to image
 => => naming to docker.io/library/node_docker_app

3️⃣ Executar o Contêiner

# Modo daemon (background)
docker run -d -p 3000:3000 --name meu_node_app node_docker_app

# Ou modo interativo (ver logs em tempo real)
docker run -p 3000:3000 --name meu_node_app node_docker_app

4️⃣ Verificar Status

# Listar contêineres em execução
docker ps

# Ver todos os contêineres (incluindo parados)
docker ps -a

# Verificar logs
docker logs meu_node_app

# Seguir logs em tempo real
docker logs -f meu_node_app

5️⃣ Testar a Aplicação

Via cURL:

# Teste da rota principal
curl http://localhost:3000

# Teste da rota data.json
curl http://localhost:3000/data.json

# Teste com formatação bonita
curl http://localhost:3000 | json_pp

Via Navegador:

• Acesse: http://localhost:3000
• Ou: http://localhost:3000/data.json

Via Postman/Insomnia:

• Method: GET
• URL: http://localhost:3000

6️⃣ Acessar o Arquivo Dentro do Contêiner

# Ver conteúdo do data.json
docker exec meu_node_app cat /app/data.json

# Listar arquivos no contêiner
docker exec meu_node_app ls -la /app

# Entrar no contêiner (shell interativo)
docker exec -it meu_node_app sh

🔧 Comandos Úteis Docker

Gerenciamento do Contêiner

# Parar o contêiner
docker stop meu_node_app

# Iniciar o contêiner parado
docker start meu_node_app

# Reiniciar o contêiner
docker restart meu_node_app

# Remover o contêiner (precisa estar parado)
docker rm meu_node_app

# Forçar remoção (mesmo se estiver rodando)
docker rm -f meu_node_app

Gerenciamento de Imagens

# Listar imagens locais
docker images

# Remover a imagem
docker rmi node_docker_app

# Remover imagens não utilizadas
docker image prune

# Ver histórico de camadas da imagem
docker history node_docker_app

Limpeza Geral

# Remover contêineres parados
docker container prune

# Remover tudo (contêineres, redes, imagens não usadas)
docker system prune -a

# Ver uso de espaço do Docker
docker system df

🧪 Exemplos de Teste

Teste 1: Verificar Atualização Automática

# Faça duas requisições consecutivas
curl http://localhost:3000
sleep 2
curl http://localhost:3000

# A data deve ser diferente em cada resposta

Teste 2: Verificar Persistência do Arquivo

# Acesse a rota principal (gera o arquivo)
curl http://localhost:3000

# Acesse a rota do arquivo
curl http://localhost:3000/data.json

# As datas devem ser iguais

Teste 3: Testar Rotas Inexistentes

# Deve retornar erro 404
curl http://localhost:3000/rota-invalida

📊 Monitoramento

# Ver uso de recursos do contêiner
docker stats meu_node_app

# Ver processos rodando no contêiner
docker top meu_node_app

# Inspecionar detalhes do contêiner
docker inspect meu_node_app

🐛 Troubleshooting

Problema: Porta já em uso

# Verificar o que está usando a porta 3000
lsof -i :3000  # Linux/Mac
netstat -ano | findstr :3000  # Windows

# Usar outra porta
docker run -d -p 3001:3000 --name meu_node_app node_docker_app

Problema: Contêiner não inicia

# Ver logs de erro
docker logs meu_node_app

# Verificar se a imagem foi construída corretamente
docker images | grep node_docker_app

# Reconstruir a imagem
docker build --no-cache -t node_docker_app .

Problema: Arquivo data.json não é criado

# Entrar no contêiner e verificar
docker exec -it meu_node_app sh
ls -la /app
cat /app/data.json

# Verificar logs do Node.js
docker logs meu_node_app

🛠️ Tecnologias Utilizadas

• Node.js 18: Runtime JavaScript
• HTTP nativo: Módulo http do Node.js
• File System: Módulo fs para manipulação de arquivos
• Path: Módulo path para manipulação de caminhos
• Docker: Containerização da aplicação
• Alpine Linux: Sistema operacional base da imagem

📈 Possíveis Melhorias Futuras

• Adicionar rota para histórico de datas
• Implementar persistência de dados com volume Docker
• Adicionar testes automatizados
• Implementar API de configuração de fuso horário
• Adicionar suporte a CORS
• Criar endpoint de health check
• Adicionar variáveis de ambiente para configuração
• Implementar logging estruturado
• Adicionar Docker Compose para orquestração

📝 Notas Importantes

• O arquivo data.json é gerado dentro do contêiner e não persiste após remover o contêiner
• Para persistir dados, seria necessário usar Docker Volumes
• A data/hora reflete o sistema onde o Docker está rodando
• A aplicação não tem dependências externas (usa apenas módulos nativos do Node.js)
• O formato de data pode variar dependendo da localização do sistema