ComfyUI no Google Colab: Gerar Imagens e Vídeos com IA

ComfyUI no Google Colab é hoje o caminho mais barato e prático para gerar imagens e vídeos com IA em qualidade profissional sem precisar de uma placa de vídeo cara em casa. Quem tenta rodar Stable Diffusion, Flux ou Wan 2.2 num notebook com 6 GB de VRAM trava na primeira tentativa. Eu mesmo perdi noites tentando até desistir do hardware local para um cliente do Yeshua que precisava de 80 thumbnails por semana. A combinação ComfyUI no Google Colab resolveu o impasse — e neste guia mostro exatamente como replicar o setup, do zero até o primeiro vídeo renderizado.

TL;DR

• ComfyUI é o frontend node-based padrão para difusão em 2026, suporta SDXL, Flux, Wan 2.2, LTX-Video, Mochi-1, HiDream e Lumina.
• Google Colab entrega uma GPU NVIDIA T4 (16 GB de VRAM) gratuita por sessão, ideal para imagens em 1024 px e vídeos curtos com modelos quantizados.
• O setup leva de 8 a 12 minutos na primeira execução e libera uma URL trycloudflare.com para usar ComfyUI no navegador.
• Para vídeo com Wan 2.2 14B em GPU T4, use versão GGUF Q4 ou Q5 — caso contrário falta VRAM.
• Free tier dá 15 a 30 horas de T4 por semana; Colab Pro (US$ 9,99/mês) destrava acesso ocasional a L4 e A100.

Por que ComfyUI virou o padrão para geração de mídia com IA em 2026

Até 2024, ferramentas como Automatic1111 dominavam Stable Diffusion. ComfyUI virou o jogo por um motivo simples: cada nó representa um passo do pipeline de difusão, e isso significa controle absoluto. Você vê o KSampler, o VAE, o CLIP Text Encoder, o Checkpoint Loader e o Save Image como blocos visuais. Quando um modelo novo sai — Flux, Wan 2.2, LTX-Video, Mochi-1 — a comunidade publica custom nodes em dias, não em meses.

O ecossistema passou de mil pacotes de custom nodes em 2026. ControlNet, IPAdapter, AnimateDiff, Hunyuan, Cosmos da NVIDIA: tudo plugável. Para quem trabalha com IA generativa de forma séria — agência, e-commerce, EAD, mídia social — esse é o ambiente onde os modelos chegam primeiro.

O problema é o hardware. Rodar Flux Dev 12B exige uns 16 GB de VRAM para conforto. Wan 2.2 em fp16 pede 20 GB e leva 1h20min num RTX 4090. Comprar uma placa dessas custa o preço de um carro popular. A saída é nuvem — e a nuvem mais acessível chama-se Google Colab.

Google Colab: a GPU gratuita que destrava ComfyUI sem placa de vídeo

Google Colab é um Jupyter notebook hospedado na infraestrutura do Google. Por trás de cada notebook você tem uma máquina virtual com GPU, geralmente uma NVIDIA Tesla T4 com 16 GB de VRAM no tier gratuito. Para ComfyUI no Google Colab, esse hardware é suficiente para SDXL em 1024 px, Flux quantizado, e vídeos curtos com Wan 2.2 5B ou versões GGUF dos modelos 14B.

A T4 não é a GPU mais rápida do mundo. Ela é Turing, geração 2018, sem suporte nativo a FP8 que Hopper e Ada Lovelace têm. Mesmo assim, ela renderiza uma imagem SDXL em cerca de 25 a 40 segundos e um clipe de 81 frames com Wan 2.2 GGUF em torno de 12 a 20 minutos — números aceitáveis para iterar criativos.

Limites do tier gratuito que você precisa entender

O Colab grátis tem regras que não estão escritas em letras grandes:

• 15 a 30 horas de T4 por semana, ajustadas dinamicamente conforme demanda global.
• Sessão máxima de 12 horas, geralmente cortada antes (4 a 6 horas é o realista).
• Idle timeout de 90 minutos — se você não interagir, o runtime cai.
• Sem garantia de GPU: às vezes só tem CPU disponível em horários de pico.
• Storage da VM é efêmero: tudo que estiver no disco da máquina some quando a sessão acaba.

