Snapshots

Snapshots are persistent, point-in-time captures of sandbox state, including the filesystem, installed packages, dependencies, and settings. A snapshot saves a sandbox's state so you can restore it later, and any number of new sandboxes can start from the same snapshot.

Daytona provides default snapshots for creating sandboxes. You can also create snapshots from images, capture the state of existing sandboxes, or create warm pools for a snapshot:

• Create snapshots from an image: define the base operating system, language runtimes, packages, and project-level setup in an image or Dockerfile, and Daytona builds it into a snapshot you can use to create sandboxes
• Create snapshots from a sandbox: captures and persists a sandbox's current state; container sandboxes capture filesystem state only (cold snapshots), VM sandboxes capture filesystem and memory state (hot snapshots)
• Warm pools: keep a configured number of pre-created, running sandboxes built from a snapshot; matching sandbox create requests claim one warm sandbox from the pool instantly instead of provisioning a new sandbox

Default snapshots

Default snapshots include pre-installed Python and Node.js packages.

1. Go to Daytona Sandboxes ↗
2. Click Create Sandbox
3. Select a snapshot
4. Click Create

from daytona import Daytona, CreateSandboxFromSnapshotParams

daytona = Daytona()
sandbox = daytona.create(
    CreateSandboxFromSnapshotParams(
        snapshot="daytona-small",
    )
)

Create snapshots

Create a snapshot.

1. Go to Daytona Snapshots ↗
2. Click Create Snapshot
3. Enter the snapshot name and image of any publicly accessible image or container registry
   • Snapshot name: identifier used to reference the snapshot
   • Snapshot image: base image for the snapshot, must include either a tag or a digest (e.g., ubuntu:22.04); the latest/lts/stable tags are not supported
4. Click Create

from daytona import Daytona, CreateSnapshotParams

daytona = Daytona()
snapshot = daytona.snapshot.create(
    CreateSnapshotParams(name="my-awesome-snapshot", image="ubuntu:22.04"),
)

VM snapshots

Daytona provides methods to create VM snapshots for Linux VM and Windows.

VM snapshots are used to create VM sandboxes. VM snapshots are distinct from container snapshots and cannot be used to create container sandboxes. VM snapshots support VM-only capabilities such as creating a snapshot from a sandbox.

from daytona import Daytona, CreateSnapshotParams, SandboxClass

daytona = Daytona()
snapshot = daytona.snapshot.create(
    CreateSnapshotParams(
        name="my-vm-snapshot",
        image="ubuntu:22.04",
        sandbox_class=SandboxClass.LINUX_VM,
    )
)

GPU snapshots

Create a GPU snapshot. GPU snapshots are used to create GPU sandboxes.

1. Go to Daytona Snapshots ↗

2. Click Create Snapshot

3. Enter the snapshot name and image

4. Select the Allocate GPU checkbox

5. Specify the GPU type(s):

   • NVIDIA H100
   • NVIDIA H200
   • NVIDIA RTX PRO 6000
   • NVIDIA RTX 4090
   • NVIDIA RTX 5090

6. Click Create

from daytona import CreateSnapshotParams, Daytona, Image, Resources

daytona = Daytona()
snapshot = daytona.snapshot.create(
    CreateSnapshotParams(
        name="my-gpu-snapshot",
        image=Image.base("python:3.12"),
        resources=Resources(cpu=1, memory=1, disk=1, gpu=1),
    ),
)

Create snapshot from sandbox

Create a snapshot from a running or stopped sandbox.

sandbox._experimental_create_snapshot("my-snapshot")

Snapshots from private registries

Create a snapshot from images from private container registries.

1. Go to Daytona Registries ↗

2. Click Add Registry and select your provider:

   • Docker Hub
   • Google Artifact Registry
   • GitHub Container Registry
   • Amazon ECR

3. Enter the required fields

4. Go to Daytona Snapshots ↗

5. Click Create Snapshot

6. Enter the snapshot name and the full image reference, including the registry host and repository (e.g. my-registry.com/<repo>/custom-alpine:3.21)

Docker Hub

Create a snapshot from Docker Hub images.

1. Go to Daytona Registries ↗

2. Click Add Registry and select the Docker Hub tab

3. Input the following fields:

   • Username: your Docker Hub username (the account with access to the image)
   • Personal Access Token: a Docker Hub PAT; not your account password
   • Registry URL: auto-filled with docker.io and not shown in the form

4. Create the snapshot using the full image reference

   docker.io/<username>/<image>:<tag>

Google Artifact Registry

Create a snapshot from images from Google Artifact Registry.

