Remote Development Environments

OpenSandbox enables instant remote development environments with VS Code (code-server), pre-configured toolchains, and isolated workspaces accessible from any browser.

Overview

Remote development environments in OpenSandbox provide:

Browser-based VS Code via code-server
Pre-configured toolchains (Python, Node.js, Go, Java, etc.)
Isolated workspaces for each developer or project
Instant provisioning - seconds to start a new environment
Resource control - CPU, memory, and storage limits per environment
Persistent or ephemeral - choose based on your workflow

Architecture

┌─────────────────────────────────────┐
│   Developer's Browser               │
│   ┌─────────────────────────────┐   │
│   │  VS Code Web Interface      │   │
│   │  (code-server)              │   │
│   └─────────────────────────────┘   │
└──────────────┬──────────────────────┘
               │ HTTPS
               ▼
┌─────────────────────────────────────┐
│   OpenSandbox Server                │
│   ┌─────────────────────────────┐   │
│   │  API Gateway & Auth         │   │
│   └─────────────────────────────┘   │
└──────────────┬──────────────────────┘
               │
               ▼
┌─────────────────────────────────────┐
│   VS Code Sandbox Container         │
│                                     │
│   ┌─────────────────────────────┐   │
│   │  code-server :8443          │   │
│   │  - VS Code extensions       │   │
│   │  - Terminal access          │   │
│   │  - File explorer            │   │
│   └─────────────────────────────┘   │
│                                     │
│   ┌─────────────────────────────┐   │
│   │  Development Tools          │   │
│   │  - Python 3.11              │   │
│   │  - Node.js                  │   │
│   │  - Git                      │   │
│   │  - Package managers         │   │
│   └─────────────────────────────┘   │
│                                     │
│   ┌─────────────────────────────┐   │
│   │  Workspace /workspace       │   │
│   │  - User files               │   │
│   │  - Project code             │   │
│   └─────────────────────────────┘   │
└─────────────────────────────────────┘

Quick Start

1. Build or Pull VS Code Image

# Pull pre-built image
docker pull opensandbox/vscode:latest

# Or build from source
cd examples/vscode
docker build -t opensandbox/vscode:latest .

2. Start OpenSandbox Server

uv pip install opensandbox-server
opensandbox-server init-config ~/.sandbox.toml --example docker
opensandbox-server

3. Create a Development Environment

import asyncio
from datetime import timedelta
from opensandbox import Sandbox
from opensandbox.config import ConnectionConfig
from opensandbox.models.execd import RunCommandOpts

async def create_dev_environment():
    sandbox = await Sandbox.create(
        image="opensandbox/vscode:latest",
        connection_config=ConnectionConfig(domain="localhost:8080"),
        env={"PYTHON_VERSION": "3.11"},
    )
    
    async with sandbox:
        # Start code-server
        await sandbox.commands.run(
            "code-server --bind-addr 0.0.0.0:8443 --auth none /workspace",
            opts=RunCommandOpts(background=True)
        )
        
        # Get access URL
        endpoint = await sandbox.get_endpoint(8443)
        print(f"VS Code available at: http://{endpoint.endpoint}/")
        
        # Keep sandbox alive
        await asyncio.sleep(600)  # 10 minutes
        await sandbox.kill()

asyncio.run(create_dev_environment())

View the complete example: examples/vscode/

Features

VS Code Web (code-server)

Full VS Code experience in the browser:

Extensions marketplace - Install VS Code extensions
Integrated terminal - Full shell access
File explorer - Browse and edit files
Git integration - Commit, push, pull directly from the UI
Debugging - Full debugger support
IntelliSense - Code completion and suggestions

Pre-configured Toolchains

The VS Code image includes:

# Python development
RUN apt-get install -y python3 python3-pip python3-venv

# Node.js development
RUN curl -fsSL https://deb.nodesource.com/setup_lts.x | bash -
RUN apt-get install -y nodejs

