Python ile Render Farm Yükleme Otomasyonu: paramiko ve rsync Kılavuzu

Bir bulut renderının en yavaş kısmı çoğunlukla rendering işleminin kendisi değildir. Her gece bir render farm'a çok kameralı VFX çekimi veya 400 GB'lık Houdini önbelleği aktaran bir stüdyo için darboğaz baytları taşımaktır — projeyi güvenilir biçimde yüklemek ve tamamlanmış kareleri sabah herkes gelene kadar geri çekmek. Bunu elle yapmak, gece yarısı ilerleme çubuğunu izlemek, ölçeklenemez. Komut dosyasıyla otomatikleştirmek ölçeklenebilir.

Bu kılavuz, Python'da bu transfer katmanını otomatikleştirmekle ilgilidir. Tam yönetimli bir render farm olan Super Renders Farm'ı işletiyoruz ve "tam yönetimli" ifadesinin otomasyon için kesin bir anlamı var: makinelere uzaktan bağlanmazsınız, yazılım yüklemezsiniz veya lisans yönetimi yapmazsınız; dolayısıyla pipeline'da komut dosyasıyla kontrol ettiğiniz bölüm size ait olan bölümdür — yukarı giden dosyalar ve aşağı gelen renderlar. Transfer yüzeyi SFTP üzerinden gerçek anlamda komut dosyasıyla yönetilebilir ve Python bunu çalıştırmanın birinci sınıf bir yoludur. Kendi transfer belgelerimiz, desteklenen bir istemci olarak Python'un paramiko kütüphanesini doğrudan rsync ve standart sftp komut satırının yanı sıra açıkça adlandırır.

Aynı zamanda bugün Python'dan neyi otomatikleştiremeyeceğiniz konusunda da kesin konuşacağız; çünkü var olmayan bir özelliğe dayanan bir pipeline, ilk gözetimsiz çalışmasında başarısız olan bir pipeline'dır. Daha geniş kavramsal haritayı arıyorsanız — "başsız" ve "gözetimsiz" ifadelerinin ne anlama geldiğini, sahneleri komut satırı rendering'e nasıl hazırlayacağınızı — bunun için ayrı bir yardımcı kılavuz mevcuttur. Bu kılavuz kod düzeyinde kalır ve transfer katmanına odaklanır: paramiko, rsync, SSH anahtarları, yeniden denemeler ve stüdyo otomasyonunuza ekleyebileceğiniz bir gece senkronizasyonu kalıbı.

Bugün Python ile neler otomatikleştirebilirsiniz?

Herhangi bir kod yazmadan önce sınırı çizmek yararlıdır. Yönetilen bir render farm'da pipeline'ın bir kısmı tamamen komut dosyasıyla yönetilebilir, bir kısmı kasıtlı olarak GUI güdümlüdür ve bir bölümü arasındadır. Hangisinin hangisi olduğu konusunda dürüst olmak, otomasyonunuzun sessizce bozulmasını önler.

Yönetilen bir bulut render farm'da hangi render farm pipeline adımlarının Python ile otomatikleştirilebileceğini gösteren matris diyagramı: Proje yükleme (paramiko, rsync, sftp aracılığıyla tamamen komut dosyasıyla yönetilebilir), Çıktı indirme (tamamen komut dosyasıyla yönetilebilir), İş tamamlanmasını algılama (kısmi — SFTP çıktı dizinini yokla, durum API'si yok), Render işi gönderme (yalnızca GUI — web formu, Client App veya DCC eklentisi), Hesap ve faturalama yönetimi (yalnızca GUI), yeşil, amber ve gri durum sütunlarıyla

