Przejdź do treści

Kostka

Kostka

Dowolny obraz kontenera, który budzi się na każde żądanie

Twój obraz jako aplikacja pod własnym adresem. Jej instancje budzą się, gdy przychodzą żądania, zasypiają, gdy żądania ustają, i wznawiają pracę tam, gdzie ją przerwały.

Przeczytaj dokumentację

Kostka w liczbach

na wybudzenie instancji1
3.5 ms
bezczynności przed zaśnięciem przy rzadkich żądaniach2
0 ms
na wycofanie wdrożenia
1 wywołanie

W trzech krokach

Te same wywołania z wiersza poleceń, API, SDK i serwera MCP.

Zanim zaczniesz

Ustaw swój klucz API w zmiennej 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. Wdróż obraz

    Jego wersja przejmuje ruch, gdy tylko jest gotowa, pod własnym adresem.

    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. Wywołaj aplikację

    Pierwsze żądanie budzi instancję.

    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. Obserwuj aplikację

    Po jednym wierszu na każde żądanie: czy wybudziło instancję i ile to trwało.

    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› to sześć znaków identyfikatora Twojego projektu. API nazywa Kostkę aplikacją (app).

Co potrafi

  • Zasypia, gdy żądania ustają, a następne budzi ją w 3.5 ms.1

  • Każde wdrożenie to wersja: ruch przechodzi na nią, gdy tylko jest gotowa, i wraca jednym wywołaniem.

  • Instancja dla każdego klucza, tworzona przy pierwszym żądaniu, z własną pamięcią i dyskiem.

  • Skalowanie w każdym regionie: instancje startują wraz z napływem żądań, aż do ustalonego przez Ciebie maksimum.

  • Własna domena, a certyfikat wystawiamy i odnawiamy za Ciebie.

  • Twój plik Compose zamienia się w osobną Kostkę dla każdej usługi, dostępną pod jej nazwą.

Przeczytaj dokumentację

Ilustracje poglądowe

Porównanie

W zestawieniu z dwoma typowymi sposobami uruchamiania usługi.

Serwer 24/7Kontener skalowany do zeraKostka
Pierwsze żądanie po przerwieObsłużone od razuCzeka, aż kontener znów wystartuje z obrazuBudzi instancję w 3.5 ms1
Pamięć i procesy podczas bezczynnościZachowaneUtraconeZachowane w uśpieniu: przez godzinę albo tak długo, jak żyje instancja przypisana do klucza
Za co płacisz w czasie bezczynnościZa wszystkoZa nicNie za CPU, tylko za to, co przechowuje
Izolacja od innychMaszyna wirtualnaZwykle współdzielone jądroWłasna microVM

Do czego służy

  • API i aplikacje webowe

    CPU rozliczane za każdą milisekundę pracy, a między żądaniami aplikacja śpi.

    glac deploy ghcr.io/acme/web:2.0 \
      --name web --port 3000
    curl https://web-‹project›.glac.run/
  • Backend dla każdego użytkownika lub agenta

    Jedna instancja na klucz, każda z własną pamięcią i dyskiem.

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

    Obraz, który działa, aż skończy, a potem się zatrzymuje.

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

Ceny i limity

Rozliczana według zużytych zasobów Kostki, jak każdy produkt. Wszystkie ceny i plany

Co jest liczoneJakCena
CPUCzas pracy CPU, co do milisekundy$0.01 / mln ms CPU$0.00001 / sekunda CPU$0.036 / godzina CPU$26.28 / miesiąc CPU
PamięćZajmowana, co do milisekundy, w blokach po 128 MiB$0.00222 / mln GiB-ms$0.00000222 / GiB-sekunda$0.008 / GiB-godzina$5.84 / GiB-miesiąc
ŻądaniaZa żądanie do Kostki lub przez link piaskownicy$0.30 / mln
Ruch wychodzącyNA · EUZa GB wychodzący z Ameryki Północnej i Europy$0.004 / GB
Ruch wychodzącyAPACZa GB wychodzący z regionu Azji i Pacyfiku$0.01 / GB
Przechowywane w uśpieniu3To, co przechowują uśpione instancje, oraz migawki$0.00000761 / mln GB-ms$0.00000000761 / GB-sekunda$0.0000274 / GB-godzina$0.02 / GB-miesiąc
Logi3Przechowywane logi Kostek, liczone przed kompresją$0.00000761 / mln GB-ms$0.00000000761 / GB-sekunda$0.0000274 / GB-godzina$0.02 / GB-miesiąc

Oszacuj miesięczny koszt

Prawdziwe obciążenie i jego miesięczny koszt w planie Płatnym i w planie Bezpłatnym.

JSON na wejściu, JSON na wyjściu, jedno lub dwa zapytania do bazy danych.

Instancja jest aktywna średnio 23.8 h dziennie, a przez kolejne 0.21 h wstrzymana w pamięci. Do CPU samych żądań doliczamy 0.61 ms na każde żądanie: czas aktywności między żądaniami oraz każde zatrzymanie i wybudzenie.

Miesiąc liczący 30 dni; na koncie działa tylko to obciążenie. Źródła

Miesiąc w planie Płatnym

$5.00

$0.39 za milion żądań

  • CPU11 mln ms CPU$0.11
  • Pamięć90 GiB-h$0.72
  • Żądania10 mln żądań$3.00
  • Ruch wychodzący6 GB$0.02
Zużycie po cenach katalogowych
$3.85
W cenie planu Płatnego
−$3.85
Opłata za plan Płatny
$5.00

Za dużo jak na plan Bezpłatny: żądań.

BezpłatnyPłatny
Kostkina konto10500
Instancje Kostkiw każdym regionie, maksymalnie5500
Aktywne jednocześnieinstancje i piaskownice5500
Największa instancja2 vCPU, 4 GiB8 vCPU, 16 GiB
Zmienne i sekretyna Kostkę64128
Przechowywanie logów3 dni30 dni

Izolacja

Maszyna wirtualna dla każdej instancji, a wszystko, co przechowuje, zaszyfrowane kluczem Twojego projektu.

Bezpieczeństwo
  • Własna microVM

    Osobna microVM Firecracker z własnym jądrem, uruchamiana z Twojego obrazu.

  • Dodatkowa warstwa izolacji

    Pusty katalog główny, użytkownik bez uprawnień, własne limity.

  • Dostęp przez API

    Polecenia i pliki przechodzą przez agenta wewnątrz niej, a nie przez jej sieć.

  • Sieć, na którą pozwolisz

    Prywatna sieć dla każdego projektu; reguły określają, z którymi hostami może się łączyć.

  • Zaszyfrowane Twoim kluczem

    Dyski, pamięć w uśpieniu, migawki i logi, zanim opuszczą maszynę.

  • Klucze, które otwierają tylko to, co mają otwierać

    Klucz API otwiera jeden projekt, w granicach swoich zakresów; dziennik audytu zapisuje, co robi.

Czytaj dalej

Platforma