Points de terminaison publics

• HTTPS : la plateforme assure la terminaison TLS en périphérie avec un certificat qu’elle provisionne et renouvelle, puis transmet la requête à votre port en HTTP non chiffré.
• TLS passthrough : la plateforme achemine la connexion vers votre port au moyen de Server Name Indication (SNI), sans la déchiffrer. Votre charge de travail assure elle-même la terminaison TLS et gère ses propres certificats.

​

Choisir l’authentification

export WANDB_API_KEY="[WANDB-API-KEY]"

uv pip install 'cwsandbox[wandb]>=1.16.0'

from cwsandbox import AuthStrategy

AUTH = AuthStrategy.WANDB

import { createSandboxClientFromEnv } from "@coreweave/cwsandbox/wandb";

export const client = createSandboxClientFromEnv();

export CWSANDBOX_API_KEY="[API-ACCESS-TOKEN]"

uv pip install 'cwsandbox>=1.16.0'

from cwsandbox import AuthStrategy

AUTH = AuthStrategy.COREWEAVE_API_KEY

import { createSandboxClientFromEnv } from "@coreweave/cwsandbox/node";

export const client = createSandboxClientFromEnv();

​

Comparer les deux types

​

Déclarer un point de terminaison

from sandbox_auth import AUTH
from cwsandbox import (
    Endpoint,
    EndpointAuth,
    EndpointKind,
    Sandbox,
    Service,
    ServiceVisibility,
)

sandbox = Sandbox.run(
    "python3", "-m", "http.server", "8080",
    container_image="python:3.11",
    services=[
        Service(
            port=8080,
            name="web",
            visibility=ServiceVisibility.PUBLIC,
            endpoint=Endpoint(kind=EndpointKind.HTTPS, auth=EndpointAuth.OPEN),
        ),
    ],
    resources={"cpu": "1", "memory": "1Gi"},
    auth=AUTH,
)

import { client } from "./sandbox-client.mts";

const sandbox = await client.run(["python3", "-m", "http.server", "8080"], {
  containerImage: "python:3.11",
  services: [
    {
      port: 8080,
      name: "web",
      visibility: "public",
      endpoint: { kind: "https", auth: "open" },
    },
  ],
});

from sandbox_auth import AUTH
from cwsandbox import (
    Endpoint,
    EndpointKind,
    Sandbox,
    Service,
    ServiceVisibility,
)

sandbox = Sandbox.run(
    "python3", "/srv/serve_tls.py",
    container_image="python:3.11",
    services=[
        Service(
            port=8443,
            name="tls",
            visibility=ServiceVisibility.PUBLIC,
            endpoint=Endpoint(kind=EndpointKind.TLS_PASSTHROUGH),
        ),
    ],
    resources={"cpu": "1", "memory": "1Gi"},
    auth=AUTH,
)

import { client } from "./sandbox-client.mts";

const sandbox = await client.run(["python3", "/srv/serve_tls.py"], {
  containerImage: "python:3.11",
  services: [
    {
      port: 8443,
      name: "tls",
      visibility: "public",
      endpoint: { kind: "tls_passthrough" },
    },
  ],
});

• Les ports et les noms doivent être uniques dans l’ensemble des entrées services, y compris les noms générés pour les ports sans nom.
• Les entrées comportant un endpoint nécessitent visibility=PUBLIC. Définissez protocol=TCP ou ne définissez pas protocol. La plateforme rejette les points de terminaison UDP et SCTP.
• Les entrées simples sans endpoint peuvent ne pas définir de visibilité ou utiliser PRIVATE, PUBLIC ou CUSTOM. Elles peuvent déclarer TCP, UDP ou SCTP. Si aucun protocole n’est défini, TCP est utilisé par défaut. L’exposition effective dépend des capacités et de la politique du déploiement. Ces champs ne créent pas de point de terminaison public. Pour modifier les sources autorisées des services CUSTOM existants, voir Politiques réseau dynamiques.
• Ne combinez pas des services simples exposés avec des entrées de point de terminaison. Dans une sandbox comportant des points de terminaison, ne définissez la visibilité d’aucun service simple. En l’absence de point de terminaison, utilisez au plus une valeur de visibilité exposée pour l’ensemble des services simples.
• Omettez auth et request_timeout_seconds en mode TLS passthrough. En Python, passez None plutôt que 0. Le SDK rejette tout délai d’expiration défini, y compris 0.
• Une limite de la plateforme plafonne le nombre de services qu’une sandbox peut déclarer. Les opérateurs configurent ce plafond pour leur déploiement.

​

Se connecter avec un jeton de partage

import time
import urllib.error
import urllib.request

from sandbox_auth import AUTH
from cwsandbox import (
    Endpoint,
    EndpointAuth,
    EndpointKind,
    Sandbox,
    Service,
    ServiceVisibility,
)


def get_status(url, headers=None):
    request = urllib.request.Request(url, headers=headers or {})
    try:
        with urllib.request.urlopen(request, timeout=10) as response:
            return response.status
    except urllib.error.HTTPError as error:
        return error.code


