Replicate teszt: modell-API másodpercenkénti árazással, az élekkel együtt

A Replicate mennyezetes inferenciaplatform, amely több ezer nyílt súlyú és proprietáris modellt fog össze egyetlen predikciós API mögött, és csak azokra a másodpercekre számol, amíg egy gép tényleg futtatja a kérésed. Az álláspont egyszerű: annak a csapatnak, amely ma délután ki akarja próbálni egy új kép- vagy videomodellt anélkül, hogy GPU-t kellene beállítania, ez a legrövidebb út a piacon. Azoknak a terméknek, amelynek késleltetési kerete és kiszámítható számlája van, a másodpercenkénti árazás rossz szerződés, és a platform csak akkor védhető, ha a verzió rögzített, és a modell deploymenten fut.

Valahol a saját GPU és a modellbeszállító között helyezkedik el. Az egyik oldalon versenytársa a fal.ai és a Baseten, amelyek inferenciát adnak el katalógus helyett; a másikon a GPU-közvetítőtől bérelt gép és a saját konténer. Amit nem vált fel, az a tokenenként számolt LLM-API. A Replicate szívesen szolgálja ki egy Llama modellt egy H100-on, de senki nem áraz egy chat-végpontot másodpercenkénti GPU-időre.

Mi a Replicate valójában

Három dolog oszt egy fiókot és egy API-t. Először a szerzőik által közzétett modellek nyilvános katalógusa: finomhangolások, közösségi implementációk, kutatási kód. Másodszor a hivatalos modellek halmaza, amelyeket maga a Replicate tart karban, a dokumentáció szerint több mint százat, amelyek mindig melegen állnak, kimeneti egységenként áraznak, és stabil input-sémájuk van. Harmadszor azok a privát modellek, amelyeket magad csomagolsz Cog-gal, és dedikált hardveren futtatod, ahol az példány teljes életidejéért fizetsz, nem az elvégzett munkáért.

• Minden futás egy predikciós objektum, benne bemenetek, kimenetek, állapot, időzítési metrikák és cancel URL, bármit is csinál a modell.
• Másodpercenkénti árazás a közzétett díjakkal: 0,000025 $ egy kis CPU-ra, 0,000225 $ egy T4-re, 0,001400 $ egy 80 GB A100-ra, 0,001525 $ egy H100-ra.
• A hivatalos modellek kimenet szerint számolnak: flux-1.1-pro 0,04 $ képpenként, ideogram-v3-quality 0,09 $, deepseek-r1 3,75 $ millió input tokenre.
• Aszinkron az alapértelmezés; szinkron a Prefer: wait headerrel lesz, ami 60 másodpercig tartja nyitva a kérést.
• Előleg, nem előfizetés. A kredit egy évig érvényes a vásárlástól, és nem visszatéríthető.
• Apache-2.0 kliens Node.jshez, Pythonhoz, Swifthez és Go-hoz, plusz a mcp.replicate.com hosztolt MCP-szervere, ami követi a HTTP API-t.

Hogyan fut egy predikció

Egy predikció létrehozása azonnal visszaad egy objektumot starting állapottal, és ez az objektum marad a munkaegység a futás idejére. Három dönti el, majd meddig vársz: hogy a modell meleg-e, mennyi ideig fut maga a modell, és hogy pollolsz, nyitva tartod a HTTP kapcsolatot, vagy egy webhookra vársz.

Az állapotok kevesek, és a működési információt hordozzák. A starting normálisan jóval egy másodpercnél rövidebb; ha tovább tart, az cold boot, és több gigabájt súly betöltése több percet is vehet. A processing a modell saját predict() metódusa. Utána a succeeded, failed, canceled vagy aborted állapot zárja a futást, és az utóbbi kettő közötti különbség az, hogy a gép elindult-e egyáltalán.

A predikciók 30 perc után timeoutba ütköznek, és a predikcióhoz megadott határidő lehetővé teszi, hogy az alkalmazás hamarabb feladja. A számlázási szabály pontosan követi ezt a kettősséget: a kezdés előtt megszakított predikció nem számítódik, az utána megszakított a futott másodpercekért. Ez valóban jó tervezés, és egyben az egyetlen ok, hogy a határidőt bátran szigorúan lehet állítani.

Első lépések

A Node.js kliens az életciklust a run() hívásba zsugorítja. Egy olyan modellnél, amely másodpercek alatt végez, ez a teljes integráció, mást nem is kell írni.

import Replicate from "replicate";
import { writeFile } from "node:fs/promises";

// Reads REPLICATE_API_TOKEN from the environment.
const replicate = new Replicate();

