Bir Flux İş Akışını ComfyUI'de API Olarak Nasıl Çalıştırılır

Flux, Black Forest Labs tarafından geliştirilen, gelişmiş görüntü oluşturma yeteneklerine sahip, son teknoloji bir metinden görüntüye modelidir. Öte yandan, ComfyUI, düğüm tabanlı bir iş akışı sistemine sahip, güçlü ve modüler bir difüzyon modeli arayüzüdür. Birleştirildiğinde, programlı olarak erişilebilen yüksek kaliteli görüntü oluşturma için sağlam bir çözüm oluştururlar.

Flux modellerinin gücünü ComfyUI'nin çok yönlülüğü ile birleştirmek, yapay zeka Görüntü oluşturma iş akışınızı önemli ölçüde geliştirebilir. Bu eğitim, Flux'u bir API olarak ComfyUI'de çalıştırma sürecinde size rehberlik edecek ve otomasyon ve diğer sistemlerle entegrasyon olanakları sunacaktır.

💡

Flux ComfyUI API'mizi kurmaya başlamadan önce, test araçları hakkında konuşalım. API'lerle çalışırken, güvenilir bir test platformuna sahip olmak çok önemlidir ve Apidog bu alanda önde gelen Postman alternatifi olarak öne çıkıyor.

Apidog, tek bir birleşik platformda otomatik test, sahte sunucular ve ayrıntılı dokümantasyon oluşturma gibi özelliklerle kapsamlı bir API geliştirme ekosistemi sunar.

button

Postman'den farklı olarak Apidog, ComfyUI'deki gibi karmaşık iş akışları için özel olarak optimize edilmiş yerleşik hata ayıklama araçlarıyla sorunsuz API yaşam döngüsü yönetimi sağlar. Sezgisel arayüzü, Flux ComfyUI uç noktalarınızı test etmeyi önemli ölçüde daha verimli hale getirir ve ekip üyelerinin API yapılandırmalarını birlikte paylaşmasını ve iyileştirmesini sağlayan işbirliği özellikleri sunar.

API geliştirme ve test etme konusunda ciddiyseniz, Apidog'un hepsi bir arada çözümü iş akışınızı önemli ölçüde kolaylaştıracaktır.

button

Flux ComfyUI Ortamınızı Kurma

API uygulamasına geçmeden önce, gerekli ortamı kurmamız gerekiyor. GPU erişimi ile sunucusuz uygulamaları çalıştırmayı kolaylaştıran bir bulut platformu olan Modal'ı kullanacağız.

Flux ComfyUI için Önkoşullar

Bir Modal hesabı (adresinden oluşturun modal.com)
Python 3.11 veya üzeri
Yerel makinenize kurulmuş Git
Python ve API kavramları hakkında temel bilgi

Flux ComfyUI Kapsayıcı Görüntüsünü Oluşturma

İlk adımımız, Flux'u ComfyUI'de çalıştırmak için gerekli tüm bileşenleri içeren bir kapsayıcı görüntüsü oluşturmaktır. Süreci parçalayalım:

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
    )
)

Bu kod, Python 3.11 ile Debian Slim tabanlı bir Modal görüntüsü oluşturur, ardından Git, FastAPI ve comfy-cli'yi yükler. Daha sonra comfy-cli aracı, ComfyUI'nin kendisini yüklemek için kullanılır.

Flux ComfyUI'nizi Özel Düğümlerle Geliştirme

Ek işlevlerin kilidini açmak için, ComfyUI kurulumumuza özel düğümler ekleyeceğiz:

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, özellikle Flux modelleriyle çalışırken faydalı olabilecek görüntü oluşturma ve işleme için ek işlevsellik sağlar.

Flux ComfyUI Model İndirmeyi Ayarlama

Sorunsuz bir deneyim için verimli model yönetimi çok önemlidir. Flux modelini indirmek ve kalıcı bir hacimde saklamak için bir işlev oluşturacağız:

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"
)

