Execução de código no ambiente CodeSpace - AgentBay: Central de Documentação do Alibaba Cloud

Início rápido

Execute um trecho de código Python em uma sessão do CodeSpace:

import os
from agentbay import AgentBay, CreateSessionParams

agent_bay = AgentBay(api_key=os.environ.get("AGENTBAY_API_KEY"))

session_params = CreateSessionParams(image_id="code_latest")
result = agent_bay.create(session_params)
session = result.session

output = session.code.run_code('print("Hello from CodeSpace!")', "python")
print(output.result)

agent_bay.delete(session)

O código acima cria uma sessão com a imagem code_latest, executa uma linha de Python e exibe a saída. Todos os exemplos subsequentes pressupõem que você já criou uma sessão seguindo esse mesmo padrão.

`run_code()` vs `execute_command()`

O CodeSpace oferece duas formas de executar código:

Método	Finalidade	Entrada	Campo de saída	Mais indicado para
`session.code.run_code(code, lang)`	Interpretar código em um runtime isolado	String de código-fonte Python ou JavaScript	`result.result`	Trechos autônomos, cálculos e processamento de dados
`session.command.execute_command(cmd)`	Executar um comando de shell	String de comando de shell (ex.: `python3 script.py`)	`result.output`	Scripts salvos, instalação de pacotes, operações de shell e argumentos de linha de comando

Use run_code() para executar código inline diretamente. Use execute_command() para rodar comandos de shell e scripts do sistema de arquivos.

Executar código Python

Execução básica

Exiba informações do sistema de dentro do ambiente CodeSpace:

code = """
import os
import sys
print(f"Python version: {sys.version}")
print(f"Current directory: {os.getcwd()}")
print("Hello from AgentBay!")
"""

result = session.code.run_code(code, "python")
if result.success:
    print("Output:", result.result)
    # Output: Python version: 3.11.2 (main, Apr 28 2025, 14:11:48) [GCC 12.2.0]
    #         Current directory: /workspace
    #         Hello from AgentBay!
else:
    print("Execution failed:", result.error_message)

Cálculos

Defina e chame funções, use list comprehensions e trabalhe com a biblioteca padrão:

code = """
import math

# Calculate factorial
def factorial(n):
    return math.factorial(n)

# Fibonacci sequence
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(f"Factorial of 10: {factorial(10)}")
print(f"10th Fibonacci number: {fibonacci(10)}")

# List comprehension
squares = [x**2 for x in range(1, 11)]
print(f"Squares: {squares}")
"""

result = session.code.run_code(code, "python")
if result.success:
    print("Output:", result.result)
    # Output: Factorial of 10: 3628800
    #         10th Fibonacci number: 55
    #         Squares: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Executar código JavaScript

Execução básica de Node.js

Passe "javascript" como parâmetro de linguagem para executar código Node.js:

js_code = """
const fs = require('fs');
const path = require('path');

console.log('Node.js version:', process.version);
console.log('Current directory:', process.cwd());

// Create a simple file
fs.writeFileSync('/tmp/hello.txt', 'Hello from Node.js!');
console.log('File created successfully');
"""

result = session.code.run_code(js_code, "javascript")
if result.success:
    print("Output:", result.result)
    # Output: Node.js version: v18.20.4
    #         Current directory: /workspace
    #         File created successfully
else:
    print("Execution failed:", result.error_message)

Processamento de dados

Trabalhe com arrays e objetos em JavaScript:

js_code = """
// Array operations
const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

const sum = numbers.reduce((a, b) => a + b, 0);
const avg = sum / numbers.length;
const squares = numbers.map(x => x * x);

console.log('Numbers:', numbers);
console.log('Sum:', sum);
console.log('Average:', avg);
console.log('Squares:', squares);

// Object operations
const data = {
    name: 'AgentBay',
    version: '1.0',
    features: ['Python', 'JavaScript', 'File I/O']
};

console.log('\\nData:', JSON.stringify(data, null, 2));
"""

