Aller au contenu

Cube

Cube

Toute image de conteneur, réveillée à chaque requête

Votre image en application, à sa propre adresse. Ses instances se réveillent pour les requêtes, s’endorment quand elles cessent et reprennent là où elles en étaient.

Lire la documentation

Cube en chiffres

pour réveiller une instance1
3.5 ms
d’inactivité avant de s’endormir, quand les requêtes sont espacées2
0 ms
pour annuler un déploiement
1 appel

En trois étapes

Les mêmes appels depuis la ligne de commande, l’API, les SDK et le serveur MCP.

Avant de commencer

Mettez votre clé API dans 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. Déployez une image

    Sa version reçoit le trafic dès qu’elle est prête, à sa propre adresse.

    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. Appelez-la

    La première requête réveille une instance.

    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. Suivez-la

    Une ligne par requête, qui dit si elle a réveillé une instance et en combien de temps.

    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› correspond à six caractères de l’identifiant de votre projet. L’API appelle un Cube une app.

Ce qu’il fait

  • Endormi quand les requêtes cessent, réveillé pour la suivante en 3.5 ms.1

  • Chaque déploiement est une version : le trafic bascule dès qu’elle est prête, et revient en un appel.

  • Une instance par clé, créée par sa première requête, avec sa propre mémoire et son propre disque.

  • Montée en charge dans chaque région : les instances démarrent au fil des requêtes, jusqu’au maximum que vous autorisez.

  • Votre propre domaine, avec un certificat émis et renouvelé pour vous.

  • Votre fichier Compose devient un Cube par service, chacun joignable par son nom.

Lire la documentation

Aperçus à titre d’illustration

Comparaison

Face aux deux façons habituelles de faire tourner un service.

Serveur toujours alluméConteneur scale-to-zeroCube
La première requête après une période calmeRéponse immédiateAttend qu’il redémarre depuis son imageLe réveille en 3.5 ms1
Mémoire et processus au reposConservésPerdusConservés pendant qu’il dort : une heure, ou aussi longtemps que vit une instance à clé
Ce que vous payez au reposToutRienPas de CPU ; seulement ce qu’il garde
Isolé des autres parUne machine virtuelleEn général, un noyau partagéSa propre microVM

Conçu pour

  • API et applications web

    CPU facturé à la milliseconde active, et mise en sommeil entre les requêtes.

    glac deploy ghcr.io/acme/web:2.0 \
      --name web --port 3000
    curl https://web-‹project›.glac.run/
  • Un backend par utilisateur ou par agent

    Une instance par clé, chacune avec sa propre mémoire et son propre disque.

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

    Une image qui s’exécute jusqu’au bout, puis s’arrête.

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

Prix et limites

Facturé selon les ressources Cube qu’il utilise, comme chaque produit. Tous les prix et forfaits

Ce qui est comptéCommentPrix
CPUTemps CPU actif, à la milliseconde$0.01 / million de ms CPU$0.00001 / seconde CPU$0.036 / heure CPU$26.28 / mois CPU
MémoireRéservée, à la milliseconde, par paliers de 128 MiB$0.00222 / million de GiB-ms$0.00000222 / GiB-seconde$0.008 / GiB-heure$5.84 / GiB-mois
RequêtesPar requête vers un Cube ou via un lien de bac à sable$0.30 / million
Trafic sortantNA · EUPar GB sortant d’Amérique du Nord et d’Europe$0.004 / GB
Trafic sortantAPACPar GB sortant d’Asie-Pacifique$0.01 / GB
En sommeil3Ce que gardent les instances endormies, et les instantanés$0.00000761 / million de GB-ms$0.00000000761 / GB-seconde$0.0000274 / GB-heure$0.02 / GB-mois
Journaux3La sortie conservée des Cubes, comptée telle qu’écrite$0.00000761 / million de GB-ms$0.00000000761 / GB-seconde$0.0000274 / GB-heure$0.02 / GB-mois

Estimer un mois de consommation

Une vraie charge de travail, et ce que coûte son mois avec le forfait Payant ou le forfait Gratuit.

Du JSON en entrée, du JSON en sortie, un appel ou deux à une base de données.

Une instance éveillée en moyenne 23.8 h par jour, plus 0.21 h en pause en mémoire. Au CPU des requêtes s’ajoutent 0.61 ms par requête : le temps d’éveil entre les requêtes, ainsi que chaque arrêt et chaque réveil.

Un mois de 30 jours, cette charge de travail seule sur le compte. Sources

Un mois avec le forfait Payant

$5.00

$0.39 par million de requêtes

  • CPU11 M de ms CPU$0.11
  • Mémoire90 GiB-h$0.72
  • Requêtes10 M de requêtes$3.00
  • Trafic sortant6 GB$0.02
Consommation aux prix catalogue
$3.85
Inclus dans le forfait Payant
−$3.85
Abonnement au forfait Payant
$5.00

Au-delà de ce que permet le forfait Gratuit : requêtes.

Ce que permettent les forfaits

Toutes les limites de chaque forfait
GratuitPayant
Cubespar compte10500
Instances d’un Cubepar région, au plus5500
Éveillés en même tempsinstances et bacs à sable5500
Plus grande instance2 vCPU, 4 GiB8 vCPU, 16 GiB
Variables et secretspar Cube64128
Conservation des journaux3 jours30 jours

Isolation

Une machine virtuelle pour chaque instance, et tout ce qu’elle garde chiffré avec la clé de votre projet.

Sécurité
  • Sa propre microVM

    Une microVM Firecracker avec son propre noyau, démarrée depuis votre image.

  • Une prison autour d’elle

    Une racine vide, un utilisateur sans privilèges, ses propres limites.

  • Joignable par l’API

    Commandes et fichiers passent par un agent à l’intérieur, pas par son réseau.

  • Le réseau que vous autorisez

    Un réseau privé par projet ; des règles pour les hôtes qu’elle peut joindre.

  • Chiffré avec votre clé

    Disques, mémoire endormie, instantanés et journaux, avant qu’ils ne quittent la machine.

  • Des clés qui n’ouvrent que ce qu’elles annoncent

    Une clé API ouvre un seul projet, dans la limite de ses portées ; un journal d’audit enregistre ce qu’elle fait.

Pour aller plus loin

La plateforme