Cara Menjalankan Alur Kerja Flux ComfyUI sebagai API

Flux adalah model text-to-image canggih yang dikembangkan oleh Black Forest Labs, menampilkan kemampuan pembuatan gambar tingkat lanjut. ComfyUI, di sisi lain, adalah antarmuka model difusi yang kuat dan modular dengan sistem alur kerja berbasis node. Ketika digabungkan, mereka menciptakan solusi yang kuat untuk pembuatan gambar berkualitas tinggi yang dapat diakses secara terprogram.

Menggabungkan kekuatan model Flux dengan fleksibilitas ComfyUI dapat secara signifikan meningkatkan alur kerja pembuatan Gambar AI Anda. Tutorial ini akan memandu Anda melalui proses menjalankan Flux di ComfyUI sebagai API, membuka kemungkinan untuk otomatisasi dan integrasi dengan sistem lain.

💡

Sebelum kita membahas pengaturan API Flux ComfyUI kita, mari kita bicara tentang alat pengujian. Saat bekerja dengan API, memiliki platform pengujian yang andal sangat penting, dan Apidog menonjol sebagai alternatif Postman utama di ruang ini.

Apidog menawarkan ekosistem pengembangan API komprehensif dengan fitur-fitur seperti pengujian otomatis, server mock, dan pembuatan dokumentasi terperinci, semuanya dalam satu platform terpadu.

button

Tidak seperti Postman, Apidog menyediakan manajemen siklus hidup API yang mulus dengan alat debugging bawaan yang secara khusus dioptimalkan untuk alur kerja kompleks seperti yang ada di ComfyUI. Antarmuka intuitifnya membuat pengujian endpoint Flux ComfyUI Anda jauh lebih efisien, dengan fitur kolaboratif yang memungkinkan anggota tim untuk berbagi dan menyempurnakan konfigurasi API bersama-sama.

Jika Anda serius tentang pengembangan dan pengujian API, solusi all-in-one Apidog akan merampingkan alur kerja Anda secara signifikan.

button

Menyiapkan Lingkungan Flux ComfyUI Anda

Sebelum masuk ke implementasi API, kita perlu menyiapkan lingkungan yang diperlukan. Kita akan menggunakan Modal, platform cloud yang memudahkan untuk menjalankan aplikasi tanpa server dengan akses GPU.

Prasyarat untuk Flux ComfyUI

Akun Modal (buat satu di modal.com)
Python 3.11 atau lebih baru
Git terinstal di mesin lokal Anda
Pemahaman dasar tentang Python dan konsep API

Membangun Image Container Flux ComfyUI

Langkah pertama kita adalah membuat image container yang mencakup semua komponen yang diperlukan untuk menjalankan Flux di ComfyUI. Mari kita uraikan prosesnya:

import json
import subprocess
import uuid
from pathlib import Path
from typing import Dict

import modal

# Create a base image with necessary dependencies
image = (
    modal.Image.debian_slim(python_version="3.11")
    .apt_install("git")  # Install git for cloning ComfyUI
    .pip_install("fastapi[standard]==0.115.4")  # Web dependencies
    .pip_install("comfy-cli==1.3.5")  # ComfyUI CLI tool
    .run_commands(
        "comfy --skip-prompt install --nvidia --version 0.3.10"  # Install ComfyUI
    )
)

Kode ini membuat image Modal berdasarkan Debian Slim dengan Python 3.11, kemudian menginstal Git, FastAPI, dan comfy-cli. Alat comfy-cli kemudian digunakan untuk menginstal ComfyUI itu sendiri.

Meningkatkan Flux ComfyUI Anda dengan Node Kustom

Untuk membuka fungsionalitas tambahan, kita akan menambahkan node kustom ke instalasi ComfyUI kita:

image = (
    image.run_commands(
        "comfy node install was-node-suite-comfyui@1.0.2"  # Install WAS Node Suite
    )
    # Add more custom nodes as needed
)

WAS Node Suite menyediakan fungsionalitas tambahan untuk pembuatan dan manipulasi gambar, yang sangat berguna saat bekerja dengan model Flux.

