Naar de inhoud

Kubus

Volume

Schijven die langer meegaan dan hun instantie

De schijf van Kubus, los van elke instantie: alle data in gelaagde opslag, en zoveel ervan op de NVMe van de machine als je kiest.

Lees de docs

Volume in cijfers

per GB-maand aan data, zonder cache
$0.02
per GB-maand helemaal op NVMe
$0.08
voor schrijven of lezen
$0

In drie stappen

Dezelfde aanroepen vanaf de opdrachtregel, de API, de SDK’s en de MCP-server, waar een volume een drive heet.

Voordat je begint

Zet je API-sleutel in GLAC_API_KEY.

curl -fsSL https://glac.ai/install.sh | sh
export GLAC_API_KEY=ak_...
API=https://api.glac.ai/v1
AUTH="Authorization: Bearer $GLAC_API_KEY"
from glac import DriveMount, Glac
glac = Glac()
import { Glac } from "glac";
const glac = new Glac();
# give your agent the tools (Claude Code here)
claude mcp add glac -e GLAC_API_KEY=ak_... -- npx glac-mcp
  1. Maak een volume

    Alleen de data die je erop schrijft, wordt afgerekend.

    glac drives create --name data \
      --size-bytes 10GiB
    curl $API/drives -H "$AUTH" \
      --json '{"name": "data", "size_bytes": 10737418240}'
    drive = glac.drives.create(name="data", size_bytes=10 << 30)
    const drive = await glac.drives.create(
      { name: "data", sizeBytes: 10 * 2 ** 30 });
    drive_create {"name": "data", "size_gib": 10}
  2. Koppel het aan en schrijf erop

    In een sandbox, op een pad dat je zelf kiest.

    glac sandboxes create --name web \
      --drive data:/data
    glac sandboxes exec web -- \
      sh -c 'echo kept > /data/note'
    curl $API/sandboxes -H "$AUTH" --json '{"name": "web",
      "drives": [{"drive": "data", "path": "/data"}]}'
    curl $API/sandboxes/web/run -H "$AUTH" \
      --json '{"command": "echo kept > /data/note"}'
    mount = DriveMount("/data", drive)
    sbx = glac.sandboxes.create(drives=[mount])
    sbx.run("echo kept > /data/note")
    const mount = { path: "/data", drive: drive.id };
    const sbx = await glac.sandboxes.create(
      { drives: [mount] });
    await sbx.files.write("/data/note", "kept\n");
    drive_attach {"drive": "data", "sandbox": "web",
                  "path": "/data"}
    sandbox_run {"sandbox": "web",
                 "command": "echo kept > /data/note"}
  3. Geef het door

    Aan de volgende sandbox, met wat erop staat.

    glac drives detach data web
    glac sandboxes create --name next \
      --drive data:/data
    glac sandboxes exec next -- \
      cat /data/note
    curl -X DELETE $API/sandboxes/web/drives/data -H "$AUTH"
    curl $API/sandboxes -H "$AUTH" --json '{"name": "next",
      "drives": [{"drive": "data", "path": "/data"}]}'
    glac.drives.detach(sbx, drive)
    nxt = glac.sandboxes.create(drives=[mount])
    print(nxt.run("cat /data/note").stdout)
    await glac.drives.detach(sbx, drive);
    const nxt = await glac.sandboxes.create(
      { drives: [mount] });
    console.log(await nxt.files.readText("/data/note"));
    drive_detach {"drive": "data", "sandbox": "web"}
    drive_attach {"drive": "data", "sandbox": "next",
                  "path": "/data"}

Een volume hoort bij één sandbox tegelijk, tot het wordt losgekoppeld. Een Kubus met een volume heeft één instantie.

Wat het doet

  • Schrijven, en lezen uit de cache, op NVMe-snelheid, met zoveel in de cache als je kiest.

  • Afgerekend op data en cache, uur voor uur, nooit op grootte of leesacties.

  • Elke schrijfactie binnen een seconde in gelaagde opslag, elke 250 ms verstuurd.

  • Aan te koppelen op elke machine in de regio, en de blokken volgen naarmate ze gelezen worden.

  • Maak een snapshot van een volume, fork het of zet het terug, zonder iets te kopiëren.

  • Eén snapshot, alleen-lezen in veel sandboxen tegelijk, voor modelgewichten en datasets.

