En esto Daytona Tutorial de SDK, proporcionamos un tutorial práctico para aprovechar el entorno Sandbox seguro de Daytona para ejecutar el código Python no confiable o generado por IA de manera segura dentro de Computadora portátil. Comenzando con la creación sencilla de Sandbox y la ejecución del código básico, la guía demuestra cómo aislar procesos, instalar dependencias y ejecutar scripts simples sin poner en peligro el entorno de host. A medida que avanza el tutorial, profundiza en el procesamiento de datos con pandas, operaciones de archivos, incluida la lectura y la escritura de archivos JSON, y la ejecución de fragmentos complejos generados por IA, como funciones recursivas y algoritmos de clasificación. Finalmente, muestra la ejecución de tareas paralelas en múltiples cajas de arena y los procedimientos de limpieza adecuados, asegurando que cada recurso sea administrado y eliminado correctamente.
import os
import time
import json
from typing import List, Dict, Any
try:
import daytona_sdk
except ImportError:
print("Installing Daytona SDK...")
!pip install daytona-sdk
import daytona_sdk
from daytona_sdk import Daytona, DaytonaConfig, CreateSandboxParamsInstalamos e importamos el SDK de Daytona (si aún no está presente), luego inicializamos las clases Core Daytona (Daytona, Daytonaconfig y CreatesandBoxparams) para configurar y crear cajas de arena de Python seguras. También trae utilidades estándar como OS, Time y JSON para su uso dentro de esos Sandboxes.
class DaytonaTutorial:
"""Complete tutorial for Daytona SDK - Secure AI Code Execution Platform"""
def __init__(self, api_key: str):
"""Initialize Daytona client"""
self.config = DaytonaConfig(api_key=api_key)
self.daytona = Daytona(self.config)
self.sandboxes: List[Any] = []
def basic_sandbox_demo(self):
"""Demo 1: Basic sandbox creation and code execution"""
print("🚀 Demo 1: Basic Sandbox Operations")
print("-" * 40)
try:
sandbox = self.daytona.create(CreateSandboxParams(language="python"))
self.sandboxes.append(sandbox)
print(f"✅ Created sandbox: {sandbox.id}")
code="print("Hello from Daytona Sandbox!")\nprint(f"2 + 2 = {2 + 2}")"
response = sandbox.process.code_run(code)
if response.exit_code == 0:
print(f"📝 Output: {response.result}")
else:
print(f"❌ Error: {response.result}")
except Exception as e:
print(f"❌ Error in basic demo: {e}")
def data_processing_demo(self):
"""Demo 2: Data processing in isolated environment"""
print("\n📊 Demo 2: Secure Data Processing")
print("-" * 40)
try:
sandbox = self.daytona.create(CreateSandboxParams(language="python"))
self.sandboxes.append(sandbox)
install_cmd = "import subprocess; subprocess.run(['pip', 'install', 'pandas'])"
response = sandbox.process.code_run(install_cmd)
data_code = """
import pandas as pd
import json
# Create sample dataset
data = {
'name': ['Alice', 'Bob', 'Charlie', 'Diana'],
'age': [25, 30, 35, 28],
'salary': [50000, 60000, 70000, 55000]
}
df = pd.DataFrame(data)
result = {
'total_records': len(df),
'avg_age': df['age'].mean(),
'avg_salary': df['salary'].mean(),
'summary': df.describe().to_dict()
}
print(json.dumps(result, indent=2))
"""
response = sandbox.process.code_run(data_code)
if response.exit_code == 0:
print("✅ Data processing completed:")
print(response.result)
else:
print(f"❌ Error: {response.result}")
except Exception as e:
print(f"❌ Error in data processing demo: {e}")
def file_operations_demo(self):
"""Demo 3: File operations within sandbox"""
print("\n📁 Demo 3: File Operations")
print("-" * 40)
try:
sandbox = self.daytona.create(CreateSandboxParams(language="python"))
self.sandboxes.append(sandbox)
file_code = """
import os
import json
# Create a sample file
data = {'message': 'Hello from Daytona!', 'timestamp': '2025-06-13'}
with open('sample.json', 'w') as f:
json.dump(data, f, indent=2)
# Read and display file contents
with open('sample.json', 'r') as f:
content = f.read()
print("File contents:")
print(content)
# List files in current directory
files = os.listdir('.')
print(f"\\nFiles in directory: {files}")
"""
response = sandbox.process.code_run(file_code)
if response.exit_code == 0:
print("✅ File operations completed:")
print(response.result)
else:
print(f"❌ Error: {response.result}")
except Exception as e:
print(f"❌ Error in file operations demo: {e}")
def ai_code_execution_demo(self):
"""Demo 4: Simulated AI-generated code execution"""
print("\n🤖 Demo 4: AI-Generated Code Execution")
print("-" * 40)
ai_codes = [
"# Calculate fibonacci sequence\ndef fib(n):\n if n <= 1: return n\n return fib(n-1) + fib(n-2)\nprint([fib(i) for i in range(10)])",
"# Sort algorithm\ndef bubble_sort(arr):\n n = len(arr)\n for i in range(n):\n for j in range(0, n-i-1):\n if arr[j] > arr[j+1]:\n arr[j], arr[j+1] = arr[j+1], arr[j]\n return arr\nprint(bubble_sort([64, 34, 25, 12, 22, 11, 90]))",
"# Data analysis\nimport math\ndata = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\nmean = sum(data) / len(data)\nvariance = sum((x - mean) ** 2 for x in data) / len(data)\nstd_dev = math.sqrt(variance)\nprint(f'Mean: {mean}, Std Dev: {std_dev:.2f}')"
]
try:
sandbox = self.daytona.create(CreateSandboxParams(language="python"))
self.sandboxes.append(sandbox)
for i, code in enumerate(ai_codes, 1):
print(f"\n🔄 Executing AI Code Snippet {i}:")
response = sandbox.process.code_run(code)
if response.exit_code == 0:
print(f"✅ Output: {response.result}")
else:
print(f"❌ Error: {response.result}")
time.sleep(1)
except Exception as e:
print(f"❌ Error in AI code execution demo: {e}")
def parallel_execution_demo(self):
"""Demo 5: Multiple sandboxes for parallel processing"""
print("\n⚡ Demo 5: Parallel Execution")
print("-" * 40)
tasks = [
"print('Task 1: Computing prime numbers')\nprimes = [i for i in range(2, 50) if all(i % j != 0 for j in range(2, int(i**0.5) + 1))]\nprint(f'Primes: {primes[:10]}')",
"print('Task 2: String processing')\ntext="Hello Daytona World"\nprint(f'Reversed: {text[::-1]}')\nprint(f'Word count: {len(text.split())}')",
"print('Task 3: Mathematical calculations')\nimport math\nresult = sum(math.sqrt(i) for i in range(1, 101))\nprint(f'Sum of square roots 1-100: {result:.2f}')"
]
try:
parallel_sandboxes = []
for i in range(len(tasks)):
sandbox = self.daytona.create(CreateSandboxParams(language="python"))
parallel_sandboxes.append(sandbox)
self.sandboxes.append(sandbox)
results = []
for i, (sandbox, task) in enumerate(zip(parallel_sandboxes, tasks)):
print(f"\n🏃 Starting parallel task {i+1}")
response = sandbox.process.code_run(task)
results.append((i+1, response))
for task_num, response in results:
if response.exit_code == 0:
print(f"✅ Task {task_num} completed: {response.result}")
else:
print(f"❌ Task {task_num} failed: {response.result}")
except Exception as e:
print(f"❌ Error in parallel execution demo: {e}")
def cleanup_sandboxes(self):
"""Clean up all created sandboxes"""
print("\n🧹 Cleaning up sandboxes...")
print("-" * 40)
for sandbox in self.sandboxes:
try:
self.daytona.remove(sandbox)
print(f"✅ Removed sandbox: {sandbox.id}")
except Exception as e:
print(f"❌ Error removing sandbox {sandbox.id}: {e}")
self.sandboxes.clear()
print("🎉 Cleanup completed!")
def run_full_tutorial(self):
"""Run the complete Daytona tutorial"""
print("🎯 Daytona SDK Complete Tutorial")
print("=" * 50)
print("Secure & Isolated AI Code Execution Platform")
print("=" * 50)
self.basic_sandbox_demo()
self.data_processing_demo()
self.file_operations_demo()
self.ai_code_execution_demo()
self.parallel_execution_demo()
self.cleanup_sandboxes()
print("\n🎊 Tutorial completed successfully!")
print("Key Daytona features demonstrated:")
print("• Secure sandbox creation")
print("• Isolated code execution")
print("• File system operations")
print("• Parallel processing")
print("• Resource cleanup")Esta clase de Daytonatutorial encapsula una guía completa de extremo a extremo para usar el SDK de Daytona: inicializa un cliente de Sandbox seguro con su clave API, demuestra la ejecución de código aislado (desde impresiones simples a través de PANDAS Data Processing y I/O de archivos a los fragmentos generados por IA), ORCHESTRATA TAREAS DE CARLELES A través de múltiples landboxes y finalmente garantiza la eliminación de todos los recursos de todos los recursos de los recursos. Cada método es autónomo, mostrando características clave de Daytona, creación de sandbox, instalación de dependencia, ejecución segura y limpieza de recursos, en un flujo de trabajo claro y paso a paso que es ideal para ejecutarse en Computadora portátil.
def main():
"""Main function to run the tutorial"""
print("🔑 Daytona Setup Instructions:")
print("1. Visit: https://app.daytona.io")
print("2. Create an account")
print("3. Generate API key at: https://app.daytona.io/dashboard/keys")
print("4. Replace 'YOUR_API_KEY' below with your actual key")
print("-" * 50)
API_KEY = "Use Your API Key Here"
if API_KEY == "YOUR_API_KEY":
print("⚠️ Please set your Daytona API key before running the tutorial!")
print(" Update the API_KEY variable with your key from https://app.daytona.io/dashboard/keys")
return
try:
tutorial = DaytonaTutorial(API_KEY)
tutorial.run_full_tutorial()
except Exception as e:
print(f"❌ Tutorial failed: {e}")
print("💡 Make sure your API key is valid and you have network access")La función Main () describe los pasos de configuración iniciales, guiando a los usuarios a crear una cuenta de Daytona y generar su clave API, luego valida que la clave se ha proporcionado antes de instanciar la clase Daytonatutorial y ejecutar el tutorial completo. Si falta la clave API o no es válida, imprime instrucciones y aborta claras, asegurando una experiencia suave por primera vez.
if __name__ == "__main__":
main()
Finalmente, la verificación de punto de entrada estándar de Python anterior asegura que Main () solo se invoque cuando el script se ejecuta directamente, iniciando el flujo de trabajo del tutorial de Daytona de manera clara y controlada.
En conclusión, siguiendo este tutorial, los desarrolladores obtienen una comprensión integral de las capacidades centrales de Daytona: crear cajas de arena de pitón aisladas, realizar manipulaciones seguras de datos, administrar la E/S de archivos, ejecutar el código arbitrario o generado por IA, y orquestando cargas de trabajo paralelas, todo mientras mantiene la separación estricta del sistema anfitrión. Las rutinas de limpieza subrayan la importancia de la higiene de recursos en los flujos de trabajo de larga duración. Armados con estas habilidades fundamentales, los usuarios pueden integrar con confianza Daytona en tuberías de aprendizaje automático más grande, marcos de prueba automatizados o cualquier escenario que requiera la ejecución segura del código dinámico.
Mira el Computadora portátil. Todo el crédito por esta investigación va a los investigadores de este proyecto. Además, siéntete libre de seguirnos Gorjeo Y no olvides unirte a nuestro 99k+ ml de subreddit y suscribirse a Nuestro boletín.
Asif Razzaq es el CEO de MarktechPost Media Inc .. Como empresario e ingeniero visionario, ASIF se compromete a aprovechar el potencial de la inteligencia artificial para el bien social. Su esfuerzo más reciente es el lanzamiento de una plataforma de medios de inteligencia artificial, MarktechPost, que se destaca por su cobertura profunda de noticias de aprendizaje automático y de aprendizaje profundo que es técnicamente sólido y fácilmente comprensible por una audiencia amplia. La plataforma cuenta con más de 2 millones de vistas mensuales, ilustrando su popularidad entre el público.
