Go SDK - Daytona

The Daytona Go SDK provides a strongly-typed, performant interface for interacting with Daytona Sandboxes, with native concurrency support and context-based cancellation.

Installation

go get github.com/daytonaio/daytona/libs/sdk-go

Quick Start

package main

import (
    "context"
    "log"
    "time"

    "github.com/daytonaio/daytona/libs/sdk-go/pkg/daytona"
    "github.com/daytonaio/daytona/libs/sdk-go/pkg/options"
    "github.com/daytonaio/daytona/libs/sdk-go/pkg/types"
)

func main() {
    // Create client using environment variables
    client, err := daytona.NewClient()
    if err != nil {
        log.Fatal(err)
    }

    ctx := context.Background()

    // Create a sandbox
    params := types.SnapshotParams{
        SandboxBaseParams: types.SandboxBaseParams{
            Language: types.CodeLanguagePython,
        },
    }

    sandbox, err := client.Create(ctx, params, options.WithTimeout(90*time.Second))
    if err != nil {
        log.Fatal(err)
    }

    log.Printf("Created sandbox: %s (ID: %s)\n", sandbox.Name, sandbox.ID)

    // Execute a command
    result, err := sandbox.Process.ExecuteCommand(ctx, "echo 'Hello, World!'")
    if err != nil {
        log.Fatal(err)
    }

    log.Printf("Output: %s\n", result.Result)

    // Clean up
    if err := sandbox.Delete(ctx); err != nil {
        log.Printf("Failed to delete: %v", err)
    }
}

Configuration

Using Environment Variables

Set the following environment variables:

export DAYTONA_API_KEY="your-api-key"
export DAYTONA_API_URL="https://app.daytona.io/api"  # Optional
export DAYTONA_TARGET="us"  # Optional

Then create the client:

import "github.com/daytonaio/daytona/libs/sdk-go/pkg/daytona"

client, err := daytona.NewClient()
if err != nil {
    log.Fatal(err)
}

Using Configuration Object

import (
    "github.com/daytonaio/daytona/libs/sdk-go/pkg/daytona"
    "github.com/daytonaio/daytona/libs/sdk-go/pkg/types"
)

config := &types.DaytonaConfig{
    APIKey: "your-api-key",
}

client, err := daytona.NewClientWithConfig(config)
if err != nil {
    log.Fatal(err)
}

Sandbox Management

Creating Sandboxes

Basic Sandbox Creation

import (
    "context"
    "time"
    
    "github.com/daytonaio/daytona/libs/sdk-go/pkg/daytona"
    "github.com/daytonaio/daytona/libs/sdk-go/pkg/options"
    "github.com/daytonaio/daytona/libs/sdk-go/pkg/types"
)

ctx := context.Background()

params := types.SnapshotParams{
    SandboxBaseParams: types.SandboxBaseParams{
        Language: types.CodeLanguagePython,
    },
}

sandbox, err := client.Create(ctx, params, options.WithTimeout(90*time.Second))
if err != nil {
    log.Fatal(err)
}

log.Printf("Created sandbox: %s (ID: %s)\n", sandbox.Name, sandbox.ID)
log.Printf("State: %s\n", sandbox.State)

Customized Sandbox Creation

params := types.SnapshotParams{
    SandboxBaseParams: types.SandboxBaseParams{
        Language: types.CodeLanguagePython,
        EnvVars: map[string]string{
            "PYTHON_ENV": "production",
            "DEBUG":      "false",
        },
        Labels: map[string]string{
            "project":     "my-app",
            "environment": "production",
        },
        AutoStopInterval:    60,  // Auto-stop after 1 hour
        AutoArchiveInterval: 60,  // Auto-archive after 1 hour
        AutoDeleteInterval:  120, // Auto-delete after 2 hours
    },
}

sandbox, err := client.Create(ctx, params, options.WithTimeout(90*time.Second))
if err != nil {
    log.Fatal(err)
}

Creating from Custom Image

params := types.ImageParams{
    SandboxBaseParams: types.SandboxBaseParams{
        Language: types.CodeLanguagePython,
    },
    Image: &types.Image{
        Name: "my-custom-image",
        User: "daytona",
    },
}