• Proje yükleme — tamamen komut dosyasıyla yönetilebilir. paramiko, rsync veya betiklenmiş sftp komutlarından SFTP, SFTP sunucumuzla çalışır. Bu, aşağıdaki içeriğin özüdür.
• Tamamlanmış kareleri indirme — tamamen komut dosyasıyla yönetilebilir. Çıktı, aynı araçlarla çekebileceğiniz iş başına bir dizine iner.
• İşin tamamlandığını algılama — kısmi. Yoklanacak herhangi bir genel durum API'si yoktur. Yapabileceğiniz şey, SFTP çıktı dizinini yoklamak ve karelerin belirip kararlı hale gelişini izlemektir. Bu bir buluşsal yöntemdir, resmi bir sinyal değildir ve aşağıda bu şekilde ele alıyoruz.
• Render işi gönderme — bugün GUI. Gönderme, web formu, SuperRenders Client App veya DCC başına gönderme eklentisi üzerinden gerçekleşir. İş gönderimi, durum yoklaması ve çıktı alımı için genel bir REST API yol haritamızda bulunmaktadır; ancak şu anda doğrudan entegrasyon için herhangi bir genel API uç noktası mevcut değildir. Pipeline'ınız özellikle bir gönderme API'si nedeniyle engelleniyorsa, destek ekibiyle iletişime geçin ve kullanım senaryosunu paylaşın — yol haritası gerçek pipeline gereksinimlerine göre şekillenir.
• Hesap, kredi veya fatura yönetimi — GUI. Transfer otomasyonu kapsamı dışında.

Dolayısıyla otomatikleştirilebilir yüzey transferdir: projeyi yukarı itin, renderları aşağı çekin ve arada çıktı dizinini izleyerek açığı kapatın. Gönderme adımı kasıtlı bir aktarım olarak kalır ve bunu son pipeline'da açıkça belirteceğiz. Yönetilen rendering'in neleri açıklayıp açıklamadığına dair daha kapsamlı bir değerlendirme için, tam yönetimli render farm'ın ne olduğuna dair kılavuzumuz modeli ele almaktadır; yeni hesaplar başlangıç kılavuzundan başlayabilir.

Önkoşullar: SFTP erişimi, SSH anahtarları ve Python ortamı

İlk betiklenmiş yükleme öncesinde üç şeyin hazır olması gerekir.

Hesap başına etkinleştirilen SFTP erişimi. SFTP, istek üzerine hesap başına etkinleştirilir. Oturum açın, hesap ayarlarınızda "SFTP erişimi"ni arayın ve kimlik bilgilerini orada oluşturun; görünmüyorsa desteğe etkinleştirmesini isteyin. Kimlik bilgileriniz şunları içerir: bir sunucu ana bilgisayar adı (bölgeye ve depolama tahsisine göre değişir, bu nedenle yapılandırmadan okuduğunuz bir değer olarak ele alın, hiçbir zaman sabit kodlamayın), hesabınıza bağlı bir kullanıcı adı, parola veya SSH anahtarı ve standart SFTP bağlantı noktası 22. İki yol önemlidir: /uploads/<proje-klasörünüz>/ yazma alanınızdır ve /output/<iş-kimliği>/ tamamlanmış renderların göründüğü yerdir.

SSH anahtarı, parola değil. Otomatik işlemler için SSH anahtarı kimlik doğrulaması doğru seçimdir — gizli bilgileri komut dosyalarınızın dışında tutar ve etkileşimli istem olmadan gözetimsiz çalışmalarda çalışmaya devam eder. Modern bir anahtar çifti oluşturun ve genel yarısını hesabınıza kaydedin:

ssh-keygen -t ed25519 -C "pipeline@yourstudio.example"
# ~/.ssh/id_ed25519.pub içeriğini şuraya ekleyin:
# superrendersfarm.com -> Settings -> SFTP -> SSH Keys

Hesap güvenliği hakkında bir not: şu anda hesaplarda iki faktörlü kimlik doğrulama desteklenmemektedir; bu nedenle SFTP için en güçlü sertleştirme, anahtar dosyasında bir parola ifadesi ve oturum için kilidi açılmış anahtarı tutan bir SSH ajanıdır. Anahtar artı parola ifadesinin bilgisi, ikinci bir faktöre benzer bir rol oynar — sahiplik artı gizli bilgi.