const [image] = await replicate.run("black-forest-labs/flux-schnell", {
  input: {
    prompt: "An astronaut riding a rainbow unicorn, cinematic lighting",
  },
});

await writeFile("output.png", image);
console.log("saved output.png");

A hosszabb modellekhez az aszinkron út kell, és az eredményről csak egy webhook értesít hitelesen. Két részlet szokott hibát okozni. Az aláírás a nyers kérés törzsét fedi le, ezért az ellenőrzésnek minden JSON-feldolgozás előtt kell futnia. A kliens pedig a HMAC kiszámítása előtt visszaalakítja a bájttörzset sztringgé, ami csendben minden aláírásellenőrzést törne.

import express from "express";
import Replicate from "replicate";
import { createHmac, timingSafeEqual } from "node:crypto";

const replicate = new Replicate();
const app = express();

// Verify first, parse second: the signature covers the raw body bytes.
app.post("/webhook", express.raw({ type: "application/json" }), (req, res) => {
  const key = process.env.REPLICATE_WEBHOOK_KEY.replace("whsec_", "");
  const signed = `${req.headers["webhook-id"]}.${req.headers["webhook-timestamp"]}.${req.body}`;
  const expected = createHmac("sha256", key).update(signed).digest("base64");
  const seen = String(req.headers["webhook-signature"]).split(" ").map((p) => p.split(",")[1]);
  const valid = seen.some((sig) => {
    const a = Buffer.from(sig), b = Buffer.from(expected);
    return a.length === b.length && timingSafeEqual(a, b);
  });
  if (!valid) return res.status(401).end();

  const prediction = JSON.parse(String(req.body));
  res.sendStatus(204); // Replicate retries terminal webhooks on 4xx and 5xx.
  console.log(prediction.id, prediction.status);
});

app.post("/image", async (req, res) => {
  const prediction = await replicate.predictions.create({
    model: "black-forest-labs/flux-schnell",
    input: { prompt: req.body.prompt },
    webhook: "https://example.com/webhook",
    webhook_events_filter: ["completed"],
  });
  res.json({ id: prediction.id });
});

Mennyibe kerül

A nyilvános katalógus másodpercenként méri a számítási időt, és az ár a hardverhez tartozik, nem a modellhez. A közzétett táblázat óradíjat is számít ki minden arányhoz, ami az összehasonlításhoz jó, de nem ezt számítják. A megosztott kapacitáson az indítási és az üresjárati idő ingyenes, csak a feldolgozás számít.

A hivatalos modellek megtörik ezt a mintát, és innen lesz kiszámítható a számla. A flux-1.1-pro 0,04 $ kimeneti képenként, a flux-schnell 3,00 $ ezer képenként, az ideogram-v3-quality 0,09 $, a deepseek-r1 pedig tokenenként. Minden privát modell visszafordítja ezt: dedikált hardveren fut, és az indítási, az üresjárati és az aktív időért egyaránt fizetsz, tehát egy példány akkor is pénzbe kerül, ha egész délután senki nem hívja.

Előre fizetsz. A hitelt előre vásárolod, a használat levon belőle, egy évig érvényes, és nem visszatéríthető. Ha az egyenleg nulla, a futó infrastruktúrát lekapcsolják, és új munka nem indul. Az a predikció, amely túllépi a hitelet, a hónap végén a megadott fizetési eszközből számítanak le. Van automatikus feltöltés, a dokumentált minimum 5 $ küszöb és 15 $ feltöltés, és ez a legolcsóbb védelem a megfojtott kérések sora ellen.

Deploymentek és cold bootok

Egy deployment egy modellverziót rögzít egy hardvertípushoz és egy példánytartományhoz, és egyszerre válaszol a cold boot és az üresjárati költség kérdésére. Az ár nyílt: egy melegen tartott T4 0,81 $ óránként, vagyis 583 $ egy harmincnapos hónapban, amely sosem üresjárat, szemben a nullával ugyanerre a modellre, ha napi száz hívás fut rajta megosztott kapacitáson. A deployment itt megszűnik rugalmas lenni, és a belső költségtétel lesz.

• Rögzítsd a tesztelt verziót. Egy új modellverzió így nem változtathatja meg a viselkedést terhelés alatt.
• Állítsd min_instances értékét 1-re, és a cold boot, a többperces súlybetöltéssel együtt, megszűnik.
• A dedikált hardver nem jelent várakozó sor más felhasználóktól, de minden üresjárati órát fizetni kell.
• Ugyanez a hasadás választja el a hivatalos modelleket, amelyeket a Replicate tart karban és melegen tart, a közösségi modellektől, amelyeket a szerzőik tartanak, és amelyek hidegen indulhatnak.