sandbox, err := client.Create(ctx, params, options.WithTimeout(90*time.Second))
if err != nil {
    log.Fatal(err)
}

Streaming Build Logs

import "fmt"

params := types.SnapshotParams{
    SandboxBaseParams: types.SandboxBaseParams{
        Language: types.CodeLanguagePython,
    },
}

// Create sandbox and get build logs channel
sandbox, buildLogs, err := client.Create(
    ctx,
    params,
    options.WithTimeout(90*time.Second),
)
if err != nil {
    log.Fatal(err)
}

// Read build logs in real-time
go func() {
    for logLine := range buildLogs {
        fmt.Printf("[BUILD] %s\n", logLine)
    }
}()

log.Printf("Sandbox created: %s\n", sandbox.ID)

Listing Sandboxes

// List all sandboxes
page := 1
limit := 10
result, err := client.List(ctx, nil, &page, &limit)
if err != nil {
    log.Fatal(err)
}

log.Printf("Total sandboxes: %d\n", result.Total)
for _, sb := range result.Items {
    log.Printf("ID: %s, State: %s\n", sb.ID, sb.State)
}

// List with label filter
labels := map[string]string{"project": "my-app"}
result, err = client.List(ctx, labels, &page, &limit)
if err != nil {
    log.Fatal(err)
}

Getting a Sandbox

// Get by ID or name
sandbox, err := client.Get(ctx, "sandbox-id-or-name")
if err != nil {
    log.Fatal(err)
}

log.Printf("Sandbox: %s (State: %s)\n", sandbox.Name, sandbox.State)

Sandbox Lifecycle

// Stop a sandbox
if err := sandbox.Stop(ctx); err != nil {
    log.Fatal(err)
}
log.Printf("Sandbox state: %s\n", sandbox.State)

// Stop with custom timeout
if err := sandbox.StopWithTimeout(ctx, 120*time.Second); err != nil {
    log.Fatal(err)
}

// Start a sandbox
if err := sandbox.Start(ctx); err != nil {
    log.Fatal(err)
}
log.Printf("Sandbox state: %s\n", sandbox.State)

// Delete a sandbox
if err := sandbox.Delete(ctx); err != nil {
    log.Fatal(err)
}

Setting Labels

labels := map[string]string{
    "environment": "production",
    "project":     "my-app",
    "team":        "backend",
}

if err := sandbox.SetLabels(ctx, labels); err != nil {
    log.Fatal(err)
}

log.Printf("Labels set: %v\n", sandbox.Labels)

Code Execution

Executing Commands

// Simple command execution
result, err := sandbox.Process.ExecuteCommand(ctx, "echo 'Hello, World!'")
if err != nil {
    log.Fatal(err)
}

if result.ExitCode != 0 {
    log.Printf("Command failed: %s\n", result.Result)
} else {
    log.Printf("Output: %s\n", result.Result)
}

// Execute with working directory
result, err = sandbox.Process.ExecuteCommand(
    ctx,
    "ls -la",
    options.WithCwd("/home/daytona"),
)
if err != nil {
    log.Fatal(err)
}
log.Printf("Files: %s\n", result.Result)

// Execute with environment variables
env := map[string]string{
    "MY_VAR": "hello",
}
result, err = sandbox.Process.ExecuteCommand(
    ctx,
    "echo $MY_VAR",
    options.WithEnv(env),
)
if err != nil {
    log.Fatal(err)
}
log.Printf("Output: %s\n", result.Result)

Code Interpreter

The Code Interpreter provides stateful Python code execution with real-time streaming:

import (
    "github.com/daytonaio/daytona/libs/sdk-go/pkg/options"
)

// Get the code interpreter
interpreter := sandbox.CodeInterpreter

// Execute code with real-time streaming
channels, err := interpreter.RunCode(
    ctx,
    `import time
for i in range(5):
    print(f"Step {i+1}")
    time.sleep(0.5)
print("Done!")`,
)
if err != nil {
    log.Fatal(err)
}

// Read from channels in real-time
go func() {
    for msg := range channels.Stdout {
        log.Printf("[STDOUT] %s", msg.Text)
    }
}()