paramiko ile Python ortamı. Aşağıdaki her şey, standart saf-Python SSH/SFTP uygulaması olan paramiko kullanır ve büyük artımlı transferler için rsync'e yönlendirir.

python3 -m venv .venv && source .venv/bin/activate
pip install paramiko

Yönetilen bir render farm için SFTP hesap düzeni ve anahtar tabanlı kimlik doğrulama diyagramı: ed25519 özel anahtarını tutan yerel bir pipeline makinesi, SSH bağlantı noktası 22 üzerinden render farm SFTP sunucusuna bağlanır; sunucu iki dizin gösterir — gelen projeler için yazma alanı olarak /uploads/<proje>/ ve tamamlanmış kareler için okuma alanı olarak /output/<iş-kimliği>/; eşleşen genel anahtar hesap ayarlarına kaydedilir

Bir projeyi gözetimsiz yüklemeye dayanacak şekilde paketleme

Başarısız render işlerinin çoğu motor hataları değildir — paketleme eksiklikleridir. Sanatçının iş istasyonunda çalışan bir sahne, yeni bir çalışan üzerinde başarısız olur çünkü bir doku yolu yalnızca yerel bir sürücüye işaret eder ya da başvurulan bir alt sahne hiç paketlenmemiştir. Otomasyon bunu yükseltir: bozuk bir paketin gözetimsiz yüklenmesi gözetimsiz bir başarısızlık üretir. İki kural paketleri temiz tutar.

Birincisi, göreli yollarla projeyi bağımsız hale getirin. Her doku, proxy ve önbellek proje köküne göreli olarak çözümlenecek şekilde DCC'nizin topla ve paketle komutunu (Arşiv, Dosyaları Topla, Varlıklarla Birlikte Projeyi Kaydet) çalıştırın. İkincisi, yüklemeden önce sıkıştırıyorsanız arşiv biçimine dikkat edin: tar, tar.gz ve 7z destekliyoruz, ancak .zip desteklenmez — .tar.gz olarak yeniden paketleyin veya arşivlemeyi tamamen atlayın ve rsync'in klasör ağacını aktarmasına izin verin; bu genellikle süregelen projeler için zaten daha iyi bir seçimdir. Pratik bir tavan olarak, tek bir yüklemeyi ~300 GB'ın altında tutun; bunun üzerinde, tek büyük bir transfer yerine devam etmeyle rsync kullanın.

paramiko ile proje yükleme

İlk yapı taşı özyinelemeli bir yükleyicidir. Bir anahtarla bağlanır, yerel proje ağacında gezinir, /uploads/ altında dizin yapısını yeniden oluşturur ve her dosyayı yerleştirir. Ana bilgisayar anahtarlarını RejectPolicy ile sabitleriz ve hassas hiçbir şey komut dosyasında yer almayacak şekilde bağlantı ayrıntılarını ortamdan okuruz.

import os
import paramiko

def connect():
    host = os.environ["SRF_SFTP_HOST"]
    user = os.environ["SRF_SFTP_USER"]
    key_path = os.environ["SRF_SFTP_KEY"]      # özel anahtar yolu

    client = paramiko.SSHClient()
    client.load_system_host_keys()             # yalnızca ~/.ssh/known_hosts'a güven
    client.set_missing_host_key_policy(paramiko.RejectPolicy())
    client.connect(hostname=host, port=22, username=user, key_filename=key_path)
    return client, client.open_sftp()

def _ensure_remote_dir(sftp, remote_dir):
    # SFTP üzerinden mkdir -p: yolu parça parça oluştur
    path = ""
    for segment in remote_dir.strip("/").split("/"):
        path += "/" + segment
        try:
            sftp.stat(path)
        except IOError:
            sftp.mkdir(path)

