As a pet project, I was interested in using image generation models to virtually try on a piece of clothing. Given a photo of yourself and an outfit, generate that photo with you wearing the outfit.

Surprisingly, there weren’t many APIs set up to do this — the only ones I found were quite expensive. But I did find lots of tutorials for running virtual try-on models yourself using a tool called ComfyUI. ComfyUI lets you create workflows with diffusion models like Stable Diffusion and FLUX.1. I had heard about security concerns with some ComfyUI plugins, and I don’t have a great GPU at home anyway, so I decided to try running it on a Google Cloud Platform VM.

Skipping to the end, here’s a few fun examples of what I ended up with using ComfyUI:

While these took ~30sec, I can generate other 1024x1024 images in ~11sec, or less than $0.005 each. Compare that with $0.04/image for DALL-E.

This post will get you set up with ComfyUI on GCP and generating some images, and I’ll share the full virtual-try on workflow in another post.

Getting a GCP VM with GPU (~30min)

Before we can create a VM, we need to request GPU quota. This seems to be automatically granted within a couple minutes.

1. In Cloud Console, navigate to the page “Quotas & System Limits” (within “IAM & Admin”)
2. In the Filter box at the top of the table, filter “Name” to “GPUs (all regions)”
3. In the 3-dot menu, select “Edit quota”
4. Enter your new value (e.g. “1”) and an explanation (e.g. “Running comfyui”)

Once you get the quota approval email, you can create a VM. This is your first choice — what amount of performance are you willing to pay for?

I went with the cheapest option I could find, which is an n1-standard-4 VM + Nvidia T4 GPU:

• 4 vCPUs
• 16GB RAM
• 16GB VRAM
• 200GB disk (minimum)
• Estimated cost: $160/mo + $255/mo for GPU = ~$415/mo, or ~$0.01/min (check pricing calculator for latest)
  • $295/mo with sustained use (30% off)
  • $267/mo with a 1 year commitment

But note that this may be too small for some workflows, especially with the full-size FLUX.1 dev model (almost 24GB)! A step up would be g2-standard-4, which comes with an Nvidia L4 GPU:

• 4 vCPUs
• 16GB RAM
• 24 VRAM
• 200GB disk (minimum)
• Estimated cost: $536/mo
  • $219/mo with a “Spot” preemptible VM, which can be stopped at any time

From some quick tests, L4 took less than half the time (2.3x faster) to generate an image compared to T4, with SD1.5 512x512 images in ~1.4s and SDXL 1024x1024 images in ~11.2s. Up to you if that is worth 80%+ more per month. I may come back to it when I need faster iterations…

Once you’ve picked a VM, navigate to the page “VM Instances” (within “Compute Engine”) and click “Create instance”. Then:

1. On the “Machine configuration” page:
   1. Give it a descriptive name (e.g. comfyui-server)
   2. Select a region + zone (I went with the defaults)
   3. Switch to the “GPUs” tab and select your GPU type (T4, L4, etc)
   4. Select your machine configuration (vCPUs + RAM)
2. On the “OS and Storage” page
   1. Under “Operating system and storage”, choose “Change”
   2. Choose your OS (I went with Debian 12 for x86/64, more on why later)
   3. Switch the disk to 200GB or more — you will be storing lots of models + generations, and storage is relatively cheap compared to the machine
   4. I used a balanced persistent disk; TBD if another option would be better
3. Click “Create”!

Next, while not required, I recommend installing Tailscale for simple & secure access via SSH and browser. It creates a virtual private network with all your devices on it. I believe you could use the gcloud CLI for this, but I already had Tailscale; whatever you do, I recommend avoiding opening the ComfyUI server up externally.

1. Sign into Tailscale, or sign up for free; and ensure the app is installed+active on your local computer
2. Navigate to your Tailscale dashboard, choose “Add device > Linux server”, generate the install script, and copy it.
3. In Cloud Console, select your VM and click “SSH”
4. Run your copied command
5. Now you can SSH from your own terminal — find the IP address Tailscale has assigned comfyui-server (on macOS, you can copy this in one click via the menubar plugin) and run ssh [email protected]