go func() {
    for msg := range channels.Stderr {
        log.Printf("[STDERR] %s", msg.Text)
    }
}()

go func() {
    for execErr := range channels.Errors {
        log.Printf("[ERROR] %s: %s\n", execErr.Name, execErr.Value)
    }
}()

// Wait for completion
result := <-channels.Done
log.Printf("Execution completed: %s\n", result.Stdout)

Code Execution with Timeout

import "time"

channels, err := interpreter.RunCode(
    ctx,
    `import time
print("Starting...")
time.sleep(10)
print("This won't print")`,
    options.WithInterpreterTimeout(2*time.Second),
)
if err != nil {
    log.Fatal(err)
}

result := <-channels.Done
if result.Error != nil {
    log.Printf("Timeout error: %s\n", result.Error.Name)
}

File Operations

Uploading Files

// Upload a single file from bytes
content := []byte("Hello, World!")
if err := sandbox.FileSystem.UploadFile(ctx, content, "/tmp/hello.txt"); err != nil {
    log.Fatal(err)
}
log.Println("File uploaded")

// Upload from local file
import "os"

data, err := os.ReadFile("local-file.txt")
if err != nil {
    log.Fatal(err)
}

if err := sandbox.FileSystem.UploadFile(ctx, data, "/tmp/remote-file.txt"); err != nil {
    log.Fatal(err)
}

Downloading Files

// Download a file
content, err := sandbox.FileSystem.DownloadFile(ctx, "/tmp/hello.txt", nil)
if err != nil {
    log.Fatal(err)
}
log.Printf("Content: %s\n", string(content))

// Download and save to local file
import "os"

content, err := sandbox.FileSystem.DownloadFile(ctx, "/tmp/data.txt", nil)
if err != nil {
    log.Fatal(err)
}

if err := os.WriteFile("local-data.txt", content, 0644); err != nil {
    log.Fatal(err)
}

File System Operations

// List files in a directory
files, err := sandbox.FileSystem.ListFiles(ctx, "/tmp")
if err != nil {
    log.Fatal(err)
}

for _, file := range files {
    log.Printf("%s: %d bytes\n", file.Name, file.Size)
}

// Create a folder
if err := sandbox.FileSystem.CreateFolder(ctx, "/tmp/new-folder"); err != nil {
    log.Fatal(err)
}
log.Println("Folder created")

// Search for files
import "github.com/daytonaio/daytona/libs/sdk-go/pkg/options"

matches, err := sandbox.FileSystem.FindFiles(
    ctx,
    "/tmp",
    options.WithPattern("*.txt"),
)
if err != nil {
    log.Fatal(err)
}

log.Printf("Found %d files\n", len(matches))
for _, match := range matches {
    log.Printf("File: %s\n", match)
}

Git Operations

Cloning Repositories

import "github.com/daytonaio/daytona/libs/sdk-go/pkg/options"

// Clone a public repository
if err := sandbox.Git.Clone(
    ctx,
    "https://github.com/daytonaio/daytona.git",
    "/tmp/daytona",
); err != nil {
    log.Fatal(err)
}
log.Println("Repository cloned")

// Clone with authentication
if err := sandbox.Git.Clone(
    ctx,
    "https://github.com/private/repo.git",
    "/tmp/repo",
    options.WithUsername("user"),
    options.WithPassword("token"),
); err != nil {
    log.Fatal(err)
}

// Clone a specific branch
if err := sandbox.Git.Clone(
    ctx,
    "https://github.com/example/repo.git",
    "/tmp/repo",
    options.WithBranch("develop"),
); err != nil {
    log.Fatal(err)
}

Git Status and Branches

// Get repository status
status, err := sandbox.Git.Status(ctx, "/tmp/repo")
if err != nil {
    log.Fatal(err)
}

log.Printf("Current branch: %s\n", status.CurrentBranch)
log.Printf("Files changed: %d\n", len(status.FileStatus))

// List branches
branches, err := sandbox.Git.Branches(ctx, "/tmp/repo")
if err != nil {
    log.Fatal(err)
}