Quando vale subir para Colab Pro e Pro+

Se você usa ComfyUI no Google Colab uma vez por semana para um cliente, o grátis serve. Para uso profissional contínuo, faz sentido pagar:

• Colab Pro — US$ 9,99/mês: prioridade na fila, GPUs melhores (L4 frequente, A100 ocasional), sessões mais longas, 100 unidades de cômputo por mês.
• Colab Pro+ — US$ 49,99/mês: 500 unidades de cômputo, runtimes que continuam rodando em background por até 24 horas, acesso prioritário a A100.

Uma A100 com 40 GB renderiza Wan 2.2 em fp16 em menos de 15 minutos. Para quem fatura com vídeo gerado, Pro+ paga ele mesmo na primeira semana.

Passo a passo: rodando ComfyUI no Google Colab

A sequência abaixo é o roteiro que uso para subir um ambiente novo. Cole no Colab numa célula só, ou pegue um notebook pronto da comunidade — o comfyui_colab no repositório oficial do ComfyAnonymous é o ponto de partida mais confiável.

Setup inicial e instalação dos custom nodes

1. Em colab.research.google.com, crie um notebook novo e mude o runtime para T4 GPU em Runtime → Change runtime type.
2. Cole o clone do ComfyUI: !git clone https://github.com/comfyanonymous/ComfyUI.
3. Instale dependências: %cd ComfyUI && !pip install -r requirements.txt.
4. Adicione o Manager — o nó que instala outros nós: !git clone https://github.com/ltdrdata/ComfyUI-Manager custom_nodes/ComfyUI-Manager.
5. Inicie com tunelamento Cloudflare: !python main.py --dont-print-server & wait_then_tunnel.
6. Abra a URL trycloudflare.com que aparece no output — esse é seu ComfyUI rodando.

Na primeira vez, depois de carregar um workflow, clique em Manager → Install Missing Custom Nodes → marque tudo → Install. Reinicie o servidor. Pronto.

Conectando o Google Drive para persistir modelos

O maior tropeço de quem começa com ComfyUI no Google Colab é re-baixar 30 GB de modelos toda sessão. A solução é montar o Drive:

from google.colab import drive
drive.mount('/content/drive')
!ln -s /content/drive/MyDrive/ComfyUI/models /content/ComfyUI/models

Guarde checkpoints, LoRAs, VAEs e clip encoders no Drive. O carregamento via I/O fica 3 a 5 vezes mais lento que disco local, mas continua viável — e você economiza horas de download por semana.

Workflow básico de imagem: SDXL, Flux e checkpoints

Um workflow mínimo de SDXL tem sete nós: Checkpoint Loader, dois CLIP Text Encode (positivo e negativo), Empty Latent Image, KSampler, VAE Decode e Save Image. Você arrasta o JSON do workflow para a tela do ComfyUI e ele monta sozinho.

Para começar rápido, baixe um checkpoint base — SDXL Base 1.0 ou JuggernautXL — e jogue em models/checkpoints. Carregue o workflow, escreva o prompt no nó positivo, clique em Queue Prompt. A T4 renderiza em 25 a 35 segundos por imagem em 1024×1024 com 25 steps no sampler DPM++ 2M Karras.

Flux Dev é o passo seguinte. Ele exige o tripé: flux1-dev.safetensors, ae.safetensors (VAE), e dois text encoders (t5xxl e clip_l). Em T4, use a versão GGUF Q4_K_S do Flux que cabe nos 16 GB e mantém qualidade próxima do fp16. Tempo médio: 90 a 120 segundos por imagem 1024 px com 20 steps.

Dicas que aprendi apanhando:

• Sempre habilite --lowvram no comando de start em T4 — força offload dinâmico de pesos para CPU.
• Não use VAE em FP16 com Flux GGUF — gera artefatos. Carregue em BF16.
• Salve seeds que deram certo — ComfyUI tem nó Primitive para fixar seed e iterar prompt sem perder a composição.

Gerando vídeos com IA: Wan 2.2, LTX-Video e Mochi-1

