Skip to content

Commit e7c34d0

Browse files
nataliagranatonataliagranato
authored
Add files via upload
1 parent 379dfbd commit e7c34d0

10 files changed

Lines changed: 746 additions & 7 deletions

‎Dockerfile‎

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
# Dockerfile para testes justos de performance
2+
FROM python:3.9-slim-buster
3+
4+
# Desabilita cache de pip para builds determinísticos
5+
ENV PIP_NO_CACHE_DIR=1
6+
7+
# Define diretório de trabalho
8+
WORKDIR /app
9+
10+
# Copia script de teste
11+
COPY heavy_task.py .
12+
13+
# Define número de iterações padrão
14+
ENV ITERATIONS="100000000"
15+
16+
# Adiciona label para identificação em limpezas
17+
LABEL project="docker-offload-tests"
18+
19+
# Comando de execução
20+
CMD ["python", "heavy_task.py"]

‎METODOLOGIA.md‎

Lines changed: 130 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,130 @@
1+
# Metodologia de Teste Justa - Docker Offload vs Local
2+
3+
## Problemas Identificados nos Testes Anteriores
4+
5+
### ❌ **Cache Interferindo nos Resultados**
6+
- Docker Build Cache estava sendo reutilizado entre testes
7+
- Cache da nuvem vs cache local criava comparação desigual
8+
- Layers CACHED mascaravam o tempo real de build
9+
10+
### ❌ **Builds Não Idênticos**
11+
- Teste local usava cache de builds anteriores
12+
- Teste cloud aproveitava cache compartilhado
13+
- Tempos de download/build não eram comparáveis
14+
15+
### ❌ **Contextos Misturados**
16+
- Docker Offload já estava ativo durante "teste local"
17+
- Falta de controle explícito sobre contexto Docker
18+
- Ambiente não era resetado entre testes
19+
20+
## ✅ **Metodologia Corrigida**
21+
22+
### **1. Limpeza Completa Entre Testes**
23+
```bash
24+
# Remove containers e imagens
25+
docker-compose down --remove-orphans
26+
docker rmi $(docker images --filter "reference=docker-offload-tests*" -q)
27+
28+
# Limpa cache de build
29+
docker builder prune -f
30+
31+
# Limpa sistema Docker
32+
docker system prune -f
33+
```
34+
35+
### **2. Controle Explícito do Contexto Docker**
36+
```bash
37+
# Para teste local
38+
docker context use default
39+
40+
# Para teste cloud
41+
docker context use [cloud-context]
42+
```
43+
44+
### **3. Builds Forçados Sem Cache**
45+
```yaml
46+
# docker-compose.yaml
47+
services:
48+
heavy_runner:
49+
build:
50+
context: .
51+
no_cache: true # ← Força rebuild completo
52+
```
53+
54+
```bash
55+
# Execução forçada
56+
docker-compose up --build --force-recreate --no-deps
57+
```
58+
59+
### **4. Ambiente Docker Determinístico**
60+
```dockerfile
61+
# Dockerfile
62+
FROM python:3.9-slim-buster
63+
64+
# Desabilita cache de pip
65+
ENV PIP_NO_CACHE_DIR=1
66+
67+
# Label para identificação
68+
LABEL project="docker-offload-tests"
69+
```
70+
71+
## **Script de Teste Justo**
72+
73+
O novo script `run_fair_tests.sh` implementa:
74+
75+
### **🔄 Sequência de Teste**
76+
1. **Limpeza inicial** → Remove todo cache e containers
77+
2. **Teste local** → Contexto default + build completo
78+
3. **Limpeza intermediária** → Reset total do ambiente
79+
4. **Teste cloud** → Contexto cloud + build completo
80+
5. **Comparação** → Análise de resultados justos
81+
82+
### **📊 Medições Precisas**
83+
- **Tempo total**: Build + execução + overhead
84+
- **Sem cache**: Ambos testes sem vantagem de cache
85+
- **Mesmo build**: Dockerfile e compose idênticos
86+
- **Controle de contexto**: Alternância explícita entre local/cloud
87+
88+
### **🎯 Garantias de Justiça**
89+
- ✅ Mesma imagem base para ambos testes
90+
- ✅ Mesmo código executado
91+
- ✅ Mesmo número de iterações
92+
- ✅ Cache zerado antes de cada teste
93+
- ✅ Ambiente limpo entre testes
94+
- ✅ Contexto Docker controlado explicitamente
95+
96+
## **Execução dos Testes Corrigidos**
97+
98+
```bash
99+
# Executa testes justos
100+
./run_fair_tests.sh
101+
102+
# Resultados salvos em:
103+
# - test_results.csv (dados brutos)
104+
# - Terminal output (relatório em tempo real)
105+
```
106+
107+
### **Resultados Esperados**
108+
109+
Com a metodologia corrigida, esperamos:
110+
111+
1. **Tempo de build similar** (sem cache para ambos)
112+
2. **Diferença real de performance** entre hardware local vs cloud
113+
3. **Medição precisa** do overhead de rede vs benefício de hardware
114+
4. **Comparação justa** sem vantagens artificiais de cache
115+
116+
### **Fatores Que Ainda Podem Influenciar**
117+
118+
1. **Hardware cloud vs local**: Diferença legítima de CPU/RAM
119+
2. **Overhead de rede**: Latência para transferir imagem/dados
120+
3. **Otimizações de runtime**: Docker engine na nuvem vs local
121+
4. **Concorrência de recursos**: Outros processos no sistema local
122+
123+
Esses fatores representam as **diferenças reais** que queremos medir, não artefatos de teste mal configurado.
124+
125+
## **Próximos Passos**
126+
127+
1. **Executar** `./run_fair_tests.sh`
128+
2. **Analisar** resultados com metodologia corrigida
129+
3. **Documentar** diferenças reais de performance
130+
4. **Expandir** para testes com workloads ainda mais pesados