Lees de docs

Illustratieve voorbeelden

Hoe je toestand bewaart

Drie manieren waarop het platform bewaart wat een programma heeft, en waarvoor elke manier dient.

BewaartWaarvoor
SlaapGeheugen, processen en schijf, zoals ze warenEen instantie of een sandbox tussen gebruiksmomenten
SnapshotEen hele sandbox op een bepaald momentTeruggaan, of er veel starten vanuit één
VolumeEen schijf, los van elke instantieBestanden die langer meegaan dan hun instantie: databases, werkruimtes, datasets

Gebouwd voor

  • Databases op Kubus

    Postgres, MySQL of Redis in een Kubus, met de data op een volume.

    glac drives create --name data \
      --size-bytes 5GiB --region eu
    glac deploy redis:7 --name cache \
      --port 6379 --public false \
      --region eu --drive data:/data
  • Werkruimtes die meeverhuizen

    De bestanden van een agent gaan mee met zijn sandbox, naar welke machine in de regio ook.

    glac drives detach work old
    glac drives attach work new:/work
    glac sandboxes exec new -- ls /work
  • Caches die blijven

    Package- en buildcaches die van de ene sandbox naar de volgende bewaard blijven, zodat elke run warm begint.

    glac drives create --name deps \
      --size-bytes 20GiB
    glac sandboxes create --name ci \
      --drive deps:/root/.cache

Prijzen en limieten

Afgerekend op data en cache, uur voor uur; nooit voor schrijven of lezen. Alle prijzen en abonnementen

Wat geteld wordtHoePrijs
Data1Alles wat een volume bevat, bewaard in gelaagde opslag$0.00000761 / miljoen GB-ms$0.00000000761 / GB-seconde$0.0000274 / GB-uur$0.02 / GB-maand
NVMe-cache1Het deel op de NVMe van de machine, zo groot als je het instelt; geen kosten voor schrijven of lezen$0.0000228 / miljoen GB-ms$0.0000000228 / GB-seconde$0.0000822 / GB-uur$0.06 / GB-maand

Een maand, doorgerekend

100 GB de hele maand, op drie manieren gecachet. Schrijven en lezen kosten niets.

  • Alles op NVMe

    $8.00

    100 GB × ($0.02 + $0.06)

    Elke leesactie op NVMe-snelheid.

  • Middenweg, 25% in de cache

    $3.50

    100 GB × $0.02 + 25 GB × $0.06

    25% op NVMe; de rest gelezen op netwerksnelheid.

  • Niets in de cache

    $2.00

    100 GB × $0.02

    Elke leesactie op netwerksnelheid.

Wat de abonnementen toestaan

Alle limieten per abonnement
GratisBetaald
Volumesin een project3500, meer op aanvraag
Grootste volume10 GiB1 TiB
Alle volumes samenin een project15 GiBGeen limiet

Tot 16 TiB per volume voor een enterprise-account, in overleg. Een instantie kan hoogstens 8 volumes aankoppelen.

Hoe je data bewaard wordt

Eerst op de eigen machine geschreven, en tijdens het schrijven gekopieerd naar gelaagde opslag.

  • Eerst op de machine

    Schrijfacties komen op de NVMe terecht; leesacties van wat erop staat verlaten de machine nooit.

  • Binnen een seconde gekopieerd

    Elke 250 ms verstuurd; schrijfacties wachten zodra de oudste niet-verstuurde 900 ms oud is.

  • Wat het verlies van een machine kost

    Het volume komt terug zoals het een moment eerder was. De schijf van een sandbox, op dezelfde manier gekopieerd, verloor bij 41 verloren machines hoogstens 1.0 seconde aan schrijfacties.

  • Eén schrijver tegelijk

    Eén machine heeft de lease, en stopt met schrijven als ze die niet kan verlengen.

  • Versleuteld met jouw sleutel

    Elke megabyte ervan versleuteld met de sleutel van je project, via AES-256-GCM.

  • Eén thuisbasis

    Bewaard in één datacenter, en in geen tweede regio tenzij het verhuist.

Lees verder

Het platform