Menyiapkan Unduhan Model Flux ComfyUI

Manajemen model yang efisien sangat penting untuk pengalaman yang lancar. Kita akan membuat fungsi untuk mengunduh model Flux dan menyimpannya dalam volume persisten:

def hf_download():
    from huggingface_hub import hf_hub_download

    flux_model = hf_hub_download(
        repo_id="Comfy-Org/flux1-schnell",
        filename="flux1-schnell-fp8.safetensors",
        cache_dir="/cache",
    )

    # Symlink the model to the ComfyUI directory
    subprocess.run(
        f"ln -s {flux_model} /root/comfy/ComfyUI/models/checkpoints/flux1-schnell-fp8.safetensors",
        shell=True,
        check=True,
    )

# Create a persistent volume for model storage
vol = modal.Volume.from_name("hf-hub-cache", create_if_missing=True)

# Add the model download function to our image
image = (
    image.pip_install("huggingface_hub[hf_transfer]==0.26.2")
    .env({"HF_HUB_ENABLE_HF_TRANSFER": "1"})
    .run_function(
        hf_download,
        volumes={"/cache": vol},
    )
)

# Add our workflow JSON to the container
image = image.add_local_file(
    Path(__file__).parent / "workflow_api.json", "/root/workflow_api.json"
)

Kode ini mendefinisikan fungsi untuk mengunduh model Flux Schnell dari Hugging Face dan membuat symlink ke direktori model ComfyUI. Kita juga membuat Modal Volume untuk mempertahankan model yang diunduh di antara proses.

Pengembangan Flux ComfyUI Interaktif

Sebelum digunakan sebagai API, ada baiknya untuk menguji alur kerja Flux ComfyUI Anda secara interaktif:

app = modal.App(name="example-comfyui", image=image)

@app.function(
    allow_concurrent_inputs=10,  # Needed for UI startup
    max_containers=1,  # Limit to one container for interactive use
    gpu="L40S",  # Powerful GPU for Flux model inference
    volumes={"/cache": vol},  # Mount our cached models
)
@modal.web_server(8000, startup_timeout=60)
def ui():
    subprocess.Popen(
        "comfy launch -- --listen 0.0.0.0 --port 8000",
        shell=True
    )

Anda dapat menjalankan ini dengan modal serve your_file.py dan mengakses UI di browser Anda untuk mendesain dan menguji alur kerja Anda sebelum mengimplementasikan API.

Mengimplementasikan API Flux ComfyUI

Sekarang untuk acara utama - mengubah ComfyUI menjadi endpoint API untuk inferensi model Flux:

@app.cls(
    allow_concurrent_inputs=10,  # Allow multiple concurrent API calls
    scaledown_window=300,  # Keep containers alive for 5 minutes after use
    gpu="L40S",
    volumes={"/cache": vol},
)
class ComfyUI:
    @modal.enter()
    def launch_comfy_background(self):
        # Start ComfyUI server in the background
        cmd = "comfy launch --background"
        subprocess.run(cmd, shell=True, check=True)

    @modal.method()
    def infer(self, workflow_path: str = "/root/workflow_api.json"):
        # Check ComfyUI server health
        self.poll_server_health()

        # Run workflow with comfy-cli
        cmd = f"comfy run --workflow {workflow_path} --wait --timeout 1200 --verbose"
        subprocess.run(cmd, shell=True, check=True)

        # Find output image
        output_dir = "/root/comfy/ComfyUI/output"
        workflow = json.loads(Path(workflow_path).read_text())
        file_prefix = [
            node.get("inputs")
            for node in workflow.values()
            if node.get("class_type") == "SaveImage"
        ][0]["filename_prefix"]

        # Return image as bytes
        for f in Path(output_dir).iterdir():
            if f.name.startswith(file_prefix):
                return f.read_bytes()

    @modal.fastapi_endpoint(method="POST")
    def api(self, item: Dict):
        from fastapi import Response

        # Load workflow template
        workflow_data = json.loads(
            (Path(__file__).parent / "workflow_api.json").read_text()
        )

        # Insert the prompt
        workflow_data["6"]["inputs"]["text"] = item["prompt"]

        # Generate unique ID for this request
        client_id = uuid.uuid4().hex
        workflow_data["9"]["inputs"]["filename_prefix"] = client_id

        # Save modified workflow
        new_workflow_file = f"{client_id}.json"
        json.dump(workflow_data, Path(new_workflow_file).open("w"))

        # Run inference
        img_bytes = self.infer.local(new_workflow_file)

        return Response(img_bytes, media_type="image/jpeg")

    def poll_server_health(self) -> Dict:
        import socket
        import urllib

        try:
            # Check if server is healthy
            req = urllib.request.Request("<http://127.0.0.1:8188/system_stats>")
            urllib.request.urlopen(req, timeout=5)
            print("ComfyUI server is healthy")
        except (socket.timeout, urllib.error.URLError) as e:
            # Stop container if server is unhealthy
            print(f"Server health check failed: {str(e)}")
            modal.experimental.stop_fetching_inputs()
            raise Exception("ComfyUI server is not healthy, stopping container")

