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