Pular para o conteúdo

Cubo

Cubo

Qualquer imagem de contêiner, acordada a cada requisição

Sua imagem como uma aplicação em um endereço próprio. As instâncias acordam com as requisições, dormem quando elas acabam e continuam de onde pararam.

Leia a documentação

O Cubo em números

para acordar uma instância1
3.5 ms
de espera antes de dormir, quando as requisições chegam bem espaçadas2
0 ms
para reverter um deploy
1 chamada

Em três passos

As mesmas chamadas pela linha de comando, pela API, pelos SDKs e pelo servidor MCP.

Antes de começar

Coloque sua chave de API em 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. Faça deploy de uma imagem

    A versão recebe o tráfego assim que fica pronta, em um endereço próprio.

    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. Chame a aplicação

    A primeira requisição acorda uma instância.

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

    Uma linha por requisição, dizendo se ela acordou uma instância e quanto tempo isso levou.

    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› são seis caracteres do ID do seu projeto. A API chama um Cubo de app.

O que ele faz

  • Dorme quando as requisições acabam e acorda para a próxima em 3.5 ms.1

  • Cada deploy é uma versão: o tráfego passa para ela assim que fica pronta e volta com uma chamada.

  • Uma instância para cada chave, criada pela primeira requisição, com memória e disco próprios.

  • Escala em cada região: as instâncias iniciam conforme chegam requisições, até o máximo que você permitir.

  • Seu próprio domínio, com o certificado emitido e renovado para você.

  • Seu arquivo Compose vira um Cubo para cada serviço, cada um acessado pelo nome.

Leia a documentação

Prévias ilustrativas

Em comparação

Lado a lado com as duas formas mais comuns de rodar um serviço.

Servidor sempre ligadoContêiner com escala até zeroCubo
A primeira requisição depois de um período sem tráfegoRespondida na horaEspera o contêiner reiniciar a partir da imagemAcorda a instância em 3.5 ms1
Memória e processos quando ociosoMantidosPerdidosMantidos enquanto dorme: uma hora, ou enquanto durar uma instância por chave
O que você paga quando ociosoTudoNadaSem CPU; só o que ele guarda
Isolado dos outros porUma máquina virtualEm geral, um kernel compartilhadoUma microVM própria

Feito para

  • APIs e aplicações web

    A CPU é cobrada por milissegundo de uso, e a aplicação dorme entre as requisições.

    glac deploy ghcr.io/acme/web:2.0 \
      --name web --port 3000
    curl https://web-‹project›.glac.run/
  • Um back-end por usuário ou agente

    Uma instância por chave, cada uma com memória e disco próprios.

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

    Uma imagem que roda até o fim e depois para.

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

Preços e limites

Cobrado pelos recursos do Cubo que usa, como todos os produtos. Todos os preços e planos

O que é medidoComoPreço
CPUTempo de CPU ocupada, por milissegundo$0.01 / milhão de ms de CPU$0.00001 / segundo de CPU$0.036 / hora de CPU$26.28 / mês de CPU
MemóriaReservada, por milissegundo, em incrementos de 128 MiB$0.00222 / milhão de GiB-ms$0.00000222 / GiB-segundo$0.008 / GiB-hora$5.84 / GiB-mês
RequisiçõesPor requisição para um Cubo ou pelo link de um sandbox$0.30 / milhão
Tráfego de saídaNA · EUPor GB que sai da América do Norte e da Europa$0.004 / GB
Tráfego de saídaAPACPor GB que sai da Ásia-Pacífico$0.01 / GB
Guardado enquanto dorme3O que as instâncias adormecidas guardam, e os snapshots$0.00000761 / milhão de GB-ms$0.00000000761 / GB-segundo$0.0000274 / GB-hora$0.02 / GB-mês
Logs3O que os Cubos imprimem e fica guardado, medido como impresso$0.00000761 / milhão de GB-ms$0.00000000761 / GB-segundo$0.0000274 / GB-hora$0.02 / GB-mês

Estime o custo de um mês

Uma carga de trabalho real e quanto o mês dela custa no Pago e no Gratuito.

JSON na entrada, JSON na saída, uma ou duas chamadas ao banco de dados.

Uma instância acordada 23.8 horas por dia, em média, e pausada na memória por mais 0.21 horas. A CPU soma 0.61 ms por requisição aos da própria requisição: o tempo que a instância passa acordada entre as requisições e cada vez que ela para e acorda.

Um mês de 30 dias, só com esta carga de trabalho na conta. Fontes

Um mês no Pago

$5.00

$0.39 por milhão de requisições

  • CPU11 mi de ms de CPU$0.11
  • Memória90 GiB-h$0.72
  • Requisições10 mi de requisições$3.00
  • Tráfego de saída6 GB$0.02
Uso a preços de tabela
$3.85
Incluído no Pago
−$3.85
Mensalidade do Pago
$5.00

Além do que o Gratuito permite: requisições.

O que os planos permitem

Todos os limites de cada plano
GratuitoPago
Cubospor conta10500
Instâncias de um Cuboem cada região, no máximo5500
Acordadas ao mesmo tempoinstâncias e sandboxes5500
Maior instância2 vCPUs, 4 GiB8 vCPUs, 16 GiB
Variáveis e segredospor Cubo64128
Retenção de logs3 dias30 dias

Isolamento

Uma máquina virtual para cada instância, e a chave do seu projeto em tudo o que ela guarda.

Segurança
  • Uma microVM própria

    Uma microVM Firecracker com kernel próprio, iniciada a partir da sua imagem.

  • Uma jail em volta

    Uma raiz vazia, um usuário sem privilégios, limites próprios.

  • Acesso pela API

    Comandos e arquivos passam por um agente dentro dela, e não pela rede.

  • A rede que você permitir

    Uma rede privada por projeto; regras para os hosts que ela pode acessar.

  • Criptografado com a sua chave

    Discos, memória de instâncias adormecidas, snapshots e logs, antes de saírem da máquina.

  • Chaves que só abrem o que declaram

    Uma chave de API abre um único projeto, até onde os escopos dela permitem; um log de auditoria registra o que ela faz.

Saiba mais

A plataforma