Naar de inhoud

Kubus

Kubus

Elk containerimage, wakker voor elk verzoek

Je image als app op een eigen adres. De instanties worden wakker voor verzoeken, slapen als die ophouden en gaan verder waar ze gebleven waren.

Lees de docs

Kubus in cijfers

om een instantie te wekken1
3.5 ms
inactief voordat een instantie gaat slapen, als verzoeken ver uit elkaar liggen2
0 ms
om een uitrol terug te draaien
1 aanroep

In drie stappen

Dezelfde aanroepen vanaf de opdrachtregel, de API, de SDK’s en de MCP-server.

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 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. Rol een image uit

    De versie neemt het verkeer over zodra die klaar is, op een eigen adres.

    glac deploy ghcr.io/acme/api:1.4 \
      --name api --port 8080
    curl $API/apps -H "$AUTH" --json '{"name": "api",
      "image": "ghcr.io/acme/api:1.4", "port": 8080}'
    app = glac.cube.deploy("ghcr.io/acme/api:1.4",
                           name="api", port=8080)
    const app = await glac.cube.deploy("ghcr.io/acme/api:1.4",
      { name: "api", port: 8080 });
    cube_deploy {"app": "api", "image": "ghcr.io/acme/api:1.4",
                 "port": 8080}
  2. Roep hem aan

    Het eerste verzoek wekt een instantie.

    curl https://api-‹project›.glac.run/
    curl https://api-‹project›.glac.run/
    import urllib.request
    print(urllib.request.urlopen(app.url).status)
    console.log((await fetch(app.url)).status);
    # from a sandbox made for the one command
    sandbox_run {"command":
      "curl -s https://api-‹project›.glac.run/"}
  3. Volg hem

    Een regel per verzoek, die zegt of het een instantie wekte en hoe lang dat duurde.

    glac cube logs api -f
    curl -N "$API/apps/api/logs?follow=true" -H "$AUTH"
    for line in app.logs(follow=True):
        print(line)
    for await (const line of app.logs({ follow: true }))
      console.log(line);
    cube_logs {"app": "api", "kinds": ["requests"]}

‹project› is zes tekens uit de id van je project. In de API heet een Kubus een app.

Wat het doet

  • In slaap als de verzoeken ophouden, en in 3.5 ms wakker voor het volgende.1

  • Elke uitrol is een versie: het verkeer gaat over zodra die klaar is, en terug met één aanroep.

  • Een instantie voor elke sleutel, aangemaakt door het eerste verzoek, met een eigen geheugen en schijf.

  • Schalen per regio: instanties starten als er verzoeken komen, tot het maximum dat jij toestaat.

  • Je eigen domein, met een certificaat dat voor je wordt uitgegeven en vernieuwd.

  • Je Compose-bestand wordt een Kubus voor elke service, elk bereikbaar via zijn naam.

Lees de docs

Illustratieve voorbeelden

Vergelijking

Naast de twee gebruikelijke manieren om een service te draaien.

Server die altijd aanstaatContainer die naar nul schaaltKubus
Het eerste verzoek na een stille periodeMeteen beantwoordWacht terwijl hij opnieuw opstart vanuit zijn imageWekt hem in 3.5 ms1
Geheugen en processen bij inactiviteitBewaardKwijtBewaard tijdens de slaap: een uur, of zolang een instantie per sleutel bestaat
Wat je betaalt bij inactiviteitAllesNietsGeen CPU; alleen wat hij bewaart
Gescheiden van anderen doorEen virtuele machineMeestal een gedeelde kernelEen eigen microVM

Gebouwd voor

  • API’s en webapps

    CPU afgerekend per milliseconde rekentijd, en in slaap tussen verzoeken.

    glac deploy ghcr.io/acme/web:2.0 \
      --name web --port 3000
    curl https://web-‹project›.glac.run/
  • Een backend per gebruiker of agent

    Eén instantie per sleutel, elk met een eigen geheugen en schijf.

    glac.cube.deploy(
      "ghcr.io/acme/agent:3",
      name="agent", port=8080,
      keys={"from": {"header": "User"}})
  • Jobs

    Een image dat draait tot het klaar is en dan stopt.

    glac deploy ghcr.io/acme/report:1 \
      --name report --kind job
    glac cube logs report -f

