Vai al contenuto

Cubo

Cubo

Qualsiasi immagine container, sveglia a ogni richiesta

La tua immagine come app, con un indirizzo proprio. Le sue istanze si svegliano per le richieste, si addormentano quando non ne arrivano più e riprendono da dove si erano fermate.

Leggi la documentazione

Cubo in cifre

per svegliare un’istanza1
3.5 ms
di inattività prima di addormentarsi, quando le richieste sono distanti tra loro2
0 ms
per fare il rollback di un deploy
1 chiamata

In tre passaggi

Le stesse chiamate dalla riga di comando, dall’API, dagli SDK e dal server MCP.

Prima di iniziare

Metti la tua chiave API 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. Fai il deploy di un’immagine

    La sua versione riceve il traffico appena è pronta, a un indirizzo proprio.

    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. Chiamalo

    La prima richiesta sveglia un’istanza.

    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. Osservalo

    Una riga per richiesta, che dice se ha svegliato un’istanza e quanto ci è voluto.

    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› sono sei caratteri dell’id del tuo progetto. L’API chiama un Cubo «app».

Cosa fa

  • Si addormenta quando le richieste cessano e si sveglia in 3.5 ms per la successiva.1

  • Ogni deploy è una versione: riceve il traffico appena è pronta, e si torna indietro con una sola chiamata.

  • Un’istanza per ogni chiave, creata dalla sua prima richiesta, con la sua memoria e il suo disco.

  • Scala in ogni regione: le istanze si avviano man mano che arrivano le richieste, fino al massimo che consenti.

  • Il tuo dominio, con il certificato emesso e rinnovato per te.

  • Il tuo file Compose diventa un Cubo per ogni servizio, ciascuno raggiungibile con il suo nome.

Leggi la documentazione

Anteprime illustrative

A confronto

Rispetto ai due modi più comuni di eseguire un servizio.

Server sempre accesoContainer che scala a zeroCubo
La prima richiesta dopo un periodo di inattivitàRisposta immediataAttende che riparta dalla sua immagineSveglia l’istanza in 3.5 ms1
Memoria e processi durante l’inattivitàConservatiPersiConservati mentre dorme: un’ora, o finché vive un’istanza per chiave
Cosa paghi durante l’inattivitàTuttoNienteNiente CPU; solo ciò che conserva
Isolato dagli altri tramiteUna macchina virtualeDi solito un kernel condivisoUna microVM tutta sua

Pensato per

  • API e app web

    CPU fatturata per millisecondo di lavoro; tra una richiesta e l’altra, dorme.

    glac deploy ghcr.io/acme/web:2.0 \
      --name web --port 3000
    curl https://web-‹project›.glac.run/
  • Un backend per utente o per agente

    Un’istanza per chiave, ognuna con la sua memoria e il suo disco.

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

    Un’immagine che gira fino alla fine, poi si ferma.

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

Prezzi e limiti

Si paga in base alle risorse di Cubo che usa, come ogni prodotto. Tutti i prezzi e i piani

Cosa viene conteggiatoCome si contaPrezzo
CPUTempo di lavoro della CPU, al millisecondo$0.01 / milione di CPU-ms$0.00001 / CPU-secondo$0.036 / CPU-ora$26.28 / CPU-mese
MemoriaRiservata, al millisecondo, a blocchi di 128 MiB$0.00222 / milione di GiB-ms$0.00000222 / GiB-secondo$0.008 / GiB-ora$5.84 / GiB-mese
RichiestePer richiesta a un Cubo o tramite il link di una sandbox$0.30 / milione
Traffico in uscitaNA · EUPer GB in uscita dal Nord America e dall’Europa$0.004 / GB
Traffico in uscitaAPACPer GB in uscita dall’Asia-Pacifico$0.01 / GB
Conservato durante il sonno3Ciò che conservano le istanze dormienti, e gli snapshot$0.00000761 / milione di GB-ms$0.00000000761 / GB-secondo$0.0000274 / GB-ora$0.02 / GB-mese
Log3Ciò che i Cubi stampano e viene conservato, così come è stampato$0.00000761 / milione di GB-ms$0.00000000761 / GB-secondo$0.0000274 / GB-ora$0.02 / GB-mese

Stima il costo di un mese

Un carico di lavoro reale, e quanto costa in un mese con il piano a pagamento e con quello gratuito.

JSON in entrata, JSON in uscita, una o due chiamate al database.

Un’istanza sveglia in media 23.8 ore al giorno, e in pausa in memoria per 0.21 ore in più. La CPU include 0.61 ms per richiesta oltre a quelli della richiesta stessa: il tempo di veglia tra una richiesta e l’altra, e ogni arresto e risveglio.

Un mese di 30 giorni, con solo questo carico di lavoro sull’account. Fonti

Un mese con il piano a pagamento

$5.00

$0.39 per milione di richieste

  • CPU11 Mln di CPU-ms$0.11
  • Memoria90 GiB-h$0.72
  • Richieste10 Mln di richieste$3.00
  • Traffico in uscita6 GB$0.02
Utilizzo a prezzo di listino
$3.85
Incluso nel piano a pagamento
−$3.85
Canone del piano a pagamento
$5.00

Oltre i limiti del piano gratuito: richieste.

Cosa consentono i piani

Tutti i limiti di ogni piano
GratuitoA pagamento
Cubiper account10500
Istanze di un Cuboin ogni regione, al massimo5500
Sveglie contemporaneamenteistanze e sandbox5500
Istanza più grande2 vCPU, 4 GiB8 vCPU, 16 GiB
Variabili e segretiper Cubo64128
Log conservati3 giorni30 giorni

Isolamento

Una macchina virtuale per ogni istanza, e tutto ciò che conserva sigillato con la chiave del tuo progetto.

Sicurezza
  • Una microVM tutta sua

    Una microVM Firecracker con il suo kernel, avviata dalla tua immagine.

  • Una jail tutt’intorno

    Una root vuota, un utente senza privilegi, limiti propri.

  • Raggiungibile tramite l’API

    Comandi e file passano da un agente al suo interno, non dalla sua rete.

  • La rete che consenti

    Una rete privata per progetto; regole per gli host che può raggiungere.

  • Sigillato con la tua chiave

    Dischi, memoria dormiente, snapshot e log, prima che lascino la macchina.

  • Chiavi che aprono solo ciò che dicono

    Una chiave API apre un solo progetto, nei limiti dei suoi ambiti; un registro di audit annota ciò che fa.

Per saperne di più

La piattaforma