En esto Daytona Tutorial de SDK, proporcionamos un tutorial práctico para servirse el entorno Sandbox seguro de Daytona para ejecutar el código Python no confiable o generado por IA de forma segura en el interior de Computadora portátil. Comenzando con la creación sencilla de Sandbox y la ejecución del código cardinal, la derrotero 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 leída 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 desinfección adecuados, asegurando que cada apelación 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. Igualmente trae utilidades habitual como OS, Time y JSON para su uso en el interior 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 sequencendef fib(n):n if n <= 1: return nn return fib(n-1) + fib(n-2)nprint((fib(i) for i in range(10)))",
"# Sort algorithmndef 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 arrnprint(bubble_sort((64, 34, 25, 12, 22, 11, 90)))",
"# Data analysisnimport mathndata = (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 mathnresult = 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 derrotero completa de extremo a extremo para usar el SDK de Daytona: inicializa un cliente de Sandbox seguro con su secreto API, demuestra la ejecución de código incomunicación (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 exterminio de todos los bienes de todos los bienes de los bienes. Cada método es autónomo, mostrando características secreto de Daytona, creación de sandbox, instalación de dependencia, ejecución segura y desinfección de bienes, 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 presente 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 crear su secreto API, luego valida que la secreto se ha proporcionado ayer de instanciar la clase Daytonatutorial y ejecutar el tutorial completo. Si descuido la secreto API o no es válida, imprime instrucciones y aborta claras, asegurando una experiencia suave por primera vez.
if __name__ == "__main__":
main()
Finalmente, la comprobación de punto de entrada habitual de Python antecedente asegura que Main () solo se invoque cuando el script se ejecuta directamente, iniciando el flujo de trabajo del tutorial de Daytona de forma 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, tener la llave de la despensa la E/S de archivos, ejecutar el código improcedente o generado por IA, y orquestando cargas de trabajo paralelas, todo mientras mantiene la separación estricta del sistema huésped. Las rutinas de desinfección subrayan la importancia de la higiene de bienes 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 formación mecánico más holgado, marcos de prueba automatizados o cualquier marco 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 tesina. Por otra parte, siéntete libertado 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 patrón e ingeniero iluminado, ASIF se compromete a servirse el potencial de la inteligencia fabricado para el proporcionadamente social. Su esfuerzo más flamante es el dispersión de una plataforma de medios de inteligencia fabricado, MarktechPost, que se destaca por su cobertura profunda de noticiero de formación mecánico y de formación 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 sabido.