def upload_dir(sftp, local_dir, remote_dir):
    for root, _dirs, files in os.walk(local_dir):
        rel = os.path.relpath(root, local_dir)
        remote_root = remote_dir if rel == "." else f"{remote_dir}/{rel.replace(os.sep, '/')}"
        _ensure_remote_dir(sftp, remote_root)
        for name in files:
            local_path = os.path.join(root, name)
            remote_path = f"{remote_root}/{name}"
            sftp.put(local_path, remote_path)
            print(f"yüklendi {remote_path}")

Bir proje için çalıştırma:

client, sftp = connect()
try:
    upload_dir(sftp, "/local/projects/archviz-tower", "/uploads/archviz-tower-2026-06")
finally:
    sftp.close()
    client.close()

Bu küçük ve orta ölçekli projeler için yeterlidir. sftp.put ayrıca aktarılan baytları ve toplamı alan bir callback= bağımsız değişkeni kabul eder; bunu bir ilerleme ölçerine veya dosya başına bir günlük satırına bağlayabilirsiniz. Ancak stüdyo çalışmasını tanımlayan büyük, tekrarlanan transferler için rsync daha iyi bir araçtır.

Bir render farm için paramiko yükleme rutininin akış diyagramı: yerel proje klasörü os.walk ile dosya dosya gezinilir, uzak dizin ağacı mkdir-p döngüsüyle /uploads altında oluşturulur, ardından her dosya SSH anahtarı ile kimlik doğrulamalı bağlantı üzerinden sftp.put ile gönderilir ve tamamlanan her dosyayı günlüğe kaydeden bir ilerleme geri çağrısıyla

SSH üzerinden rsync ile artımlı senkronizasyon

Bir render projesi nadiren tek seferlik yüklenir. Bir shader'ı ayarlarsınız, bir sim'i yeniden önbelleğe alırsınız, bir ışığı düzeltir ve yeniden yüklersiniz. Her seferinde klasörün tamamını göndermek saatler boşa gider; rsync yalnızca değişenleri gönderir. Her gece yükleme yapan bir stüdyo için bu, transfer katmanında tek büyük zaman tasarrufudur; çünkü projeyi değil yalnızca deltayi aktarır.

Standart çağrım:

rsync -avz --partial --progress \
  /local/projects/archviz-tower/ \
  "$SRF_SFTP_USER@$SRF_SFTP_HOST:/uploads/archviz-tower-2026-06/"

-a yapıyı ve zaman damgalarını korur, -z aktarım sırasında sıkıştırır, --partial kısmen aktarılan dosyaları saklar; böylece düşen bir bağlantı yeniden başlamak yerine devam eder, --progress dosya başına raporlar. Bir değişiklikten sonra aynı komutu yeniden çalıştırmak yalnızca değiştirilen dosyaları aktarır. Amaç otomasyon olduğundan, diğer her şeyle aynı komut dosyasında yaşaması ve çıkış koduna tepki verebilmek için Python'a sarın:

import subprocess

def rsync_up(local_dir, remote_subdir):
    host = os.environ["SRF_SFTP_HOST"]
    user = os.environ["SRF_SFTP_USER"]
    dest = f"{user}@{host}:/uploads/{remote_subdir}/"
    cmd = ["rsync", "-avz", "--partial", "--progress",
           f"{local_dir.rstrip('/')}/", dest]
    subprocess.run(cmd, check=True)   # başarısızlıkta CalledProcessError fırlatır

Gözetimsiz çalıştırmak için zamanlayın. Gece sabah 1'de çalışma dizinini her gece render farm'a yansıtan bir stüdyo için tek bir cron satırı yeterlidir:

0 1 * * *  cd /studio/pipeline && /usr/bin/python3 nightly_sync.py >> sync.log 2>&1

rsync'in SSH üzerinden istem olmadan kimlik doğrulaması yapması için -e "ssh -i ~/.ssh/id_ed25519" ile anahtarınıza işaret edin veya oturum için kilidi açılmış anahtarı bir SSH ajanının tutmasına izin verin.