Bu kod, Flux Schnell modelini Hugging Face'den indirmek ve ComfyUI modeller dizinine bir sembolik bağlantı oluşturmak için bir işlev tanımlar. Ayrıca, çalıştırmalar arasında indirilen modelleri kalıcı hale getirmek için bir Modal Hacmi oluşturuyoruz.

Etkileşimli Flux ComfyUI Geliştirme

Bir API olarak dağıtmadan önce, Flux ComfyUI iş akışınızı etkileşimli olarak test etmek faydalıdır:

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
    )

Bunu modal serve your_file.py ile çalıştırabilir ve API'yi uygulamadan önce iş akışlarınızı tasarlamak ve test etmek için tarayıcınızdaki kullanıcı arayüzüne erişebilirsiniz.

Flux ComfyUI API'sini Uygulama

Şimdi ana olay - ComfyUI'yi Flux model çıkarımı için bir API uç noktasına dönüştürme:

@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]["inputs"]["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")

Bu sınıf, temel API işlevselliğini tanımlar:

launch_comfy_background, kapsayıcı başlatıldığında ComfyUI sunucusunu başlatır
infer bir iş akışı çalıştırır ve oluşturulan görüntüyü döndürür
api, bir istem kabul eden, iş akışını değiştiren ve görüntüyü döndüren FastAPI uç noktasıdır
poll_server_health, ComfyUI sunucusunun yanıt vermesini sağlar

Flux ComfyUI API'nizi Test Etme

API'nizi test etmek için basit bir istemci betiği oluşturabilirsiniz:

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()

Flux ComfyUI Performansını Optimize Etme

API'nizin duyarlı ve uygun maliyetli kalmasını sağlamak için, aşağıdaki optimizasyonları uygulamayı düşünün:

1. Daha Hızlı Flux ComfyUI Soğuk Başlangıçları için Bellek Anlık Görüntüsü Alma

Soğuk başlangıçlar, sunucusuz uygulamalar için bir darboğaz olabilir. Modal, başlangıç sürelerini önemli ölçüde azaltabilen bellek anlık görüntüsü alma olanağı sunar:

@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. Flux ComfyUI için İstek Toplu İşleme

Yüksek verim senaryoları için, istek toplu işleme uygulamak verimliliği artırabilir:

@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

Gelişmiş Flux ComfyUI API Özellikleri

İş Akışı Parametrelerini Özelleştirme

API'nizi yalnızca istemin ötesinde ek parametreler içerecek şekilde genişletin:

@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")

Farklı Flux ComfyUI Modellerini İşleme

Farklı Flux modelleri arasında geçişe izin verin:

@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")

Flux ComfyUI API'nizi İzleme

Üretim dağıtımları için uygun izleme uygulamak çok önemlidir:

@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")

Sonuç: Flux ComfyUI'nin API Olarak Gücünü Ortaya Çıkarma

Bu eğitimde belirtilenleri izleyerek, ComfyUI'yi Flux modelleriyle ölçeklenebilir, üretime hazır bir API hizmetine nasıl dönüştüreceğinizi öğrendiniz. Bu yaklaşım çeşitli avantajlar sunar:

Ölçeklenebilirlik: Otomatik kapsayıcı ölçeklendirme ile birden fazla isteği eşzamanlı olarak işleyin
Esneklik: Kullanıcı gereksinimlerine göre iş akışlarını özelleştirin
Entegrasyon: Görüntü oluşturma yeteneklerinizi diğer uygulamalarla bağlayın
Uygun Maliyet: Yalnızca kullandığınız işlem için ödeme yapın

Modal'ın sunucusuz altyapısının, ComfyUI'nin güçlü iş akışı sisteminin ve Flux'un son teknoloji görüntü oluşturma özelliğinin birleşimi, çok çeşitli yaratıcı ve iş uygulamaları için sağlam bir çözüm oluşturur.

İster yaratıcı bir araç, ister bir e-ticaret görselleştirme sistemi veya bir içerik oluşturma platformu oluşturuyor olun, Flux'u bir API olarak ComfyUI'de çalıştırmak, yenilikçi yapay zeka destekli görsel deneyimler için temel sağlar.

button