1. Go to Daytona Registries ↗,

2. Click Add Registry and select the Google tab

3. Input the following fields:

   • Registry URL: the base URL for your region

     https://<region>-docker.pkg.dev

   • Service Account JSON Key: the contents of your service account key JSON file

   • Google Cloud Project ID: your GCP project ID

   • Username: auto-filled with _json_key (required by Google for service-account auth)

4. Create the snapshot using the full image reference

   <region>-docker.pkg.dev/<project>/<repo>/<image>:<tag>

GitHub Container Registry

Create a snapshot from images from GitHub Container Registry.

1. Go to Daytona Registries ↗,

2. Click Add Registry and select the GitHub tab

3. Input the following fields:

   • GitHub Username: the account with access to the image
   • Personal Access Token: a GitHub PAT with read:packages scope (and write:packages / delete:packages for pushing or deleting)
   • Registry URL: auto-filled with ghcr.io and not shown in the form

4. Create the snapshot using the full image reference

   ghcr.io/<owner>/<image>:<tag>

Amazon ECR

Create a snapshot from images from Amazon Elastic Container Registry.

Daytona pulls private ECR images via cross-account IAM role assumption. You create a role in your AWS account that trusts Daytona's broker principal, and Daytona assumes it on every pull to fetch a short-lived ECR token.

• Daytona Broker ARN

  The IAM principal Daytona uses to assume into your role. Self-hosted: substitute the IAM role your API pods assume (e.g. via IRSA).

  arn:aws:iam::967657494466:role/DaytonaEcrCredentialBroker

• External ID

  Your Daytona organization ID, visible in the dashboard URL (/dashboard/<orgId>/...) and on your organization settings page.

1. Create an IAM role in your AWS account

   • Trust policy

   {
     "Version": "2012-10-17",
     "Statement": [{
       "Effect": "Allow",
       "Principal": { "AWS": "arn:aws:iam::967657494466:role/DaytonaEcrCredentialBroker" },
       "Action": "sts:AssumeRole",
       "Condition": {
         "StringEquals": {
           "sts:ExternalId": "<YOUR_EXTERNAL_ID>"
         }
       }
     }]
   }

   • Permissions policy (read-only on ECR)

   {
     "Version": "2012-10-17",
     "Statement": [{
       "Effect": "Allow",
       "Action": [
         "ecr:GetAuthorizationToken",
         "ecr:BatchCheckLayerAvailability",
         "ecr:GetDownloadUrlForLayer",
         "ecr:BatchGetImage"
       ],
       "Resource": "*"
     }]
   }

2. Go to Daytona Registries ↗

3. Click Add Registry and select the Amazon ECR tab

4. Input the following fields:

   • Registry URL: <account_id>.dkr.ecr.<region>.amazonaws.com
   • Role ARN: the role you created in step 1

   Password is not used for ECR. Daytona resolves credentials server-side by assuming the role you created in step 1, using your organization ID as the AssumeRole ExternalId.

5. Go to Daytona Snapshots ↗

6. Click Create Snapshot

7. Enter the snapshot name and the full image reference

   <account_id>.dkr.ecr.<region>.amazonaws.com/<repo>/<image>:<tag>

8. (Optional) Harden the trust policy

   Daytona sends a daytona-<orgId>-pull session name on every AssumeRole call. You can require it in your trust policy for CloudTrail audit visibility. Add inside Condition:

   "StringLike": {
     "sts:RoleSessionName": "daytona-<YOUR_EXTERNAL_ID>-*"
   }

Snapshots from local images

Create a snapshot from local images or from local Dockerfiles.

Daytona expects the local image to be built for AMD64 architecture. Therefore, the --platform=linux/amd64 flag is required when building the Docker image if your machine is running on a different architecture.

1. Ensure the image and tag you want to use is available

docker images

2. Create a snapshot and push it to Daytona:

daytona snapshot push custom-alpine:3.21 --name alpine-minimal

Alternatively, use the --dockerfile flag under create to pass the path to the Dockerfile you want to use and Daytona will build the snapshot for you. The COPY/ADD commands will be automatically parsed and added to the context. To manually add files to the context, use the --context flag.

daytona snapshot create my-awesome-snapshot --dockerfile ./Dockerfile

Get snapshot

Get a snapshot by name.

daytona.snapshot.get("my-awesome-snapshot")

List snapshots

List snapshots and view their details.

daytona.snapshot.list(page=2, limit=10)

Activate snapshots

Activate an inactive snapshot.

Snapshots automatically become inactive after 2 weeks of not being used.