Almost ready for ComfyUI! Lastly you need to install the Nvidia drivers + CUDA toolkit. This step had me pulling out my hair, until I found this GCP script, which handles all the downloads/commands. Though note that the script worked on Debian 12 (x86), but not on Ubuntu 22.04 (x86). The script may reboot your VM along the way (it will tell you when this happens), after which you will need to SSH back into your machine and run the script again to continue. There are quick verification commands for each step, which I recommend running to ensure it is complete before you move on.

Before we install ComfyUI, one last thing I found useful: adding swap memory. Swap memory is like extra RAM but using your hard drive, so it’s slower. For some reason, this was necessary for workflows involving larger models like SDXL (maybe something expects system memory to be larger than the GPU memory?). Anyway, these commands will add 4GB of swap memory:

1. sudo fallocate -l 4G /swapfile
2. sudo chmod 600 /swapfile
3. sudo mkswap /swapfile
4. sudo swapon /swapfile
5. free -h — should confirm that the 4GB swap is now active
6. Finally, make it persistent across reboots: run sudo nano /etc/fstab and add this line to the end: /swapfile none swap sw 0 0

Installing ComfyUI (~10min)

Alright, now we’re ready for ComfyUI!

First, install Miniconda and activate an environment (instructions)

1. conda create --name comfyui python=3.9
   1. For some reason I got dependency errors with the default python 3.13
2. conda activate comfyui
3. conda install pip

Make sure git is installed

1. sudo apt update
2. sudo apt install git

Install ComfyUI and its dependencies (instructions)

1. conda install pytorch torchvision torchaudio pytorch-cuda=12.1 -c pytorch -c nvidia
   • Make sure you use the Nvidia instructions!
2. git clone https://github.com/comfyanonymous/ComfyUI.git
3. cd ComfyUI
4. pip install -r requirements.txt

ComfyUI doesn’t come with a model built-in, so let’s download Stable Diffusion 1.5 from Hugging Face:

• cd ~/ComfyUI/models/checkpoints
• wget https://huggingface.co/stable-diffusion-v1-5/stable-diffusion-v1-5/resolve/main/v1-5-pruned-emaonly.safetensors

Finally, start the ComfyUI server:

1. cd ~/ComfyUI
2. python main.py --listen
3. Look up the Tailscale IP for your device (again) and visit http://YOUR_IP:8188 in a browser on your local computer

And that’s it! You can now start generating images. Here’s a workflow to get you started — just download this JSON file and drop it onto your ComfyUI tab: sd15_example.json. Click the “Queue” button to start generating.

You’re all set!

Next steps

To see what you can do with ComfyUI, check out:

• ComfyUI subreddit - latest news, lots of cool workflows
• Latent Vision YT channel - creator of some of the most popular plugins, has a great series on “ComfyUI Zero 2 Hero”
• Huggingface + CivitAI - lots of models and extensions; few people seem to use the stock models

You’ll likely also want to install some custom plugins/nodes, which extend what ComfyUI can do. ComfyUI Manager is a great place to start.

If you’re going to be starting & restarting the GCP VM often, I recommend this approach to auto start ComfyUI on boot:

1. Create a script: ~/start-comfyui.sh

#! /bin/bash

alias conda='/home/<USERNAME>/miniconda3/bin/conda'
source /home/<USERNAME>/miniconda3/bin/activate
conda activate comfyui

cd /home/<USERNAME>/ComfyUI
nohup python main.py --listen > output.log 2>&1 &

2. Create a systemd service: sudo nano /etc/systemd/system/comfyui.service

[Unit]
Description=Run ComfyUI server at boot
After=network.target

[Service]
ExecStart=/home/<USERNAME>/start-comfyui.sh
Type=oneshot
RemainAfterExit=true

[Install]
WantedBy=multi-user.target

3. Start the service

sudo systemctl daemon-reload
sudo systemctl start comfyui.service
sudo systemctl enable comfyui.service

Lastly, a shameless plug — if you want to evaluate a ComfyUI workflow across multiple inputs, check out https://evals.tbuckley.com. I’ll be writing a follow-up post about how to use this.

Happy generating!