Render farm'a tam yeniden yükleme ile rsync artımlı senkronizasyonunu karşılaştıran öncesi-sonrası diyagramı: solda, bir projedeki her dosya her gece yeniden gönderilir; sağda rsync yerel ve uzak dosyaları karşılaştırır ve yalnızca değişen dosyaları (bir değiştirilmiş shader ve yeni bir önbellek) aktarır, değişmeyen büyük kısım atlanır; bu durum, gece stüdyo yüklemelerini hızlı kılan yalnızca-delta transferini gösterir

Tamamlanmış kareleri otomatik indirme

Bir iş tamamlandığında çıktı kareleri, SFTP sunucusunda /output/<iş-kimliği>/ dizinine yazılır. İndirme tarafı yükleme tarafını yansıtır — paramiko ile özyinelemeli bir get veya rsync çekimi. paramiko sürümü uzak dizinde gezinir ve yerel olarak yeniden oluşturur:

import stat

def download_dir(sftp, remote_dir, local_dir):
    os.makedirs(local_dir, exist_ok=True)
    for entry in sftp.listdir_attr(remote_dir):
        remote_path = f"{remote_dir}/{entry.filename}"
        local_path = os.path.join(local_dir, entry.filename)
        if stat.S_ISDIR(entry.st_mode):
            download_dir(sftp, remote_path, local_path)
        else:
            sftp.get(remote_path, local_path)
            print(f"indirildi {local_path}")

Büyük çıktı kümeleri için rsync çekimi yine daha verimli ve devam edebilen bir seçimdir:

rsync -avz --progress \
  "$SRF_SFTP_USER@$SRF_SFTP_HOST:/output/<iş-kimliği>/" \
  /local/downloads/<iş-kimliği>/

Gözetimsiz pipeline'lar için önemli olan bir operasyonel ayrıntı: renderlanan çıktı, iş tamamlandıktan sonra 45 gün süreyle saklanır, ardından otomatik olarak silinir. SFTP bu pencereyi uzatmaz. Güvenli kalıp, çıktıyı göründüğü anda yerel arşive yansıtan bir gece senkronizasyonudur; böylece elde tutma süresi hiçbir zaman kareleriniz ile aranızdaki engel olmaz.

Durum API'si olmadan iş tamamlanmasını algılama

Burada dürüst sınır somut bir mühendislik seçimi haline gelir. "12345 numaralı iş tamamlandı mı?" diye sorulacak herhangi bir genel uç nokta yoktur — ancak çıktı dizini SFTP üzerinden gözlemlenebilir durumdadır. Pratik kalıp, /output/<iş-kimliği>/'yi yoklamak, dosyaları saymak ve sayının beklenen kare toplamına ulaşmasını ve art arda yapılan kontrollerde sabit kalmasını beklemektir (böylece yazma ortasında indirmeye başlamazsınız).

import time

def wait_for_output(sftp, output_dir, expected_frames, poll=120, stable_checks=2):
    last_count, stable = -1, 0
    while True:
        try:
            files = sftp.listdir(output_dir)
        except IOError:
            files = []                      # klasör henüz oluşturulmadı -> başlamadı
        count = len(files)
        if count >= expected_frames and count == last_count:
            stable += 1
            if stable >= stable_checks:
                return files                # sayı karşılandı ve sabit -> tamamlandı say
        else:
            stable = 0
        last_count = count
        time.sleep(poll)

Bunun ne olduğu konusunda net olun. Kareler artımlı olarak görünür; dolayısıyla yalnızca varlık tamamlanma değildir. Sayıyı beklenen toplamla karşılaştırmak ve yoklamalar arasında sabit olduğunu doğrulamak, otomasyon için yeterince güvenilir kılar. Bu bir dizin buluşsal yöntemidir, bir sözleşme değildir. Genel API geldiğinde, bu işlevin tamamı bir durum çağrısına dönüşür — o zamana kadar çıktı dizinini izlemek açığı kapatmanın sağlam yoludur ve yalnızca zaten var olan yeteneklere bağlıdır.