for _, branch := range branches {
    log.Printf("Branch: %s\n", branch)
}

Committing Changes

// Add files to staging
if err := sandbox.Git.Add(
    ctx,
    "/tmp/repo",
    []string{"file1.txt", "file2.txt"},
); err != nil {
    log.Fatal(err)
}

// Commit changes
if err := sandbox.Git.Commit(
    ctx,
    "/tmp/repo",
    "Add new features",
    "Your Name",
    "your.email@example.com",
); err != nil {
    log.Fatal(err)
}

// Push changes
if err := sandbox.Git.Push(
    ctx,
    "/tmp/repo",
    options.WithUsername("user"),
    options.WithPassword("token"),
); err != nil {
    log.Fatal(err)
}

Snapshots and Volumes

Managing Snapshots

// Create a snapshot
import (
    "github.com/daytonaio/daytona/libs/sdk-go/pkg/types"
)

params := &types.CreateSnapshotParams{
    Name: "my-snapshot",
    Image: &types.Image{
        Name: "python:3.11",
        User: "root",
    },
}

snapshot, buildLogs, err := client.Snapshot.Create(ctx, params, 180*time.Second)
if err != nil {
    log.Fatal(err)
}

// Stream build logs
go func() {
    for logLine := range buildLogs {
        log.Printf("[BUILD] %s\n", logLine)
    }
}()

log.Printf("Snapshot created: %s\n", snapshot.Name)

// List snapshots
page := 1
limit := 10
snapshots, err := client.Snapshot.List(ctx, &page, &limit)
if err != nil {
    log.Fatal(err)
}

for _, snap := range snapshots.Items {
    log.Printf("Snapshot: %s\n", snap.Name)
}

// Delete a snapshot
if err := client.Snapshot.Delete(ctx, snapshot); err != nil {
    log.Fatal(err)
}

Managing Volumes

// Create a volume
volume, err := client.Volume.Create(ctx, "my-volume")
if err != nil {
    log.Fatal(err)
}
log.Printf("Volume created: %s\n", volume.Name)

// List volumes
volumes, err := client.Volume.List(ctx)
if err != nil {
    log.Fatal(err)
}

for _, vol := range volumes {
    log.Printf("Volume: %s\n", vol.Name)
}

// Delete a volume
if err := client.Volume.Delete(ctx, volume); err != nil {
    log.Fatal(err)
}

Error Handling

import (
    "errors"
    "log"
)

func handleSandbox() error {
    client, err := daytona.NewClient()
    if err != nil {
        return fmt.Errorf("failed to create client: %w", err)
    }

    ctx := context.Background()
    params := types.SnapshotParams{
        SandboxBaseParams: types.SandboxBaseParams{
            Language: types.CodeLanguagePython,
        },
    }

    sandbox, err := client.Create(ctx, params)
    if err != nil {
        return fmt.Errorf("failed to create sandbox: %w", err)
    }

    defer func() {
        if err := sandbox.Delete(ctx); err != nil {
            log.Printf("Failed to delete sandbox: %v", err)
        }
    }()

    result, err := sandbox.Process.ExecuteCommand(ctx, "invalid-command")
    if err != nil {
        return fmt.Errorf("command execution failed: %w", err)
    }

    if result.ExitCode != 0 {
        return fmt.Errorf("command failed with exit code %d: %s", result.ExitCode, result.Result)
    }

    return nil
}

Complete Example

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "github.com/daytonaio/daytona/libs/sdk-go/pkg/daytona"
    "github.com/daytonaio/daytona/libs/sdk-go/pkg/options"
    "github.com/daytonaio/daytona/libs/sdk-go/pkg/types"
)