Adatmegőrzés, tokenek és webhookok

Az API-n átmenő minden alapértelmezés szerint illékony. Az API-n létrehozott predikcióknál a dokumentáció szerint a bemeneti paramétereket, a kimeneti értékeket, a kimeneti fájlokat és a logokat egy óra után eltávolítják, és saját másolatot kell tartani. A webes felületen létrehozott predikciók viszont korlátlan ideig megmaradnak. Ez az aszimmetria a dokumentáció legmeglepőbb működési ténye, mert ugyanaz a modell két nagyon különböző megőrzési szabály alá kerülhet attól függően, melyik felületet használták.

• Az API-tokenek 40 karakteres, r8_ előtagú stringek, bearer tokenként mennek, környezetenként nevezhetők, és egyenként visszavonhatók.
• A Replicate átnézi a nyilvános repókat a kiszivárgott tokenek után, és az kompromittáltakat automatikusan letiltja, magyarázó e-maillel. Kényelmes, de egyben olyan út is, amelyen egy téves riasztás megállítja a produkciót.
• A webhookok hordoznak webhook-id, webhook-timestamp és webhook-signature mezőt; a hitelesített tartalom a pontokkal összefűzött három, HMAC-SHA256 aláírással.
• Az aláírási kulcs a GET /v1/webhooks/default/secret végpontjáról jön, és a dokumentáció cache-elést javasol neki kiszolgálásonkénti lekérés helyett.
• A limitek 600 predikciólétrehozás percenként és 3000 kérés percenként minden más végponton, 429-es választesttel, amely megnevezi az újraengedélyezési ablakot.

Hol fáj

A katalógus a termék, és a katalógus a kockázat. Egy közösségi modell egy idegen által közzétett konténer: az input-séma verziók között megváltozhat, a szerzője eltűnhet, és maga a Replicate dokumentációja szerint a közösségi modelleknél eltérő lehet a stabilitás, a dokumentáció és a támogatás szintje. Csak a hivatalos modelleknek van stabil API-juk, és amit a vevő lát, annál a rögzített verzió és egy teszt a minimum.

A második probléma, hogy a számla soha nem az a számla, amit a pénzügy vár. Egy 0,04 $ a képpenkénti és egy 5,49 $ óránkénti modell is egy oda nem figyelő ciklus mögé kerülhet, és az egyetlen futásszintű adat, amit az API visszaad, az egy adott predikció metrics objektuma, amit alapból senki nem aggregál.

Harmadszor, a klienskönyvtárak egyenetlenek. A Node.js kliens 1.4.0-nál, a Python kliens 1.0.7-nél jár, a 2.0 sorozat pedig beta helyett kiadásra vár. Egy Python szolgáltatásnak közvetlenül a HTTP API-t érdemes hívnia várakozás helyett, és ezt az OpenAPI séma meg a llms.txt végpont kellemetlen egyszerűvé teszi.

Verdiktrum

A Replicate a legjobb ár-érték egyetlen konkrét problémára: nyílt modellt futtatni GPU nélkül. Minden másra rosszul illeszkedik, és ennek oka strukturális, nem érettségi. A másodpercenkénti árazás a szolgáltató hardverkihasználását optimalizálja, és a te számlád ennek az optimalizálásnak a zajterme.

1. Csapatok, amelyek egy új kép-, videó- vagy beszédmodellt prototipizálnak, és erre a hétre választ akarnak.
2. Csapatok, amelyek hajlandók rögzíteni egy verziót, stabilan tartani az input-sémát, és az egészet egy merev költségkeretbe zárni.
3. Mindenki, aki modellnagyobbonságot akar egy platform helyett, és elfogadja, hogy a katalógus nagy része karbantartás nélkül marad.
4. Ne válaszd interaktív végponthoz, ahol a farok-késleltetés termékfeltétel, és ne egyenletes, néhány százalékos kihasználás feletti terheléshez, ahol egy fenntartott GPU egyszerűen olcsóbb.
5. Ne válaszd, ha a bemeneti fájlok védett személyes adatot tartalmaznak, és az egyórás megőrzési ablak nem felel meg a saját előírásaidnak.

Források

1. Replicate pricing
2. Replicate docs: About predictions
3. Replicate docs: Create a prediction
4. Replicate docs: Prediction lifecycle
5. Replicate docs: Rate limits
6. Replicate docs: Data retention
7. Replicate docs: Verify webhooks
8. Replicate docs: Official models
9. fal.ai pricing
10. Baseten pricing