result = session.code.run_code(js_code, "javascript")
if result.success:
    print("Output:", result.result)
    # Output: Numbers: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    #         Sum: 55
    #         Average: 5.5
    #         Squares: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
    #
    #         Data: {
    #           "name": "AgentBay",
    #           "version": "1.0",
    #           "features": [
    #             "Python",
    #             "JavaScript",
    #             "File I/O"
    #           ]
    #         }

Combinar execução de código com E/S de arquivos

Leia e escreva arquivos por meio de session.file_system e combine operações de arquivo com execução de código para criar fluxos de trabalho em várias etapas.

Escrever e executar um script

Escreva um script Python no sistema de arquivos, execute-o com execute_command() e leia o arquivo de saída:

script_content = """
import json
import sys

data = {
    'message': 'Hello from uploaded script',
    'args': sys.argv[1:] if len(sys.argv) > 1 else []
}

with open('/tmp/output.json', 'w') as f:
    json.dump(data, f, indent=2)

print(json.dumps(data, indent=2))
"""

# Write the script
write_result = session.file_system.write_file("/tmp/script.py", script_content)

# Run the script with arguments
exec_result = session.command.execute_command("python3 /tmp/script.py arg1 arg2")
if exec_result.success:
    print("Script output:", exec_result.output)
    # Script output: {
    #   "message": "Hello from uploaded script",
    #   "args": [
    #     "arg1",
    #     "arg2"
    #   ]
    # }

# Read the generated output file
output_result = session.file_system.read_file("/tmp/output.json")
if output_result.success:
    print("Output file content:", output_result.content)

Projetos com múltiplos arquivos

Crie uma estrutura de diretórios, escreva vários arquivos de source e execute o projeto:

# Create the project directory
session.file_system.create_directory("/workspace/myproject")

main_py = """
from utils import greet

if __name__ == "__main__":
    print(greet("AgentBay"))
"""

utils_py = """
def greet(name):
    return f"Hello, {name}!"
"""

# Write source files
session.file_system.write_file("/workspace/myproject/main.py", main_py)
session.file_system.write_file("/workspace/myproject/utils.py", utils_py)

# Run the project
result = session.command.execute_command("cd /workspace/myproject && python3 main.py")
if result.success:
    print("Project output:", result.output)
    # Project output: Hello, AgentBay!

Comportamento de timeout

O método run_code() tem um timeout padrão de 60 segundos.

Importante

Devido a limitações do gateway, cada requisição não pode exceder 60 segundos.

# The default timeout is 60 seconds
result = session.code.run_code(code, "python")

# Specify a custom timeout of up to 60 seconds
result = session.code.run_code(code, "python", timeout_s=60)

O limite de 60 segundos aplica-se por requisição. Divida cargas de trabalho longas em etapas menores que sejam concluídas dentro dessa janela.

Bibliotecas padrão compatíveis

O CodeSpace vem pré-instalado com bibliotecas padrão para Python e Node.js. Para garantir desempenho e confiabilidade ideais, use apenas módulos integrados, como os seguintes:

Linguagem	Módulos padrão disponíveis
Python (3.11.2)	`os`, `sys`, `json`, `math`, `datetime`, `re` e outros módulos integrados
Node.js (v18.20.4)	`fs`, `path`, `os`, `crypto` e outros módulos integrados

Limpar sessões

Exclua a sessão ao terminar para liberar recursos:

agent_bay.delete(session)

Em código de produção, envolva o ciclo de vida da sessão em um bloco try/finally para tratar erros adequadamente:

import os
from agentbay import AgentBay, CreateSessionParams

agent_bay = AgentBay(api_key=os.environ.get("AGENTBAY_API_KEY"))
session_params = CreateSessionParams(image_id="code_latest")
result = agent_bay.create(session_params)
session = result.session

try:
    output = session.code.run_code('print("Hello!")', "python")
    print(output.result)
finally:
    agent_bay.delete(session)