Durum API'si olmadan render tamamlanmasını algılamak için SFTP çıktı dizinini yoklamayı gösteren sıra diyagramı: bir pipeline betiği /output/<iş-kimliği>/'yi tekrar tekrar listeler, kare sayısını beklenen toplamla karşılaştırır, sayı hem hedefe ulaşana hem de iki art arda kontrol boyunca sabit kalana kadar bekler, ardından indirmeye geçer — işin başlamadığını gösteren erken boş klasör durumu da gösterilir

Hepsini bir araya getirme: gözetimsiz bir transfer pipeline'ı

Parçalar tek bir gece betiğinde bir araya gelir. Şekil şöyledir: projeyi yukarı senkronize edin, gönderme işlemine devret, çıktının belirip kararlı hale gelişini bekleyin, aşağı çekin, doğrulayın ve arşivleyin. Gönderme adımı kasıtlı GUI aktarımıdır — yönetilen bir render farm'da web formu, Client App veya DCC gönderme eklentisi aracılığıyla gönderme yaparsınız; DCC başına eklentiler, gönderme zaten komut dosyasıyla kontrol ettiğiniz bir araçta yaşadığında ana uygulamanın kendi komut dosyası ortamından (MAXScript, DCC içinde Python) çalıştırılabilir. Bu adımı dürüstçe işaretliyoruz; bir API'nin var olduğunu iddia eden bir işleve sarmıyoruz.

def nightly_pipeline(project_dir, remote_subdir, job_id, expected_frames):
    client, sftp = connect()
    try:
        # with_retries() (sonraki bölümde tanımlanır) kırılgan ağ çağrılarını sarar
        with_retries(lambda: rsync_up(project_dir, remote_subdir))    # 1. deltayı yukarı it
        # 2. GÖNDERİM: GUI / Client App / DCC eklentisi -- henüz genel API yok
        files = wait_for_output(                                      # 3. çıktı dizinini izle
            sftp, f"/output/{job_id}", expected_frames)
        with_retries(lambda:                                          # 4. tamamlanmış kareleri çek
            download_dir(sftp, f"/output/{job_id}", f"/local/downloads/{job_id}"))
        print(f"iş {job_id}: {len(files)} kare alındı")
    finally:
        sftp.close()
        client.close()

1., 3. ve 4. adımlar tamamen otomatikleştirilmiştir; 2. adım aktarımdır. Genel bir gönderme API'si geldiğinde, 2. ve 3. adımlar API çağrılarına dönüşür ve dizin yoklaması sona erer. Mimari değişmez — yalnızca gönderme ve durum ayakları GUI ve buluşsal yöntemden uç noktaya taşınır.

Python'dan yönetilen bir render farm transfer pipeline'ının uçtan uca akış diyagramı: 1. adım rsync proje deltasını /uploads'a yükler, 2. adım işin web formu, Client App veya DCC eklentisi aracılığıyla gönderildiği açıkça işaretlenmiş bir GUI aktarımıdır (genel API yok), 3. adım kareler tamamlanıp kararlı hale gelene kadar /output/<iş-kimliği>/'yi yoklar, 4. adım tamamlanmış kareleri yerel olarak indirir ve arşivler — otomatik adımlar camgöbeği rengiyle, manuel gönderme adımı griyle gösterilir

Hata yönetimi, yeniden denemeler ve devam edilebilir transferler

Gözetimsiz, bir transfer tökezlediğinde kimsenin izlemediği anlamına gelir; bu nedenle komut dosyasının kendi kendini kurtarması gerekir. Üç alışkanlık çoğu başarısızlığı kapsar.

Geçici başarısızlıkları geri çekilme ile yeniden deneyin. Ağ kesintileri ve kısa bağlantı kopmaları uzun transferler boyunca normaldir. Kırılgan çağrıları — nightly_pipeline'ın yukarıda yaptığı gibi — sarın; böylece tek bir kopma çalışmayı öldürmez. Her şeyi değil, belirli geçici hataları yakalayın: paramiko'nun SSHException'ı, soketler için OSError ailesi ve başarısız rsync için CalledProcessError.