Prijzen en limieten

Afgerekend op de resources van Kubus die het gebruikt, zoals elk product. Alle prijzen en abonnementen

Wat geteld wordtHoePrijs
CPUActieve CPU-tijd, per milliseconde$0.01 / miljoen CPU-ms$0.00001 / CPU-seconde$0.036 / CPU-uur$26.28 / CPU-maand
GeheugenBezet, per milliseconde, in stappen van 128 MiB$0.00222 / miljoen GiB-ms$0.00000222 / GiB-seconde$0.008 / GiB-uur$5.84 / GiB-maand
VerzoekenPer verzoek naar een Kubus of via een sandboxlink$0.30 / miljoen
Uitgaand verkeerNA · EUPer GB vanuit Noord-Amerika en Europa$0.004 / GB
Uitgaand verkeerAPACPer GB vanuit Azië-Pacific$0.01 / GB
In slaap bewaard3Wat slapende instanties bewaren, en snapshots$0.00000761 / miljoen GB-ms$0.00000000761 / GB-seconde$0.0000274 / GB-uur$0.02 / GB-maand
Logs3De bewaarde uitvoer van Kubussen, zoals geprint$0.00000761 / miljoen GB-ms$0.00000000761 / GB-seconde$0.0000274 / GB-uur$0.02 / GB-maand

Bereken een maand

Een echte workload, en wat een maand ervan kost met Betaald en met Gratis.

JSON erin, JSON eruit, een databaseaanroep of twee.

Een instantie is gemiddeld 23.8 uur per dag wakker, en nog 0.21 uur gepauzeerd in het geheugen. De CPU telt per verzoek 0.61 ms bovenop die van het verzoek zelf: de tijd dat een instantie tussen verzoeken wakker is, en elk stoppen en wakker worden.

Een maand van 30 dagen, met alleen deze workload op het account. Bronnen

Een maand met Betaald

$5.00

$0.39 per miljoen verzoeken

  • CPU11 mln. CPU-ms$0.11
  • Geheugen90 GiB-uur$0.72
  • Verzoeken10 mln. verzoeken$3.00
  • Uitgaand verkeer6 GB$0.02
Verbruik tegen de lijstprijzen
$3.85
Inbegrepen bij Betaald
−$3.85
Abonnementsgeld van Betaald
$5.00

Meer dan Gratis toestaat: verzoeken.

Wat de abonnementen toestaan

Alle limieten per abonnement
GratisBetaald
Kubussenper account10500
Instanties van een Kubusmaximaal, per regio5500
Tegelijk wakkerinstanties en sandboxen5500
Grootste instantie2 vCPU’s, 4 GiB8 vCPU’s, 16 GiB
Variabelen en geheimenper Kubus64128
Logs bewaard3 dagen30 dagen

Los van elkaar

Een virtuele machine voor elke instantie, en de sleutel van je project op alles wat ze bewaart.

Beveiliging
  • Een eigen microVM

    Een Firecracker-microVM met een eigen kernel, opgestart vanuit je image.

  • Een jail eromheen

    Een lege root, een gebruiker zonder rechten, eigen limieten.

  • Bereikbaar via de API

    Commando’s en bestanden gaan via een agent binnenin, niet via het netwerk.

  • Het netwerk dat jij toestaat

    Een privénetwerk per project; regels voor welke hosts bereikt mogen worden.

  • Versleuteld met jouw sleutel

    Schijven, slapend geheugen, snapshots en logs, voordat ze de machine verlaten.

  • Sleutels die alleen openen waarvoor ze bedoeld zijn

    Een API-sleutel opent één project, voor zover zijn scopes het toestaan; een auditlog legt vast wat hij doet.

Lees verder

Het platform