Execute code and exchange files (Azure Container Apps)

El AI backend interactúa con las dynamic sessions a través de la session pool management API. El backend autentica con Entra ID y solo manda código y ficheros autorizados al environment aislado

Authenticate the backend

Cada request a management API requiere de un bearer token de Entra ID. La calling identity necesita del rol ContainerApps Session Executor. Puedes asignar este rol con scope de la session pool para que la identidad no pueda ejecutar código en pools no relacionadas.

az role assignment create \
	--role "Azure ContainerApps Session Executor" \
	--assignee <BACKEND_PRINCIPAL_ID> \
	--scope <SESSION_POOL_RESOURCE_ID>

El app code puede usar DefaultAzureCredential en ambos local y azure environments.

from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()
access_token = credential.get_token(
	"https://dynamicsessions.io/.default"
).token

Lo ideal es pedir un token cada vez que la app prepara una llamada, y no cachearlo indefinidamente.

Create secure session identifiers

Un session identifier enruta una request a una session existente o causa a la pool que asigne una nueva. Reutilizar el identifier preserva ficheros y estado temporal entre llamadas.

Hay que generar un ID (UUID) no predecible para cada llamada autenticada del user o el agente. El ID se tiene que mantener en el lado del servidor. No aceptar IDs random del cliente.

from uuid import uuid4

def create_session_identifier() -> str:
	return str(uuid4())

El ID por sí sólo no identifica a un caller. El backend necesita autorizar al usuario con su token propio. Esto evita que un usuario pueda cambiar su token por otro y acceder la session de un tercero.

Submit code for execution

El endpoint executions del code interpreter acepta inline code y devuelve el resultado de la ejecución. El aislamiento reduce el impacto de la ejecución de código no confiable, pero por si solo no determina si la acción que ejecuta el código es apropiada.

crea authenticated headers y common query params

from azure.identity import DefaultAzureCredential

API_VERSION = "2025-10-02-preview"
TOKEN_SCOPE = "https://dynamicsessions.io/.default"

class DynamicSessionClient:
    def __init__(
        self,
        pool_management_endpoint: str,
        session_identifier: str,
    ) -> None:
        self.endpoint = pool_management_endpoint.rstrip("/")
        self.identifier = session_identifier
        self.credential = DefaultAzureCredential()

    def _headers(self) -> dict[str, str]:
        token = self.credential.get_token(TOKEN_SCOPE).token
        return {"Authorization": f"Bearer {token}"}

    def _params(self) -> dict[str, str]:
        return {
            "api-version": API_VERSION,
            "identifier": self.identifier,
        }

envía código síncrono de python

import requests

def execute_python(
    client: DynamicSessionClient,
    code: str,
) -> dict:
    response = requests.post(
        f"{client.endpoint}/executions",
        headers={
            **client._headers(),
            "Content-Type": "application/json",
        },
        params=client._params(),
        json={
            "properties": {
                "codeInputType": "inline",
                "executionType": "synchronous",
                "code": code,
            }
        },
        timeout=30,
    )
    response.raise_for_status()
    return response.json()

raise_for_status() evita que los fallos de auth, validacion, etc se vean como ejecuciones exitosas. El caller debe inspeccionar el resultado y buscar errores de python para gestionarlos.

Exchange files with a session

File operations permiten que el user suba ficheros y produzca artefactos como documentos transformados o charts. El backend sube sólo ficheros autorizados para la current task.

Los ficheros subidos se guardan en /mnt/data

subir un fichero con multipart request

from pathlib import Path

import requests

def upload_file(
    client: DynamicSessionClient,
    file_path: Path,
) -> dict:
    with file_path.open("rb") as source:
        response = requests.post(
            f"{client.endpoint}/files",
            headers=client._headers(),
            params=client._params(),
            files={
                "file": (
                    file_path.name,
                    source,
                    "application/octet-stream",
                )
            },
            timeout=30,
        )

    response.raise_for_status()
    return response.json()

El límite de file upload es de 128 MB

Reuse a session across operations

Calls relacionadas usan el mismo environment cuando incluyen el mismo ID antes de que la session expire. Esto permite que la app suba un documento, ejecute un análisis y cree una visualización sin tener que volver a subir el documento.

from pathlib import Path

session_id = create_session_identifier()
client = DynamicSessionClient(pool_endpoint, session_id)

upload_file(client, Path("operational-data.csv"))
execution = execute_python(client, supplied_python_payload)
available_files = list_files(client)
download_file(client, "trend.png", Path("trend.png"))

La reutilización de sessions es una conveniencia temporal, no una garantía de almacenamiento. Todo lo que sea a largo plazo se debe guardar antes de que el cooldown borre la session.

Integrate a LangChain agent

Ejemplo de integración con LangChain. Crea una tool de una pool management y la hace accesible a un agente.

# Code fragment - focus on creating the LangChain tool
from langchain_azure_dynamic_sessions import SessionsPythonREPLTool

python_repl = SessionsPythonREPLTool(
    pool_management_endpoint=pool_management_endpoint
)
agent_tools = [python_repl]

No registrar una tool como un singleton para todos los usuarios. Hay que crear una tool separada con el contexto del agente para cada usuario autenticado o cada conversación para que llamadas no relacionadas no compartan ficheros temporales o python state

Additional resources

Use dynamic sessions in Azure Container Apps