# Git and version control
RUN apt-get install -y git git-lfs

# Build tools
RUN apt-get install -y build-essential cmake

Workspace Persistence

Choose between ephemeral and persistent workspaces:

Ephemeral (Default)

# Workspace is lost when sandbox terminates
sandbox = await Sandbox.create("opensandbox/vscode:latest")

Persistent with Volume Mounts

from opensandbox.models import VolumeMount

sandbox = await Sandbox.create(
    "opensandbox/vscode:latest",
    volume_mounts=[
        VolumeMount(
            name="workspace",
            mount_path="/workspace",
            pvc_name="user-workspace-pvc"
        )
    ]
)

See: examples/docker-pvc-volume-mount/

Multi-Language Support

Configure Python version at runtime:

sandbox = await Sandbox.create(
    "opensandbox/vscode:latest",
    env={"PYTHON_VERSION": "3.11"}  # or "3.12", "3.10", etc.
)

Install additional languages on-demand:

# Install Go
await sandbox.commands.run(
    "apt-get update && apt-get install -y golang-go"
)

# Install Rust
await sandbox.commands.run(
    "curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y"
)

# Install Java
await sandbox.commands.run(
    "apt-get install -y openjdk-17-jdk maven"
)

Use Cases

Onboarding New Developers

Provide instant, pre-configured development environments:

async def onboard_developer(user: str, repo_url: str):
    sandbox = await Sandbox.create(
        "opensandbox/vscode:latest",
        metadata={"user": user}
    )
    
    # Clone repository
    await sandbox.commands.run(f"git clone {repo_url} /workspace/project")
    
    # Install dependencies
    await sandbox.commands.run(
        "cd /workspace/project && pip install -r requirements.txt",
    )
    
    # Start code-server
    await sandbox.commands.run(
        "code-server --bind-addr 0.0.0.0:8443 --auth none /workspace/project",
        opts=RunCommandOpts(background=True)
    )
    
    endpoint = await sandbox.get_endpoint(8443)
    return f"http://{endpoint.endpoint}/"

Coding Interviews

Create isolated environments for technical assessments:

async def create_interview_environment(candidate: str, problem: str):
    sandbox = await Sandbox.create(
        "opensandbox/vscode:latest",
        timeout=timedelta(hours=2),  # Interview duration
        metadata={"candidate": candidate, "type": "interview"}
    )
    
    # Prepare problem files
    await sandbox.files.write_file("/workspace/README.md", problem)
    await sandbox.files.write_file("/workspace/solution.py", "# Your solution here")
    await sandbox.files.write_file("/workspace/test_solution.py", test_code)
    
    # Start code-server
    await sandbox.commands.run(
        "code-server --bind-addr 0.0.0.0:8443 --auth none /workspace",
        opts=RunCommandOpts(background=True)
    )
    
    endpoint = await sandbox.get_endpoint(8443)
    return endpoint.endpoint

Educational Platforms

Provide students with hands-on coding environments:

async def create_classroom_environment(student_id: str, lesson: str):
    sandbox = await Sandbox.create(
        "opensandbox/vscode:latest",
        memory_limit="512Mi",  # Limit resources per student
        cpu_limit="0.5"
    )
    
    # Load lesson materials
    lesson_files = load_lesson(lesson)
    for filename, content in lesson_files.items():
        await sandbox.files.write_file(f"/workspace/{filename}", content)
    
    # Start code-server
    await sandbox.commands.run(
        "code-server --bind-addr 0.0.0.0:8443 --auth none /workspace",
        opts=RunCommandOpts(background=True)
    )
    
    endpoint = await sandbox.get_endpoint(8443)
    return endpoint.endpoint

CI/CD Pipeline Testing

Test build scripts and deployment configurations:

async def test_ci_pipeline(repo_url: str, branch: str):
    sandbox = await Sandbox.create("opensandbox/vscode:latest")
    
    # Clone and checkout branch
    await sandbox.commands.run(f"git clone {repo_url} /workspace/repo")
    await sandbox.commands.run(f"cd /workspace/repo && git checkout {branch}")
    
    # Run CI script
    result = await sandbox.commands.run(
        "cd /workspace/repo && ./ci/build.sh"
    )
    
    if result.error:
        print(f"CI failed: {result.error.value}")
    else:
        print("CI passed!")
    
    await sandbox.kill()

Development Sandboxes for AI Agents

Provide AI coding agents with full IDE access:

async def agent_coding_environment(task: str):
    sandbox = await Sandbox.create("opensandbox/vscode:latest")
    
    # Agent can use code-server UI or SDK for file operations
    await sandbox.files.write_file("/workspace/task.md", task)
    
    # Start code-server for monitoring
    await sandbox.commands.run(
        "code-server --bind-addr 0.0.0.0:8443 --auth none /workspace",
        opts=RunCommandOpts(background=True)
    )
    
    # Agent performs coding task via SDK
    await sandbox.files.write_file("/workspace/solution.py", generated_code)
    
    # Run tests
    result = await sandbox.commands.run("python -m pytest /workspace/tests/")
    
    return result

Configuration

Environment Variables

sandbox = await Sandbox.create(
    "opensandbox/vscode:latest",
    env={
        "PYTHON_VERSION": "3.11",
        "CODE_PORT": "8443",
        "GIT_USER_NAME": "John Doe",
        "GIT_USER_EMAIL": "john@example.com"
    }
)

Authentication

Enable code-server authentication:

# Generate password
import secrets
password = secrets.token_urlsafe(16)

# Start with auth
await sandbox.commands.run(
    f"code-server --bind-addr 0.0.0.0:8443 --auth password /workspace",
    opts=RunCommandOpts(background=True),
    env={"PASSWORD": password}
)

print(f"Login with password: {password}")

VS Code Extensions

Install extensions programmatically:

# Install Python extension
await sandbox.commands.run(
    "code-server --install-extension ms-python.python"
)

# Install multiple extensions
extensions = [
    "ms-python.python",
    "ms-python.vscode-pylance",
    "esbenp.prettier-vscode",
    "dbaeumer.vscode-eslint"
]

for ext in extensions:
    await sandbox.commands.run(f"code-server --install-extension {ext}")

Custom Dockerfile

Extend the base image with your tools:

FROM opensandbox/vscode:latest

# Install additional tools
RUN apt-get update && apt-get install -y \
    postgresql-client \
    redis-tools \
    docker.io \
    kubectl

# Pre-install VS Code extensions
RUN code-server --install-extension ms-python.python && \
    code-server --install-extension golang.go && \
    code-server --install-extension rust-lang.rust-analyzer

