Ambiente de simulação nativo em Kubernetes para avaliação de estratégias de Content Steering em streaming de vídeo DASH utilizando algoritmos de Aprendizado por Reforço sob latências de rede reais.
Explore a documentação »
Ver Demonstração
·
Reportar Bug
·
Solicitar Recurso
Índice
Este projeto simula o mecanismo de Content Steering em streaming adaptativo DASH usando múltiplas estratégias de decisão inteligente. O objetivo principal é treinar e avaliar algoritmos de Aprendizado por Reforço (como Multi-Armed Bandits e PPO) para selecionar dinamicamente a melhor fonte de entrega (CDN) com base nas flutuações de latência, jitter e bufferbloat em tempo real.
Principais recursos:
- Servidor de Steering em FastAPI contendo as estratégias:
epsilon_greedy(MAB clássico)ucb1(Upper Confidence Bound)linucb(Contextual Bandit)thompson_sampling(Contextual Thompson Sampling)ppo_hybrid(Algoritmo de política híbrida para bitrate + steering)round_robin,random,no_steeringeoracle_best_choice(baselines)
- Ambiente Kubernetes nativo (Kind) para emulação e isolamento de rede real entre os pods.
- 3 servidores de cache simulados (Delivery Nodes) usando Caddy para entrega local via HTTPS.
- Pipeline automatizado de testes com orquestração via Playwright em navegadores Headless.
- Módulo completo de análise para agregação de logs e geração de gráficos estatísticos com qualidade de publicação.
Abaixo estão listadas as tecnologias e ferramentas utilizadas para construir este ecossistema:
Siga as instruções a seguir para configurar e executar a simulação localmente no seu ambiente de desenvolvimento.
Para rodar este simulador, você precisará de:
- Sistema Operacional: Linux (recomendado Ubuntu/Debian) ou WSL2 no Windows.
- Gerenciador de Dependências Python:
uvinstalado localmente.curl -LsSf https://astral.sh/uv/install.sh | sh - Docker e Kind instalados e em execução.
- kubectl para gerenciamento de recursos do Kubernetes.
- mkcert para geração de certificados SSL locais confiáveis:
sudo apt install mkcert mkcert -install
- Clone o repositório do projeto:
git clone https://github.com/alissonpef/content_steering.git
- Instale as dependências de Python do projeto de forma isolada com o
uv:uv sync
- Obtenha a pasta de dataset necessária:
- Baixe os arquivos do dataset do Google Drive Link.
- Coloque a pasta baixada como
./datasetno diretório raiz do projeto (de forma que o caminho para o manifesto do vídeo seja./dataset/Eldorado/4sec/avc/manifest.mpd).
O sistema é implantado de forma totalmente emulada e nativa dentro de um cluster Kubernetes rodando via Kind:
flowchart TD
classDef browser fill:#f9f9f9,stroke:#333,stroke-width:2px;
classDef proxy fill:#4caf50,stroke:#fff,stroke-width:2px,color:#fff;
classDef frontend fill:#ffeb3b,stroke:#f57f17,stroke-width:2px,color:#333;
classDef backend fill:#00bcd4,stroke:#fff,stroke-width:2px,color:#fff;
classDef storage fill:#607d8b,stroke:#fff,stroke-width:2px,color:#fff;
Browser("🌐 Navegador Cliente (Dash.js)"):::browser
subgraph Cluster ["☸️ Cluster Kubernetes (Kind)"]
Gateway{"🛡️ Nginx Gateway"}:::proxy
UI["💻 dash-client (UI Nginx)"]:::frontend
RL["🧠 steering-server (FastAPI)"]:::backend
subgraph CDNNodes ["📦 Nós de Entrega CDN (Caddy)"]
direction LR
Node1[("Delivery Node 1")]:::storage
Node2[("Delivery Node 2")]:::storage
Node3[("Delivery Node 3")]:::storage
end
end
Browser -- "1. Carrega UI (localhost:5000/)" --> Gateway
Gateway -- "Rota: /" --> UI
Browser -- "2. Obtém Decisão (/steering/coords)" --> Gateway
Gateway -- "Rota: /steering" --> RL
Browser -- "3. Baixa Chunks (/nodeX/...)" --> Gateway
Gateway -- "Rota: /node[1-3]" --> CDNNodes
RL -. "Sondas de Latência em Backgound" .-> CDNNodes
- Nginx Gateway: Atua como o ponto único de entrada do cluster (proxy reverso), roteando o tráfego e lidando com políticas de CORS.
- dash-client: Servidor web que serve os arquivos estáticos da interface web e do player customizado do
dash.js. - steering-server: O backend inteligente contendo os algoritmos de Aprendizado por Reforço e monitoramento de latência ativa e passiva.
- CDNNodes: Nós de entrega (servidores Caddy) que armazenam os blocos do vídeo de simulação. Eles utilizam a ferramenta
tc(Traffic Control) do kernel Linux para injetar latência, jitter e perturbações configuradas nos cenários de teste.
Para interagir com o ambiente e executar as simulações, utilize os utilitários de infraestrutura e execução disponibilizados no repositório.
-
Primeiro, gere os certificados HTTPS necessários localmente:
uv run python tasks.py generate_certificates
-
Inicialize o cluster local do Kubernetes (Kind) e implante todos os manifestos de simulação:
uv run python tasks.py setup_k8s
-
Acesse o painel de visualização no seu navegador local em:
Caso a porta não esteja respondendo automaticamente, faça o redirecionamento manual da porta com o comando:
kubectl port-forward deployment/gateway 5000:80
-
Para destruir o cluster e interromper o ambiente de simulação:
uv run python tasks.py stop_k8s
O projeto conta com um script automatizado que executa toda a bateria de testes e compila os resultados para os diferentes modelos e cenários.
Você pode orquestrar uma execução de simulação em lote completa executando o seguinte script:
uv run python scripts/run_all.pyEsse pipeline realiza as seguintes ações de forma automatizada:
- Roda as simulações do navegador cliente de forma headless via Playwright para cada algoritmo e cenário configurados.
- Copia os arquivos de log gerados internamente de dentro dos pods no Kubernetes para o host local.
- Agrega todos os arquivos de log brutos.
- Processa estatísticas de desempenho e gera gráficos comparativos de latência média, arrependimento acumulado (cumulative regret), acurácia de escolha ótima e gráficos de séries temporais das simulações.
- Gera um relatório em markdown consolidado chamado
analise_cenarios.md.
Caso prefira processar dados brutos que já estejam salvos no diretório local, você pode acionar os scripts de análise de forma independente:
- Agregação de logs por estratégia e cenário:
uv run python analysis/aggregate_logs.py linucb --suffix_pattern _baseline
- Geração de gráficos comparativos gerais (Latência e Regret):
uv run python analysis/plotting/generate_compare_graphs.py
- Geração de gráficos de distribuição de escolha (Heatmaps):
uv run python analysis/plotting/generate_compare_graphs.py --metric dynamic_best_server_latency
- Geração de gráficos de corridas de simulação individuais:
uv run python analysis/plotting/generate_graphs.py
- Geração de boxplots estatísticos comparativos:
uv run python analysis/plotting/generate_boxplots.py
Todos os resultados estruturados e figuras finais em formato pronto para artigos acadêmicos serão armazenados na pasta data/results/.
Contribuições são o que tornam a comunidade open source um lugar tão incrível para aprender, inspirar e criar. Qualquer contribuição que você fizer será muito apreciada.
Se você tiver alguma sugestão que tornaria isso melhor, por favor faça o fork do repositório e crie um pull request. Você também pode simplesmente abrir uma issue com a tag "enhancement". Não se esqueça de dar uma estrela ao projeto! Obrigado novamente!
- Faça o Fork do Projeto
- Crie a sua Branch de Funcionalidade (
git checkout -b feature/FuncionalidadeIncrivel) - Commit suas Mudanças (
git commit -m 'Adicione alguma FuncionalidadeIncrivel') - Faça o Push para a Branch (
git push origin feature/FuncionalidadeIncrivel) - Abra um Pull Request
Distribuído sob a Licença MIT. Veja LICENSE.txt para mais informações.
Álisson Pereira Ferreira - alissonpef@gmail.com
Link do Projeto: https://github.com/alissonpef/content_steering
Este projeto baseia-se e expande os trabalhos dos seguintes repositórios:
- Content Steering Tutorial — repositório base para a lógica inicial de desvio de fluxo.
- Content Steering K8s Simulator — base para o ecossistema de simulação distribuída em cluster Kubernetes local.