def with_retries(fn, attempts=3, backoff=5):
    transient = (paramiko.SSHException, OSError, subprocess.CalledProcessError)
    for i in range(1, attempts + 1):
        try:
            return fn()
        except transient:                  # SSH / ağ / rsync kesintilerini yeniden dene
            if i == attempts:
                raise
            time.sleep(backoff * i)        # geri çekil: 5sn, 10sn, 15sn

Devam edilebilirliğe dayanın. rsync --partial kesintiye uğrayan dosyaları zaten devam ettirir ve bir rsync'i yeniden çalıştırmak idempotent'tir — yalnızca eksik olanı gönderir — dolayısıyla yeniden denenen senkronizasyon ucuzdur, yeniden başlatma değildir. paramiko transferleri için, yeniden deneme artı yeniden gezinme aynı etkiyi sağlar çünkü zaten mevcut dosyalar neredeyse anında aktarılır.

Ana bilgisayar anahtarı ve bağlantı hatalarını açıkça işleyin. "Ana bilgisayar anahtarı doğrulaması başarısız oldu" hatası, ~/.ssh/known_hosts'ta önbelleğe alınan anahtarın artık sunucununkiyle eşleşmediği anlamına gelir — çoğunlukla nadir ana bilgisayar anahtarı döndürmesinden sonra. Hatanın adlandırdığı eski satırı kaldırın ve yeni anahtarı kabul etmek için yeniden bağlanın. Bağlantı reddedilmesi veya zaman aşımı genellikle stüdyo güvenlik duvarının giden TCP 22'yi engellediği anlamına gelir; buna izin verin veya alternatifler için desteğe sorun. Aktarım hızı bant hızınızın çok altında kalıyorsa, SFTP'nin paket başına ek yükü uzun mesafeli bağlantılarda nedendir — paralel segmentlerle lftp veya birkaç eşzamanlı SFTP oturumu açığın büyük bölümünü telafi eder.

Özet: neyi ve nasıl otomatikleştireceğiniz

Transfer katmanı, yönetilen bir render farm pipeline'ında kodla sahip olduğunuz bölümdür ve Python tamamını kapsar.

Yüklemeyi otomatikleştirin, indirmeyi otomatikleştirin, çıktı dizinini izleyerek ortadaki açığı kapatın ve gönderme aktarımını açık tutun. Bu size dikişleri konusunda dürüst ve bu sayede güvenilir bir gece pipeline'ı verir. Transfer güvenilirliğinin en çok önem taşıdığı büyük simülasyon ağırlıklı projeler için — çok terabaytlık Houdini önbellekleri ve benzerleri — aynı kalıplar doğrudan Super Renders Farm'da ölçeklenir; Houdini cloud render farm sayfamız bu iş yükünü kapsamaktadır.

SSS

Q: Render farm'a yükleme yapmak için hangi Python kütüphanesini kullanmalıyım? A: paramiko standart seçimdir ve SFTP belgelerimizde desteklenen bir istemci olarak doğrudan adlandırılır. Saf Python'dur, SFTP'yi temiz bir şekilde yönetir ve yükleme ile indirme mantığı için iyi çalışır. Çok büyük veya sık tekrarlanan transferler için Python'dan subprocess ile SSH üzerinden rsync'e yönlendirin — yalnızca değiştirilen dosyaları gönderir ve kesintiye uğrayanları devam ettirir; paramiko bunu yerel olarak yapmaz.

Q: Python pipeline'ımdan render işleri göndermek için genel bir API var mı? A: Henüz yok. Gönderme, durum yoklaması ve çıktı alımı için genel bir REST API yol haritamızda bulunmaktadır; ancak bugün herhangi bir genel uç nokta mevcut değildir. Geçerli programatik gönderme yolları, SuperRenders Client App ve DCC başına gönderme eklentisidir; bu eklenti, MAXScript veya DCC içinde Python gibi ana uygulamanın kendi komut dosyası ortamıyla entegre olur. Pipeline'ınız özellikle genel bir gönderme API'si nedeniyle engelleniyorsa, destek ekibiyle iletişime geçin ve kullanım senaryosunu paylaşın — yol haritası gerçek pipeline gereksinimlerine göre şekillenir.

