Sandboxes on Northflank cloud

Isolation on Northflank cloud is automatic. CPU sandboxes run in microVMs, and GPU sandboxes run under gVisor. You do not select a runtime, and there is nothing to configure.

GPU sandboxes have an extra requirement: the project must sit in a GPU-enabled region, such as asia-southeast. You choose a region when you create a project and you cannot move a project afterwards, so pick a GPU-enabled region up front if you plan to run GPU workloads.

Sandboxes run in projects. A project deployed to Northflank's managed cloud gets sandbox isolation automatically.

1. In the Northflank dashboard, click Create Project.
2. Enter a project name.
3. Choose Northflank Cloud as the deployment target.
4. Select a region. Pick a GPU-enabled one if you plan to run GPU sandboxes, because this cannot be changed later.
5. Click Create project.

Note the project ID. You pass it as a parameter in every API call that follows.

See create a project for the full walkthrough.

Projects on Northflank cloud are created from your team dashboard. Any sandbox you deploy into one of those projects runs on Northflank's managed infrastructure automatically, with no extra configuration.

const sandboxId = `sandbox-${crypto.randomUUID().split('-')[4]}`;

await apiClient.create.service.deployment({
  parameters: {
    projectId: 'your-northflank-project-id',
  },
  data: {
    name: sandboxId,
    billing: {
      deploymentPlan: 'nf-compute-200',
    },
    deployment: {
      instances: 1,
      docker: {
        configType: 'customCommand',
        customCommand: 'sleep infinity',
      },
      external: {
        imagePath: 'ubuntu:22.04',
      },
      storage: {
        ephemeralStorage: {
          storageSize: 2048,
        },
      },
    },
  },
});

import uuid

sandbox_id = f"sandbox-{uuid.uuid4().hex[:8]}"

client.create.service.deployment(
    project_id="your-northflank-project-id",
    data={
        "name": sandbox_id,
        "billing": {"deploymentPlan": "nf-compute-200"},
        "deployment": {
            "instances": 1,
            "docker": {
                "configType": "customEntrypointCustomCommand",
                "customEntrypoint": "/bin/bash",
                "customCommand": "-c 'sleep infinity'",
            },
            "external": {"imagePath": "ubuntu:22.04"},
            "storage": {"ephemeralStorage": {"storageSize": 2048}},
        },
    },
)

See create a project if you do not have a project yet.

The billing.deploymentPlan field sets how much CPU and memory a sandbox gets. Northflank cloud offers standard plans from nf-compute-10 at the small end up to nf-compute-2000, with nf-compute-200 a reasonable starting point for most sandboxes.

See the pricing page for the vCPU, memory, and cost of each plan.

You can also list the plans available to your account, with their CPU and memory, using list.plans.

Change a plan at any time by scaling the service. The sandbox restarts with the new allocation, and anything held only in ephemeral storage is lost:

await apiClient.scale.service({
  parameters: {
    projectId: 'your-project-id',
    serviceId: sandboxId,
  },
  data: {
    deploymentPlan: 'nf-compute-400',
  },
});

client.scale.service(
    project_id="your-project-id",
    service_id=sandbox_id,
    data={"deploymentPlan": "nf-compute-400"},
)

On your own cloud you are not limited to these plans. See create custom resource plans.

GPU sandboxes provide GPU acceleration on Northflank cloud. Create the project in a region that supports your GPU type and count. Then select the matching GPU resource plan for the sandbox.

GPU sandboxes use gVisor isolation automatically. GPU plans include CPU and system RAM. Set deployment.gpu.enabled to true and set the matching type and count in deployment.gpu.configuration.

See GPU plans and regions for plan IDs and supported configurations. Your account needs GPU access.

The GPU sandbox example creates a project and a Jupyter sandbox. Choose one or eight H100 or RTX PRO 6000 GPUs, with compatible ephemeral storage and shared memory.

For model serving, use the SGLang example with persistent storage.

Northflank cloud bills compute per second of runtime. Pausing a sandbox scales it to zero instances, which stops compute charges. Volumes attached to a paused sandbox continue to be billed, because the data is still stored.

• Compute is charged per second against the resource plan you selected.
• Volumes are charged per GB per month, whether the sandbox is running or paused.
• Ephemeral storage is included in the compute charge.

Short-lived sandboxes are cheap to run precisely because of per-second billing: a sandbox that exists for 40 seconds is billed for 40 seconds.

See the pricing page for current rates, and monitor spending to set up billing alerts before costs surprise you.