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.
Cube en chiffres
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-mcpDé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 8080curl $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}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/"}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 -fcurl -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.
Aperçus à titre d’illustration
Comparaison
Face aux deux façons habituelles de faire tourner un service.
| Serveur toujours allumé | Conteneur scale-to-zero | Cube | |
|---|---|---|---|
| La première requête après une période calme | Réponse immédiate | Attend qu’il redémarre depuis son image | Le réveille en 3.5 ms1 |
| Mémoire et processus au repos | Conservés | Perdus | Conservés pendant qu’il dort : une heure, ou aussi longtemps que vit une instance à clé |
| Ce que vous payez au repos | Tout | Rien | Pas de CPU ; seulement ce qu’il garde |
| Isolé des autres par | Une machine virtuelle | En 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é | Comment | Prix |
|---|---|---|
| CPU | Temps CPU actif, à la milliseconde | $0.01 / million de ms CPU$0.00001 / seconde CPU$0.036 / heure CPU$26.28 / mois CPU |
| Mémoire | Ré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êtes | Par requête vers un Cube ou via un lien de bac à sable | $0.30 / million |
| Trafic sortantNA · EU | Par GB sortant d’Amérique du Nord et d’Europe | $0.004 / GB |
| Trafic sortantAPAC | Par GB sortant d’Asie-Pacifique | $0.01 / GB |
| En sommeil3 | Ce 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 |
| Journaux3 | La 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.
Des pages rendues côté serveur, avec connexion.
Chaque requête attend la réponse d’un modèle.
Des événements venus d’autres services, et du travail planifié.
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
$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
- Données stockées$0.00
- Cache NVMe$0.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.
Glac$3.85
À la taille
Ce que permettent les forfaits
Toutes les limites de chaque forfait| Gratuit | Payant | |
|---|---|---|
| Cubespar compte | 10 | 500 |
| Instances d’un Cubepar région, au plus | 5 | 500 |
| Éveillés en même tempsinstances et bacs à sable | 5 | 500 |
| Plus grande instance | 2 vCPU, 4 GiB | 8 vCPU, 16 GiB |
| Variables et secretspar Cube | 64 | 128 |
| Conservation des journaux | 3 jours | 30 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
- CubeAdresses, versions, instances et leur sommeil, protocoles, instances à clé.
- Services et ComposeLe réseau privé, les variables partagées, le déploiement de plusieurs services, les fichiers Compose.
- Journaux et exportLe journal d’un Cube, ses métriques, et leur envoi vers tout récepteur OpenTelemetry.
- La référence de l’APIChaque appel pour les apps, les versions, les instances et les domaines.
La plateforme
Cube
Applications managées
- Bac à sableUn ordinateur dédié à chaque agent
- BientôtNavigateurDe vrais navigateurs, pilotés par le code
- BientôtPostgres sans serveurPostgres qui s’endort au repos et se réveille dès qu’on s’y connecte
- BientôtApplications tiercesDes projets open source exécutés pour vous, puis une place de marché