Kelas ini mendefinisikan fungsionalitas API inti:

launch_comfy_background memulai server ComfyUI saat container diluncurkan
infer menjalankan alur kerja dan mengembalikan gambar yang dihasilkan
api adalah endpoint FastAPI yang menerima prompt, memodifikasi alur kerja, dan mengembalikan gambar
poll_server_health memastikan server ComfyUI responsif

Menguji API Flux ComfyUI Anda

Untuk menguji API Anda, Anda dapat membuat skrip klien sederhana:

import requests
import base64
from PIL import Image
import io
import argparse

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--prompt", default="A surreal landscape with floating islands and ethereal light")
    parser.add_argument("--endpoint", default="<https://your-modal-endpoint.modal.run>")
    args = parser.parse_args()

    # Send request to the API
    response = requests.post(
        f"{args.endpoint}/api",
        json={"prompt": args.prompt}
    )

    # Handle the response
    if response.status_code == 200:
        # Save and display the image
        image = Image.open(io.BytesIO(response.content))
        image.save("flux_output.jpg")
        print(f"Image generated and saved as flux_output.jpg")

        # Optional: display the image if in a suitable environment
        try:
            image.show()
        except:
            pass
    else:
        print(f"Error: {response.status_code}, {response.text}")

if __name__ == "__main__":
    main()

Mengoptimalkan Kinerja Flux ComfyUI

Untuk memastikan API Anda tetap responsif dan hemat biaya, pertimbangkan untuk menerapkan optimasi berikut:

1. Memory Snapshotting untuk Cold Start Flux ComfyUI yang Lebih Cepat

Cold start dapat menjadi hambatan untuk aplikasi tanpa server. Modal menawarkan memory snapshotting yang dapat secara signifikan mengurangi waktu startup:

@app.cls(
    allow_concurrent_inputs=10,
    gpu="L40S",
    volumes={"/cache": vol},
    memory_snapshot=modal.MemorySnapshot(
        snapshot_path="/root/comfy-snapshot",
        boot_command="comfy launch --background",
    ),
)
class ComfyUI:
    # Rest of the class implementation

2. Request Batching untuk Flux ComfyUI

Untuk skenario throughput tinggi, mengimplementasikan request batching dapat meningkatkan efisiensi:

@modal.method()
def batch_inference(self, prompts: list[str]):
    results = []
    for prompt in prompts:
        # Create workflow for each prompt
        client_id = uuid.uuid4().hex
        workflow_data = json.loads(
            (Path(__file__).parent / "workflow_api.json").read_text()
        )
        workflow_data["6"]["inputs"]["text"] = prompt
        workflow_data["9"]["inputs"]["filename_prefix"] = client_id

        # Save and process workflow
        new_workflow_file = f"{client_id}.json"
        json.dump(workflow_data, Path(new_workflow_file).open("w"))
        img_bytes = self.infer.local(new_workflow_file)
        results.append(img_bytes)

    return results

Fitur API Flux ComfyUI Tingkat Lanjut