with Sandbox.run(
    "python3", "-m", "http.server", "8080",
    container_image="python:3.11",
    services=[
        Service(
            port=8080,
            name="web",
            visibility=ServiceVisibility.PUBLIC,
            endpoint=Endpoint(kind=EndpointKind.HTTPS, auth=EndpointAuth.SHARE_TOKEN),
        ),
    ],
    resources={"cpu": "1", "memory": "1Gi"},
    max_lifetime_seconds=300,
    auth=AUTH,
) as sandbox:
    token = sandbox.endpoint_share_token
    if token is None:
        sandbox.start().result()
        token = sandbox.endpoint_share_token
    if token is None:
        raise RuntimeError("No share token returned; recreate the sandbox.")

    sandbox.wait()
    deadline = time.monotonic() + 60
    while time.monotonic() < deadline:
        sandbox.get_status()
        if sandbox.service_urls:
            url = sandbox.service_urls[0][2]
            try:
                if get_status(url, token.as_headers()) == 200:
                    break
            except (urllib.error.URLError, TimeoutError, OSError):
                pass
        time.sleep(2)
    else:
        raise TimeoutError("Authenticated request did not succeed within 60 seconds.")

    assert get_status(url) == 401, "Expected anonymous access to be rejected."
    print("Authenticated request: 200; anonymous request: 401")

​

Lire l’adresse attribuée

for endpoint in sandbox.service_addresses:
    print(endpoint.port, endpoint.name, endpoint.address)

for (const endpoint of sandbox.serviceAddresses ?? []) {
  console.log(endpoint.port, endpoint.name, endpoint.address);
}

import type { HttpsEndpointStatus } from "@coreweave/cwsandbox";

await sandbox.inspect();
const endpoints: readonly HttpsEndpointStatus[] = sandbox.serviceEndpoints ?? [];
for (const endpoint of endpoints) {
  console.log(
    endpoint.port,
    endpoint.name,
    endpoint.auth,
    endpoint.requestTimeoutSeconds,
    endpoint.url || "(no URL)",
  );
}

8443 tls 8443-2f8d41b6-9c3e-4a17-b5d2-7e0a13c64f89.a1b2c3d4.ep2.cwsandbox.com:443

• Une adresse TLS passthrough est attribuée dès la création de la sandbox : elle figure donc dans la réponse de création et reste disponible tant que la sandbox est en cours de création ou d’exécution.
• Une URL HTTPS devient disponible dès que sa route dispose d’un nom d’hôte, tant que la sandbox est en cours de création ou d’exécution. Appelez get_status() en Python ou inspect() en TypeScript en boucle jusqu’à ce que l’URL apparaisse ou que votre propre délai expire.
• Dans les deux cas, cela ne signifie pas que l’application est prête à servir. La plateforme n’attend pas que votre processus se lie au port pour signaler que la sandbox est en cours d’exécution : prévoyez donc une nouvelle tentative pour votre première connexion.

​

Se connecter à un point de terminaison TLS passthrough

• Envoyez l’hôte du point de terminaison comme nom de serveur SNI. La plateforme achemine le trafic uniquement en fonction du SNI : une connexion qui l’omet, ou qui transmet un autre nom, n’atteint pas votre sandbox.
• Faites confiance au certificat de la charge de travail. Le nom d’hôte du point de terminaison est attribué par la plateforme ; un certificat que vous émettez vous-même ne lui correspond donc pas, sauf si vous l’émettez pour ce nom d’hôte. Configurez le client pour qu’il fasse confiance à votre propre autorité de certification, ou épinglez le certificat.

import socket
import ssl

address = "[ENDPOINT-ADDRESS]"  # host:port provenant de service_addresses
host, port = address.rsplit(":", 1)

context = ssl.create_default_context(cafile="[PATH-TO-CA-CERT]")

with socket.create_connection((host, int(port))) as sock:
    with context.wrap_socket(sock, server_hostname=host) as tls:
        print(tls.version(), tls.getpeercert()["subject"])

​

Durée de vie du point de terminaison

• Il est lié à la sandbox, et non à un Pod. Si le Pod sous-jacent redémarre, l’adresse ne change pas.
• La suppression de la sandbox entraîne celle du point de terminaison. L’adresse n’est pas transférée vers une autre sandbox, et toute nouvelle sandbox reçoit une nouvelle adresse.
• Rien n’est réservé d’une sandbox à l’autre. Vous ne pouvez pas conserver un nom d’hôte pour le réutiliser.

​

Résoudre les échecs de création

​

Pages connexes

• Configuration du bac à sable : ressources, ports, secrets et délais d’expiration.
• Architecture des sandboxes : interactions entre les exécuteurs, les profils et le plan de contrôle.
• Accéder à un service tailnet depuis une sandbox : établir une connexion sortante vers un service privé via Tailscale.
• Cycle de vie d’une sandbox : les différents états par lesquels passe une sandbox.