# Add custom scripts
COPY scripts/ /opt/scripts/
RUN chmod +x /opt/scripts/*

# Set custom workspace template
COPY workspace-template/ /workspace/

Security Best Practices

Network Isolation

Restrict network access:

sandbox = await Sandbox.create(
    "opensandbox/vscode:latest",
    network_mode="none"  # No external network
)

Resource Quotas

Prevent resource abuse:

sandbox = await Sandbox.create(
    "opensandbox/vscode:latest",
    memory_limit="2Gi",
    cpu_limit="2",
    timeout=timedelta(hours=8),
    storage_limit="10Gi"
)

User Isolation

Run as non-root user (default in opensandbox/vscode):

# In Dockerfile
RUN useradd -m -s /bin/bash vscode
USER vscode
WORKDIR /workspace

Audit Logging

Track sandbox usage:

sandbox = await Sandbox.create(
    "opensandbox/vscode:latest",
    metadata={
        "user": "john@example.com",
        "project": "web-app",
        "created_at": datetime.now().isoformat()
    }
)

Performance Optimization

Image Caching

Pre-pull images on nodes:

docker pull opensandbox/vscode:latest

Persistent Volumes

Reuse workspaces to avoid re-cloning:

# First session
sandbox1 = await Sandbox.create(
    "opensandbox/vscode:latest",
    volume_mounts=[VolumeMount(name="workspace", mount_path="/workspace")]
)
await sandbox1.commands.run("git clone https://github.com/user/repo /workspace/repo")
await sandbox1.kill()

# Later session - repo already cloned
sandbox2 = await Sandbox.create(
    "opensandbox/vscode:latest",
    volume_mounts=[VolumeMount(name="workspace", mount_path="/workspace")]
)
# /workspace/repo still exists

Background Services

Use background processes for long-running services:

# Start code-server in background
await sandbox.commands.run(
    "code-server --bind-addr 0.0.0.0:8443 --auth none /workspace",
    opts=RunCommandOpts(background=True)
)

# Start language servers, file watchers, etc.
await sandbox.commands.run(
    "npm run watch",
    opts=RunCommandOpts(background=True)
)

Troubleshooting

code-server Won’t Start

Check logs:

result = await sandbox.commands.run("ps aux | grep code-server")
for line in result.logs.stdout:
    print(line.text)

Port Already in Use

Use dynamic ports:

import random
port = random.randint(8000, 9000)

await sandbox.commands.run(
    f"code-server --bind-addr 0.0.0.0:{port} --auth none /workspace",
    opts=RunCommandOpts(background=True)
)

endpoint = await sandbox.get_endpoint(port)

Extension Installation Failed

Check network connectivity and try manual installation:

# Download extension manually
await sandbox.commands.run(
    "wget https://example.com/extension.vsix -O /tmp/extension.vsix"
)
await sandbox.commands.run(
    "code-server --install-extension /tmp/extension.vsix"
)

VS Code Example

Complete VS Code sandbox example

Volume Mounts

Persistent workspace example

AI Coding Agents

AI agents with development environments

Python SDK

SDK reference documentation

Get Started

Core Concepts

Deployment

SDKs

Components

Use Cases

Operations

Documentation Index

​Overview

​Architecture

​Quick Start

​1. Build or Pull VS Code Image

​2. Start OpenSandbox Server

​3. Create a Development Environment

​Features

​VS Code Web (code-server)

​Pre-configured Toolchains

​Workspace Persistence

​Ephemeral (Default)

​Persistent with Volume Mounts

​Multi-Language Support

​Use Cases

​Onboarding New Developers

​Coding Interviews

​Educational Platforms

​CI/CD Pipeline Testing

​Development Sandboxes for AI Agents

​Configuration

​Environment Variables

​Authentication

​VS Code Extensions

​Custom Dockerfile

​Security Best Practices

​Network Isolation

​Resource Quotas

​User Isolation

​Audit Logging

​Performance Optimization

​Image Caching

​Persistent Volumes

​Background Services

​Troubleshooting

​code-server Won’t Start

​Port Already in Use

​Extension Installation Failed

​Related Resources

VS Code Example

Volume Mounts

AI Coding Agents

Python SDK

Build docs developers (and LLMs) love

Overview

Architecture

Quick Start

1. Build or Pull VS Code Image

2. Start OpenSandbox Server

3. Create a Development Environment

Features

VS Code Web (code-server)

Pre-configured Toolchains

Workspace Persistence

Ephemeral (Default)

Persistent with Volume Mounts

Multi-Language Support

Use Cases

Onboarding New Developers

Coding Interviews

Educational Platforms

CI/CD Pipeline Testing

Development Sandboxes for AI Agents

Configuration

Environment Variables

Authentication

VS Code Extensions

Custom Dockerfile

Security Best Practices

Network Isolation

Resource Quotas

User Isolation

Audit Logging

Performance Optimization

Image Caching

Persistent Volumes

Background Services

Troubleshooting

code-server Won’t Start

Port Already in Use

Extension Installation Failed

Related Resources