func main() {
    // Initialize client
    client, err := daytona.NewClient()
    if err != nil {
        log.Fatalf("Failed to create client: %v", err)
    }

    ctx := context.Background()

    // Create sandbox with custom configuration
    params := types.SnapshotParams{
        SandboxBaseParams: types.SandboxBaseParams{
            Language: types.CodeLanguagePython,
            EnvVars: map[string]string{
                "ENV": "production",
            },
            Labels: map[string]string{
                "project": "data-analysis",
            },
        },
    }

    sandbox, err := client.Create(ctx, params, options.WithTimeout(90*time.Second))
    if err != nil {
        log.Fatalf("Failed to create sandbox: %v", err)
    }

    log.Printf("Created sandbox: %s (ID: %s)\n", sandbox.Name, sandbox.ID)

    defer func() {
        log.Println("Cleaning up...")
        if err := sandbox.Delete(ctx); err != nil {
            log.Printf("Failed to delete sandbox: %v", err)
        } else {
            log.Println("Sandbox deleted")
        }
    }()

    // Upload a Python script
    script := []byte(`
import json

data = {'name': 'Alice', 'age': 25}
print(json.dumps(data))
`)

    if err := sandbox.FileSystem.UploadFile(ctx, script, "/tmp/analyze.py"); err != nil {
        log.Fatalf("Failed to upload file: %v", err)
    }

    // Install dependencies
    installResult, err := sandbox.Process.ExecuteCommand(
        ctx,
        "pip install pandas",
    )
    if err != nil {
        log.Fatalf("Failed to install pandas: %v", err)
    }

    if installResult.ExitCode != 0 {
        log.Printf("Install failed: %s\n", installResult.Result)
        return
    }

    // Run the script
    result, err := sandbox.Process.ExecuteCommand(
        ctx,
        "python /tmp/analyze.py",
    )
    if err != nil {
        log.Fatalf("Failed to run script: %v", err)
    }

    if result.ExitCode != 0 {
        log.Printf("Script failed: %s\n", result.Result)
        return
    }

    log.Printf("Analysis result: %s\n", result.Result)
}

Best Practices

Always Use Context

import "context"

ctx := context.Background()

// For operations with timeout
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
defer cancel()

sandbox, err := client.Create(ctx, params)

Always Use Defer for Cleanup

sandbox, err := client.Create(ctx, params)
if err != nil {
    log.Fatal(err)
}

defer func() {
    if err := sandbox.Delete(ctx); err != nil {
        log.Printf("Failed to delete sandbox: %v", err)
    }
}()

// Use the sandbox...

Check Exit Codes

result, err := sandbox.Process.ExecuteCommand(ctx, "some-command")
if err != nil {
    log.Printf("Command failed: %v", err)
    return
}

if result.ExitCode != 0 {
    log.Printf("Command exited with code %d: %s", result.ExitCode, result.Result)
    return
}

log.Printf("Success: %s\n", result.Result)

Use Goroutines for Concurrent Operations

import "sync"

var wg sync.WaitGroup

for i := 0; i < 5; i++ {
    wg.Add(1)
    go func(id int) {
        defer wg.Done()
        
        sandbox, err := client.Create(ctx, params)
        if err != nil {
            log.Printf("Failed to create sandbox %d: %v", id, err)
            return
        }
        defer sandbox.Delete(ctx)
        
        // Use sandbox...
    }(i)
}

wg.Wait()

Next Steps

SDK Overview

Compare all available SDKs

API Reference

Complete API documentation

Examples

Browse Go examples on GitHub

Python SDK

Learn about the Python SDK

Getting Started

Core Concepts

SDK Guides

Features

CLI Reference

Advanced

Documentation Index

​Installation

​Quick Start

​Configuration

​Using Environment Variables

​Using Configuration Object

​Sandbox Management

​Creating Sandboxes

​Basic Sandbox Creation

​Customized Sandbox Creation

​Creating from Custom Image

​Streaming Build Logs

​Listing Sandboxes

​Getting a Sandbox

​Sandbox Lifecycle

​Setting Labels

​Code Execution

​Executing Commands

​Code Interpreter

​Code Execution with Timeout

​File Operations

​Uploading Files

​Downloading Files

​File System Operations

​Git Operations

​Cloning Repositories

​Git Status and Branches

​Committing Changes

​Snapshots and Volumes

​Managing Snapshots

​Managing Volumes

​Error Handling

​Complete Example

​Best Practices

​Always Use Context

​Always Use Defer for Cleanup

​Check Exit Codes

​Use Goroutines for Concurrent Operations

​Next Steps