1. Go to Daytona Snapshots ↗
2. Click the three dots at the end of the row for the snapshot you want to activate
3. Click Activate

daytona.snapshot.activate("my-awesome-snapshot")

Deactivate snapshots

Deactivate a snapshot.

Deactivated snapshots are not available for new sandboxes. Deactivating a snapshot also pauses top-ups of its warm pools; the pool reports the reason in its errorReason field.

1. Go to Daytona Snapshots ↗
2. Click the three dots at the end of the row for the snapshot you want to deactivate
3. Click Deactivate

Delete snapshots

Delete a snapshot.

Deleted snapshots cannot be recovered. Deleting a snapshot also deletes its warm pools and destroys their unclaimed warm sandboxes.

1. Go to Daytona Snapshots ↗
2. Click the three dots at the end of the row for the snapshot you want to delete
3. Click Delete

daytona.snapshot.delete(daytona.snapshot.get("my-awesome-snapshot"))

Snapshot lifecycle

A snapshot can have several different states. Each state reflects the snapshot's current status.

State transitions

A snapshot can transition between states in response to various actions. The following table lists the initial state, target state, and trigger for the transition.

Run Docker in a sandbox

Sandboxes can run Docker containers inside them (Docker-in-Docker), enabling you to build, test, and deploy containerized applications.

Agents can interact with these services since they run within the same sandbox environment, providing better isolation and security compared to external service dependencies.

• Run databases (PostgreSQL, Redis, MySQL) and other services
• Build and test containerized applications
• Deploy microservices and their dependencies
• Create isolated development environments with full container orchestration

Create a Docker-in-Docker snapshot

Daytona provides an option to create a snapshot with Docker support using pre-built Docker-in-Docker images as a base or by manually installing Docker in a custom image.

Using pre-built images

The following base images are widely used for creating Docker-in-Docker snapshots or can be used as a base for a custom Dockerfile:

• docker:28.3.3-dind: official Docker-in-Docker image (Alpine-based, lightweight)
• docker:28.3.3-dind-rootless: rootless Docker-in-Docker for enhanced security
• docker:28.3.2-dind-alpine3.22: Docker-in-Docker image with Alpine 3.22

Manual installation

Alternatively, install Docker manually in a custom Dockerfile:

FROM ubuntu:22.04
# Install Docker using the official install script
RUN curl -fsSL https://get.docker.com | VERSION=28.3.3 sh -

Run Docker Compose in a sandbox

Define and run multi-container applications. With Docker-in-Docker enabled in a Daytona sandbox, you can use Docker Compose to orchestrate services like databases, caches, and application containers.

1. Create a Docker-in-Docker snapshot with one of the pre-built images
2. Run Docker Compose services inside a sandbox

from daytona import Daytona, CreateSandboxFromSnapshotParams

# Initialize the Daytona client
daytona = Daytona()

# Create a sandbox from a Docker-in-Docker snapshot
sandbox = daytona.create(CreateSandboxFromSnapshotParams(snapshot='docker-dind'))

# Create a docker-compose.yml file
compose_content = '''
services:
  web:
    image: nginx:alpine
    ports:
      - "8080:80"
'''
sandbox.fs.upload_file(compose_content.encode(), 'docker-compose.yml')

# Start Docker Compose services
result = sandbox.process.exec('docker compose -p demo up -d')
print(result.result)

# Check running services
result = sandbox.process.exec('docker compose -p demo ps')
print(result.result)

# Clean up
sandbox.process.exec('docker compose -p demo down')

Run Kubernetes in a sandbox

Sandboxes can run a Kubernetes cluster inside the sandbox. Kubernetes runs entirely inside the sandbox and is removed when the sandbox is deleted, keeping environments secure and reproducible.

1. Create a sandbox
2. Install and start a k3s cluster inside the sandbox

from daytona import Daytona, SessionExecuteRequest
import time

# Initialize the Daytona client
daytona = Daytona()

# Create the sandbox instance
sandbox = daytona.create()

# Run the k3s installation script
response = sandbox.process.exec('curl -sfL https://get.k3s.io | sh -')

# Run k3s
session_name = 'k3s-server'
sandbox.process.create_session(session_name)
sandbox.process.execute_session_command(
    session_name,
    SessionExecuteRequest(
        command='sudo /usr/local/bin/k3s server',
        run_async=True,
    ),
)

# Give time to k3s to fully start
time.sleep(30)

# Get all pods
pods = sandbox.process.exec('sudo /usr/local/bin/kubectl get pod -A')
print(pods.result)