Saltar al contenido

Cubo

Cubo

Cualquier imagen de contenedor, despierta para cada solicitud

Tu imagen como una app en su propia dirección. Sus instancias se despiertan con las solicitudes, se duermen cuando estas dejan de llegar y continúan donde lo dejaron.

Lee la documentación

Cubo en cifras

en despertar una instancia1
3.5 ms
de inactividad antes de dormirse, si las solicitudes llegan muy espaciadas2
0 ms
para revertir un despliegue
1 llamada

En tres pasos

Las mismas llamadas desde la línea de comandos, la API, los SDK y el servidor MCP.

Antes de empezar

Pon tu clave de API en 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. Despliega una imagen

    Su versión recibe el tráfico en cuanto está lista, en una dirección propia.

    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. Invócala

    La primera solicitud despierta una instancia.

    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. Obsérvala

    Una línea por solicitud, que dice si despertó una instancia y cuánto tardó.

    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› son seis caracteres del ID de tu proyecto. La API llama app a un Cubo.

Qué hace

  • Se duerme cuando dejan de llegar solicitudes y se despierta en 3.5 ms para la siguiente.1

  • Cada despliegue es una versión: el tráfico pasa a ella cuando está lista, y vuelve con una sola llamada.

  • Una instancia por cada clave, creada por su primera solicitud y con su propia memoria y su propio disco.

  • Escala en cada región: las instancias arrancan a medida que llegan solicitudes, hasta el máximo que permitas.

  • Tu propio dominio, con su certificado emitido y renovado automáticamente.

  • Tu archivo Compose se convierte en un Cubo por cada servicio, cada uno accesible por su nombre.

Lee la documentación

Vistas previas ilustrativas

En comparación

Junto a las dos formas habituales de ejecutar un servicio.

Servidor siempre encendidoContenedor que escala a ceroCubo
La primera solicitud tras un rato sin tráficoRespondida al instanteEspera mientras arranca de nuevo desde su imagenLo despierta en 3.5 ms1
Memoria y procesos mientras está inactivoSe guardanSe pierdenSe guardan mientras duerme: una hora, o mientras viva una instancia por clave
Lo que pagas mientras está inactivoTodoNadaNada de CPU; solo lo que guarda
Aislado de los demás medianteUna máquina virtualNormalmente, un kernel compartidoUna microVM propia

Pensado para

  • API y apps web

    CPU facturada por milisegundo en uso; entre solicitudes, duerme.

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

    Una instancia por clave, cada una con su propia memoria y su propio disco.

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

    Una imagen que se ejecuta hasta el final y luego se detiene.

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

Precios y límites

Facturado por los recursos de Cubo que usa, como todos los productos. Todos los precios y planes

Qué se cuentaCómoPrecio
CPUTiempo de CPU en uso, por milisegundo$0.01 / millón de ms de CPU$0.00001 / segundo de CPU$0.036 / hora de CPU$26.28 / mes de CPU
MemoriaReservada, por milisegundo, en incrementos de 128 MiB$0.00222 / millón de GiB-ms$0.00000222 / GiB-segundo$0.008 / GiB-hora$5.84 / GiB-mes
SolicitudesPor solicitud a un Cubo o a través del enlace de un sandbox$0.30 / millón
Tráfico de salidaNA · EUPor GB que sale de Norteamérica y Europa$0.004 / GB
Tráfico de salidaAPACPor GB que sale de Asia-Pacífico$0.01 / GB
Guardado en reposo3Lo que guardan las instancias dormidas, y las instantáneas$0.00000761 / millón de GB-ms$0.00000000761 / GB-segundo$0.0000274 / GB-hora$0.02 / GB-mes
Registros3Lo que imprimen los Cubos y se guarda, tal como se imprime$0.00000761 / millón de GB-ms$0.00000000761 / GB-segundo$0.0000274 / GB-hora$0.02 / GB-mes

Calcula un mes de uso

Una carga de trabajo real y lo que cuesta su mes en el plan de pago y en el plan Gratis.

JSON de entrada, JSON de salida, una o dos llamadas a la base de datos.

Una instancia pasa despierta 23.8 h al día en promedio, y 0.21 h más en pausa en memoria. A la CPU de cada solicitud se suman 0.61 ms: el tiempo que la instancia pasa despierta entre solicitudes y cada vez que se detiene y se despierta.

Un mes de 30 días, con solo esta carga de trabajo en la cuenta. Fuentes

Un mes en el plan de pago

$5.00

$0.39 por millón de solicitudes

  • CPU11 M de ms de CPU$0.11
  • Memoria90 GiB-h$0.72
  • Solicitudes10 M de solicitudes$3.00
  • Tráfico de salida6 GB$0.02
Uso a precios de lista
$3.85
Incluido en el plan de pago
−$3.85
Cuota del plan de pago
$5.00

Por encima de lo que permite el plan Gratis: solicitudes.

Lo que permiten los planes

Todos los límites de cada plan
GratisDe pago
Cubospor cuenta10500
Instancias de un Cuboen cada región, como máximo5500
Despiertas a la vezinstancias y sandboxes5500
Instancia más grande2 vCPU, 4 GiB8 vCPU, 16 GiB
Variables y secretospor Cubo64128
Retención de registros3 días30 días

Aislado

Una máquina virtual para cada instancia, y todo lo que guarda, cifrado con la clave de tu proyecto.

Seguridad
  • Una microVM propia

    Una microVM de Firecracker con su propio kernel, arrancada desde tu imagen.

  • Una jaula a su alrededor

    Una raíz vacía, un usuario sin privilegios, sus propios límites.

  • Accesible a través de la API

    Los comandos y los archivos pasan por un agente dentro de ella, no por su red.

  • La red que permitas

    Una red privada por proyecto; reglas para los hosts a los que puede acceder.

  • Cifrado con tu clave

    Discos, memoria en reposo, instantáneas y registros, antes de que salgan de la máquina.

  • Claves que solo abren lo que dicen

    Una clave de API abre un solo proyecto, hasta donde permiten sus ámbitos; un registro de auditoría anota lo que hace.

Sigue leyendo

La plataforma