Vídeo é a parte que mais avançou em 2026. Wan 2.2, lançado pela Alibaba, virou referência open-source. Existem três variantes que importam:

• Wan 2.2 5B — cabe em 8 GB de VRAM nativamente, ideal para o tier gratuito.
• Wan 2.2 14B fp16 — qualidade máxima, exige 24 GB+.
• Wan 2.2 14B GGUF Q4/Q5 — empacotamento quantizado que cabe em 16 GB da T4.

O modelo aceita texto-para-vídeo (t2v), imagem-para-vídeo (i2v), texto+imagem-para-vídeo e até áudio-para-vídeo em algumas builds.

Imagem-para-vídeo (i2v) com Wan 2.2 no T4 gratuito

O caso mais útil para produto e marketing é dar movimento a uma imagem estática. O workflow oficial do ComfyUI para Wan 2.2 i2v precisa de:

1. Modelo Wan 2.2 14B i2v em GGUF (Q4_K_S funciona em T4).
2. VAE Wan 2.2 (wan_2.2_vae.safetensors).
3. Text encoder umt5_xxl em fp8.
4. Clip vision clip_vision_h.safetensors.

Depois de carregar, conecte a imagem de origem ao nó WanImageToVideo, ajuste para 49 ou 81 frames, escolha 24 fps, e mande renderizar. Numa T4, espere 12 a 25 minutos por clipe de 4 segundos. Os resultados rivalizam com Runway Gen-3 sem a mensalidade de US$ 35 do plano padrão.

LTX-Video é a alternativa mais rápida. Roda em 6 a 8 minutos por clipe na mesma T4, com qualidade ligeiramente inferior, mas excelente para iterar variantes antes de fechar a versão final no Wan.

Tabela comparativa: rodar ComfyUI no Colab vs PC local vs nuvem dedicada

Critério	ComfyUI no Google Colab (T4 grátis)	PC local com RTX 3060 12 GB	RunPod A100 sob demanda
Custo inicial	R$ 0	R$ 3.500 (placa)	R$ 0
Custo recorrente	R$ 0 a R$ 50/mês (Pro)	R$ 80/mês (energia)	US$ 1,89/h (~R$ 9,50/h)
VRAM disponível	16 GB	12 GB	40 ou 80 GB
Tempo imagem SDXL	30 s	25 s	8 s
Tempo vídeo Wan 2.2 14B	18 min (GGUF Q4)	impossível em fp16	12 min (fp16)
Persistência de modelos	Google Drive (lento)	SSD local (rápido)	Volume da instância
Idle timeout	90 min	nenhum	manual
Censura/política	conteúdo NSFW liberado	livre	livre

A escolha depende do volume. Até 50 renderizações semanais, ComfyUI no Google Colab grátis basta. Entre 50 e 300, o Pro vale. Acima disso, ou comprar GPU local ou alugar A100 por hora no RunPod, Vast.ai ou Lambda Labs.

Otimizando custo e tempo: GGUF, quantização e estratégias para T4

GGUF é o formato de quantização que veio do mundo dos LLMs e adaptado para difusão pelo city96/ComfyUI-GGUF. Em vez de carregar pesos em fp16 (16 bits por parâmetro), você usa Q8 (8 bits), Q5_K_S (~5,5 bits) ou Q4_K_S (~4,5 bits). A perda de qualidade entre fp16 e Q5 é praticamente imperceptível em geração para web e mídia social.

Na prática, isso significa que um modelo de 14 bilhões de parâmetros, que pesaria 28 GB em fp16, cabe em 8 a 10 GB em Q4. É a diferença entre rodar e não rodar no Colab grátis.

Outras táticas que valem o tempo:

• Habilite --use-split-cross-attention no startup — corta uso de VRAM no atention layer.
• Use tiled_vae para imagens acima de 1024 px — decodifica em blocos.
• Mantenha 1 só modelo carregado por vez — descarregue checkpoints anteriores com o nó Unload Model.
• Faça batching pequeno — em T4, batch 1 é mais rápido que 2 porque evita swap.
• Salve outputs direto no Drive com nó Save Image apontando para /content/drive/MyDrive/outputs/.

Armadilhas comuns e como evitar (sessão derrubada, sem VRAM, modelo travado)