‎README.md‎

Lines changed: 129 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,137 @@
1-
# Repository Sample
1+
# Docker Offload Performance Tests - Testes Justos
22

3-
Este é um repositório de exemplo criado para demonstrar o uso do GitHub.
3+
Este projeto implementa uma metodologia justa para comparar a performance entre Docker Local e Docker Offload (Build Cloud), eliminando interferências de cache e garantindo condições equivalentes.
44

5-
## Uso
5+
## 🎯 Objetivo
66

7-
Ao acessar o repositório, no canto superior direito clique em `Use this template` para começar.
7+
Realizar uma comparação **verdadeiramente justa** entre:
8+
- **Docker Local**: Execução em hardware local sem offload
9+
- **Docker Offload**: Execução na nuvem usando Docker Build Cloud
810

9-
## Contato
11+
## 🚀 Execução dos Testes Justos
1012

11-
Para mais informações, entre em contato através do [GitHub Sponsors](https://github.com/sponsors/Tech-Preta).
13+
Para executar os testes com metodologia corrigida:
14+
15+
```bash
16+
./run_fair_tests.sh
17+
```
18+
19+
O script irá:
20+
1. ✅ Limpar todo cache antes dos testes
21+
2. 🏠 Executar teste local (contexto `default`)
22+
3. 🧹 Limpar ambiente entre testes
23+
4. ☁️ Executar teste cloud (contexto `docker-cloud`)
24+
5. 📊 Gerar relatório comparativo
25+
26+
## 📁 Arquivos do Projeto
27+
28+
### **Arquivos Principais**
29+
- **`run_fair_tests.sh`**: Script de testes justos (PRINCIPAL)
30+
- **`heavy_task.py`**: Tarefa computacional intensiva para teste
31+
- **`Dockerfile`**: Container determinístico sem cache
32+
- **`docker-compose.yaml`**: Configuração com builds forçados
33+
34+
### **Documentação**
35+
- **`README.md`**: Este arquivo (instruções principais)
36+
- **`METODOLOGIA_CORRIGIDA.md`**: Explicação da metodologia justa
37+
38+
## 🔧 Garantias de Teste Justo
39+
40+
### ✅ **Cache Eliminado**
41+
- Limpeza completa antes e entre testes
42+
- `no_cache: true` no docker-compose
43+
- `docker builder prune -f` forçado
44+
45+
### ✅ **Builds Idênticos**
46+
- Mesmo Dockerfile para ambos cenários
47+
- Mesmo docker-compose.yaml
48+
- Flags `--build --force-recreate --no-deps`
49+
50+
### ✅ **Contextos Controlados**
51+
- Alternância explícita: `default` ↔ `docker-cloud`
52+
- Verificação de contexto ativo
53+
- Reset entre testes
54+
55+
### ✅ **Medição Precisa**
56+
- Tempo total: build + execução
57+
- Resultados salvos em CSV
58+
## 🧪 Tarefa de Teste
59+
60+
O projeto usa uma tarefa computacional intensiva em Python que executa:
61+
- Operações matemáticas (sin, cos, sqrt)
62+
- Loop de 100 milhões de iterações (configurável)
63+
- Medição precisa de tempo de execução
64+
65+
### Configurar Intensidade
66+
```bash
67+
# No docker-compose.yaml
68+
environment:
69+
ITERATIONS: "200000000" # Para teste mais pesado
70+
```
71+
72+
## 🔧 Pré-requisitos
73+
74+
1. **Docker Desktop** com Docker Offload habilitado
75+
2. **Docker Build Cloud** configurado
76+
3. **Python 3** (para verificação local)
77+
4. **bc** para cálculos (já disponível no sistema)
78+
79+
### Verificar Configuração
80+
```bash
81+
# Verificar contextos Docker
82+
docker context ls
83+
84+
# Verificar contexto ativo
85+
docker context show
86+
87+
# Verificar Build Cloud
88+
docker buildx ls
89+
```
90+
91+
## 📊 Resultados Esperados
92+
93+
Com a metodologia justa, esperamos medir:
94+
95+
### **Diferenças Reais**
96+
- 🖥️ Hardware: CPU/RAM cloud vs local
97+
- 🌐 Overhead: Rede e transferência de dados
98+
- ⚡ Otimizações: Runtime Docker otimizado na nuvem
99+
- 🏗️ Build: Performance sem cache para ambos
100+
101+
### **Formato dos Resultados**
102+
- **CSV**: `test_results.csv` com dados brutos
103+
- **Terminal**: Relatório em tempo real com percentuais
104+
- **Comparação**: Diferença percentual automática
105+
106+
## 🎯 Cenários de Uso Ideais
107+
108+
Docker Offload é especialmente vantajoso para:
109+
110+
1. **CPU Intensivo**: Como demonstrado nos testes
111+
2. **Builds Pesados**: Projetos com muitas dependências
112+
3. **Hardware Limitado**: Laptops, VMs, ambientes restritos
113+
4. **Equipes**: Cache compartilhado entre desenvolvedores
114+
5. **CI/CD**: Builds paralelos e escaláveis
115+
116+
## 🚀 Executar Testes Agora
117+
118+
```bash
119+
# Executa testes justos imediatamente
120+
./run_fair_tests.sh
121+
122+
# Monitora resultados em tempo real
123+
# Arquivos gerados:
124+
# - test_results.csv (dados)
125+
# - Output detalhado no terminal
126+
```
127+
128+
---
129+
130+
**✅ Projeto padronizado para testes justos e reproduzíveis!**
131+
3. Experimente com workloads reais do seu projeto
132+
4. Compare os resultados com diferentes tipos de hardware local
133+
5. Teste cenários específicos da sua aplicação (builds, ML training, etc.)
12134

13135
---
14136

15-
Feito com ❤️ por [Natália Granato](https://github.com/nataliagranato).
137+
Para mais informações sobre Docker Offload, consulte o documento principal `docker-offload.md`.

0 commit comments

Comments
 (0)