Q: Durum API'si yoksa render işinin tamamlandığını nasıl anlarım? A: İşin SFTP çıktı dizinini, /output/<iş-kimliği>/'yi yoklayın ve kare sayısını izleyin. İşi yalnızca sayı beklenen toplamına ulaştığında ve art arda yapılan kontrollerde sabit kaldığında tamamlanmış sayın; böylece kareler hâlâ yazılırken indirmeye başlamazsınız. Resmi bir durum sinyali değil dizin buluşsal yöntemidir, ancak yalnızca bugün var olan yeteneklere dayanır.

Q: Otomatik transferler için SSH anahtarı mı yoksa parola mı kullanmalıyım? A: SSH anahtarı kullanın. Bir komut dosyasına parola sabit kodlamak bir güvenlik riskidir ve anahtar kimlik doğrulaması etkileşimli istem olmadan gözetimsiz çalışır. Bir ed25519 anahtarı oluşturun, genel yarısını Settings → SFTP → SSH Keys'na kaydedin ve özel anahtarı bir SSH ajanının tuttuğu bir parola ifadesiyle koruyun. Şu anda hesaplarda iki faktörlü kimlik doğrulama desteklenmediğinden, anahtar artı parola ifadesi SFTP erişimi için en güçlü pratik sertleştirmedir.

Q: Komut dosyamdan .zip arşivi yükleyebilir miyim? A: Hayır — .zip arşivleri desteklenmez. .tar.gz (veya .tar / .7z) olarak yeniden paketleyin ya da arşivlemeyi atlayın ve rsync'in klasör ağacını doğrudan aktarmasına izin verin; bu genellikle yüklemeler arasında değişen projeler için daha iyi bir seçenektir. Tek bir yüklemeyi yaklaşık 300 GB altında tutun ve daha büyük herhangi bir şey için rsync --partial kullanın; böylece düşen bağlantı yeniden başlamak yerine devam eder.

Q: Bu yolla ne kadar büyük bir proje taşıyabilirim? A: Çok terabaytlık transferler SFTP üzerinden desteklenir; pratik sınır render farm tarafından değil, kendi yükleme bant genişliğiniz tarafından belirlenir. 100 Mbps'de 1 TB yükleme yaklaşık bir gün sürer, bu nedenle bağlantınıza göre planlayın. Kalın veya uzun mesafeli bağlantılarda maksimum aktarım hızı için paralel segmentlerle lftp veya birkaç eşzamanlı SFTP oturumu kullanın; tek bir SFTP akışı paket başına ek yük nedeniyle sınırlıdır.

Q: Renderlanan karelerim ne kadar süre indirilebilir? A: Çıktı, bir iş tamamlandıktan sonra 45 gün süreyle saklanır, ardından otomatik olarak silinir; SFTP bu pencereyi uzatmaz. Gözetimsiz bir pipeline için, çıktıyı göründüğü anda yerel arşive yansıtın — /output/<iş-kimliği>/'nin gece rsync çekimi, elde tutma süresinin bir karenin kaybolmasının nedeni olmasını engeller.

Q: Bu kılavuz, başsız ve gözetimsiz iş akışı kılavuzunuzdan nasıl farklıdır? A: Diğer kılavuz kavramsal haritadır — başsız rendering'in ne anlama geldiği, sahnelerin komut satırı rendering için nasıl hazırlanacağı ve gözetimsiz döngünün yönetilen bir render farm'da nasıl bir araya geldiği. Bu kılavuz ise kod düzeyindeki yardımcı kılavuzdur ve transfer katmanına odaklanır: projeleri yukarı ve kareleri aşağı taşımak için yazdığınız gerçek paramiko ve rsync. Şekil için iş akışı kılavuzunu okuyun; uygulama için bu kılavuzu kullanın.