Depois de meses ajudando clientes a montar ComfyUI no Google Colab, vi cinco problemas se repetirem:

1. "CUDA out of memory" no meio da geração — quase sempre é VAE em fp16 com modelo Flux/Wan. Mude para BF16 ou ative --cpu-vae.
2. ComfyUI trava em "Loading" — cache corrompido. Reinicie o runtime do Colab inteiro (Runtime → Disconnect and delete runtime) e refaça o setup.
3. Sessão cai antes de terminar o vídeo — idle timeout. Mantenha uma aba ativa rodando um script JavaScript no console: setInterval(() => document.querySelector('colab-toolbar-button#connect').click(), 60000);.
4. URL trycloudflare.com para de responder — Cloudflare derruba túneis ociosos. Reinicie a célula que sobe o tunnel sem reiniciar tudo.
5. Falta de GPU disponível — Google prioriza usuários pagantes. Tente entre 02h e 08h (horário Brasília), demanda cai.

Casos de uso reais: marketing, e-commerce, redes sociais e EAD

O que justifica investir tempo aprendendo ComfyUI no Google Colab? Casos onde economizei (ou ajudei clientes a economizar) dinheiro de verdade:

• E-commerce: gerar 200 variações de fundo para um único produto fotografado uma vez. Custo via agência de fotos: R$ 4.000. Via ComfyUI no Colab: R$ 0.
• Tráfego pago: criar 30 a 50 criativos diferentes para teste A/B no Meta Ads sem pedir designer toda semana. Veja como isso se integra à nossa estratégia em agentes ilimitados no WhatsApp empresarial — porque criativo escalável só funciona se o atendimento aguenta o volume.
• EAD e Moodle: produzir capas de cursos e personagens animados para microlearning. Junto com um aplicativo Moodle personalizado, o conteúdo visual sobe o engajamento dos alunos.
• Redes sociais: animação de carrossel estático em Reels de 5 segundos com Wan 2.2 i2v. Substitui orçamento de motion designer em projetos pequenos.
• Editorial e blog: ilustrações capa de artigos, infográficos ilustrados, mockups de produtos imaginários.

A habilidade que muda o jogo não é gerar uma imagem bonita — qualquer ferramenta SaaS faz isso. É controlar o pipeline inteiro: prompt, seed, CFG, sampler, LoRA, ControlNet, upscaler, refinamento. ComfyUI te dá esse controle. Colab te dá o hardware. Juntos, dão autonomia.

Próximos passos: do Colab para produção (e como a Agathas ajuda)

ComfyUI no Google Colab é ótimo para protótipo e volume médio. Quando o projeto cresce — automação 24/7, integração com WhatsApp, painel administrativo, billing — o setup precisa virar serviço. É aí que entra o trabalho de transformar workflow em API.

Na Agathas Web fazemos exatamente essa ponte: subimos ComfyUI numa instância GPU dedicada (RunPod, Vast.ai ou GCP), expomos os workflows como endpoint REST, e plugamos em sistemas existentes — site, CRM, bot de atendimento, gateway de pagamento. O cliente envia um briefing e recebe imagens ou vídeos prontos sem precisar abrir o Colab toda vez.

Se você chegou até aqui, já tem o suficiente para subir um ambiente próprio. Comece pelo grátis, sinta o tempo de cada modelo, descubra onde o atalho do GGUF salva sua sessão. Depois, se precisar virar isso em operação séria, conversa com a gente — a parte de infraestrutura, segurança e integração é nossa especialidade desde 2008.

Conclusão

Gerar imagem e vídeo com IA deixou de ser privilégio de quem tem RTX 4090 em casa. ComfyUI no Google Colab democratizou o acesso: você abre o navegador, clica em Run, e em 10 minutos está renderizando Wan 2.2 com qualidade de estúdio. O segredo não está no modelo da semana — está em dominar o pipeline node-based, entender os limites da T4, e usar quantização GGUF quando faltar VRAM. Comece simples: um workflow SDXL hoje, Flux amanhã, Wan 2.2 no fim de semana. Cada hora investida no ComfyUI volta como semanas de trabalho criativo automatizado.