Menyesuaikan Parameter Alur Kerja

Perluas API Anda untuk memungkinkan parameter tambahan selain hanya prompt:

@modal.fastapi_endpoint(method="POST")
def advanced_api(self, item: Dict):
    from fastapi import Response

    workflow_data = json.loads(
        (Path(__file__).parent / "workflow_api.json").read_text()
    )

    # Insert the prompt
    workflow_data["6"]["inputs"]["text"] = item["prompt"]

    # Optional: Set additional parameters if provided
    if "negative_prompt" in item:
        workflow_data["7"]["inputs"]["text"] = item["negative_prompt"]

    if "cfg_scale" in item:
        workflow_data["3"]["inputs"]["cfg"] = item["cfg_scale"]

    if "steps" in item:
        workflow_data["3"]["inputs"]["steps"] = item["steps"]

    # Generate unique ID
    client_id = uuid.uuid4().hex
    workflow_data["9"]["inputs"]["filename_prefix"] = client_id

    # Save and process workflow
    new_workflow_file = f"{client_id}.json"
    json.dump(workflow_data, Path(new_workflow_file).open("w"))
    img_bytes = self.infer.local(new_workflow_file)

    return Response(img_bytes, media_type="image/jpeg")

Menangani Model Flux ComfyUI yang Berbeda

Izinkan peralihan antara model Flux yang berbeda:

@modal.fastapi_endpoint(method="POST")
def model_selection_api(self, item: Dict):
    from fastapi import Response

    workflow_data = json.loads(
        (Path(__file__).parent / "workflow_api.json").read_text()
    )

    # Insert the prompt
    workflow_data["6"]["inputs"]["text"] = item["prompt"]

    # Select model if specified
    if "model" in item:
        if item["model"] == "flux-schnell":
            workflow_data["2"]["inputs"]["ckpt_name"] = "flux1-schnell-fp8.safetensors"
        elif item["model"] == "flux-turbo":
            workflow_data["2"]["inputs"]["ckpt_name"] = "flux1-turbo-fp8.safetensors"

    # Generate unique ID
    client_id = uuid.uuid4().hex
    workflow_data["9"]["inputs"]["filename_prefix"] = client_id

    # Save and process workflow
    new_workflow_file = f"{client_id}.json"
    json.dump(workflow_data, Path(new_workflow_file).open("w"))
    img_bytes = self.infer.local(new_workflow_file)

    return Response(img_bytes, media_type="image/jpeg")

Memantau API Flux ComfyUI Anda

Mengimplementasikan pemantauan yang tepat sangat penting untuk penerapan produksi:

@app.cls(
    # Other parameters
    monitor_agent=modal.MonitorAgent(),
)
class ComfyUI:
    # Existing implementation

    def log_request(self, prompt, model, processing_time):
        # Custom logging implementation
        print(f"Generated image for prompt: '{prompt}' using {model} model in {processing_time:.2f}s")

Kesimpulan: Melepaskan Kekuatan Flux ComfyUI sebagai API

Dengan mengikuti tutorial ini, Anda telah mempelajari cara mengubah ComfyUI dengan model Flux menjadi layanan API yang terukur dan siap produksi. Pendekatan ini menawarkan beberapa keuntungan:

Skalabilitas: Tangani beberapa permintaan secara bersamaan dengan penskalaan container otomatis
Fleksibilitas: Sesuaikan alur kerja berdasarkan kebutuhan pengguna
Integrasi: Hubungkan kemampuan pembuatan gambar Anda dengan aplikasi lain
Efektivitas biaya: Bayar hanya untuk komputasi yang Anda gunakan

Kombinasi infrastruktur tanpa server Modal, sistem alur kerja ComfyUI yang kuat, dan pembuatan gambar canggih Flux menciptakan solusi yang kuat untuk berbagai aplikasi kreatif dan bisnis.

Baik Anda sedang membangun alat kreatif, sistem visualisasi e-commerce, atau platform pembuatan konten, menjalankan Flux di ComfyUI sebagai API menyediakan fondasi untuk pengalaman visual bertenaga AI yang inovatif.

button