remove default worker profile

YunchuWang · YunchuWang · commit fdf908a2327e · 2026-06-12T13:22:56.000-07:00
diff --git a/durabletask-azuremanaged/durabletask/azuremanaged/preview/sandboxes/declarations.py b/durabletask-azuremanaged/durabletask/azuremanaged/preview/sandboxes/declarations.py
@@ -13,7 +13,6 @@
 )
 
 
-DEFAULT_WORKER_PROFILE_ID = "default"
 DEFAULT_CPU = "1000m"
 DEFAULT_MEMORY = "2048Mi"
 DEFAULT_MAX_CONCURRENT_ACTIVITIES = 100
@@ -87,7 +86,7 @@ def _build_sandbox_activity_declaration(
         *,
         activity_names: str | Iterable[str],
         scheduler_managed_identity_client_id: Optional[str],
-        worker_profile_id: str = DEFAULT_WORKER_PROFILE_ID,
+        worker_profile_id: str,
         container_image: Optional[str] = None,
         image_pull_managed_identity_client_id: Optional[str] = None,
         cpu: str = DEFAULT_CPU,
diff --git a/durabletask-azuremanaged/durabletask/azuremanaged/preview/sandboxes/worker.py b/durabletask-azuremanaged/durabletask/azuremanaged/preview/sandboxes/worker.py
@@ -15,7 +15,6 @@
 from durabletask.azuremanaged.preview.sandboxes.helpers import resolve_activity_names
 from durabletask.azuremanaged.preview.sandboxes.declarations import (
     DEFAULT_MAX_CONCURRENT_ACTIVITIES,
-    DEFAULT_WORKER_PROFILE_ID,
     build_sandbox_worker_heartbeat,
     build_sandbox_worker_start,
 )
@@ -192,9 +191,12 @@ def _resolve_secure_channel(host_address: str) -> bool:
 
 
 def _resolve_worker_profile_id() -> str:
-    resolved_worker_profile_id = (
-        os.getenv("DTS_WORKER_PROFILE_ID")
-        or DEFAULT_WORKER_PROFILE_ID)
+    resolved_worker_profile_id = os.getenv("DTS_WORKER_PROFILE_ID")
+    if not resolved_worker_profile_id or not resolved_worker_profile_id.strip():
+        raise ValueError(
+            "Sandbox worker requires DTS_WORKER_PROFILE_ID to be injected in the "
+            "sandbox environment.")
+
     return resolved_worker_profile_id.strip()
 
 
diff --git a/examples/sandboxes/README.md b/examples/sandboxes/README.md
@@ -23,7 +23,7 @@ Bash:
 ~~~bash
 export DTS_ENDPOINT="<scheduler endpoint>"
 export DTS_TASK_HUB="<task hub name>"
-export DTS_WORKER_PROFILE_ID="default"
+export DTS_WORKER_PROFILE_ID="python-sandbox-worker"
 export DTS_SANDBOX_CONTAINER_IMAGE="<container image reference>"
 export DTS_SANDBOX_IMAGE_PULL_UMI_CLIENT_ID="<image-pull UMI client ID>"
 export DTS_SANDBOX_SCHEDULER_UMI_CLIENT_ID="<scheduler UMI client ID>"
@@ -34,7 +34,7 @@ PowerShell:
 ~~~powershell
 $env:DTS_ENDPOINT = "<scheduler endpoint>"
 $env:DTS_TASK_HUB = "<task hub name>"
-$env:DTS_WORKER_PROFILE_ID = "default"
+$env:DTS_WORKER_PROFILE_ID = "python-sandbox-worker"
 $env:DTS_SANDBOX_CONTAINER_IMAGE = "<container image reference>"
 $env:DTS_SANDBOX_IMAGE_PULL_UMI_CLIENT_ID = "<image-pull UMI client ID>"
 $env:DTS_SANDBOX_SCHEDULER_UMI_CLIENT_ID = "<scheduler UMI client ID>"
diff --git a/examples/sandboxes/main_app.py b/examples/sandboxes/main_app.py
@@ -28,7 +28,7 @@ def _get_required_env(name: str) -> str:
 
 taskhub_name = os.getenv("DTS_TASK_HUB") or "SandboxPocHub"
 endpoint = os.getenv("DTS_ENDPOINT", "http://localhost:8080")
-worker_profile_id = os.getenv("DTS_WORKER_PROFILE_ID", "default")
+worker_profile_id = _get_required_env("DTS_WORKER_PROFILE_ID")
 container_image = (
     os.getenv("DTS_SANDBOX_CONTAINER_IMAGE")
     or "sandboxes-remote-worker:local")
diff --git a/examples/serverless/Containerfile b/examples/serverless/Containerfile
@@ -0,0 +1,12 @@
+FROM python:3.12-slim AS runtime
+
+WORKDIR /app
+
+COPY . /src
+RUN pip install --no-cache-dir /src /src/durabletask-azuremanaged azure-identity
+
+COPY examples/serverless/remote_worker.py /app/remote_worker.py
+COPY examples/serverless/activity_names.py /app/activity_names.py
+
+EXPOSE 8080
+ENTRYPOINT ["python", "/app/remote_worker.py"]
diff --git a/examples/serverless/README.md b/examples/serverless/README.md
@@ -0,0 +1,77 @@
+# DTS serverless activities sample
+
+This sample mirrors the .NET serverless sample with two customer-owned pieces:
+
+1. A **declarer app** (`main_app.py`) that declares which activity should run
+   serverlessly, starts the orchestration, and waits for the result.
+2. A **remote worker image** (`remote_worker.py` plus `Containerfile`) that
+   DTS starts in a sandbox to execute the declared activity.
+3. A tiny shared module (`activity_names.py`) that keeps the declarer and remote
+   worker on the same activity name constants.
+
+Reference .NET template:
+<https://github.com/microsoft/durabletask-dotnet/compare/wangbill/serverless-private-preview>
+under `samples/serverless`.
+
+> [!NOTE]
+> Until the serverless extension is published in a preview package, the worker
+> image installs the SDK from this source tree. After publication, replace that
+> Containerfile step with `pip install durabletask.azuremanaged==<preview-version>`.
+
+## Environment variables
+
+Set these before running the declarer app:
+
+```powershell
+$env:DTS_ENDPOINT = "<scheduler endpoint>"
+$env:DTS_TASK_HUB = "<task hub name>"
+$env:DTS_WORKER_PROFILE_ID = "python-serverless-worker"
+$env:DTS_SERVERLESS_CONTAINER_IMAGE = "<public container image reference>"
+```
+
+After pushing the remote worker image, set `DTS_SERVERLESS_CONTAINER_IMAGE` to
+the pushed image reference. `RemoteWorkerProfile.configure()` declares CPU,
+memory, max concurrency, customer environment variables, and serverless activity
+names with `options.add_activity(...)`. The declarer and remote worker both use
+`activity_names.py` so they stay in sync.
+
+The remote worker code cannot pass DTS runtime settings to the SDK. In a
+sandbox, `ServerlessWorker()` reads `DTS_ENDPOINT`,
+`DTS_TASK_HUB`, `DTS_WORKER_PROFILE_ID`, `DTS_SERVERLESS_MAX_ACTIVITIES`,
+`DTS_SUBSTRATE`, and `DTS_SANDBOX_ID` from environment variables injected by
+DTS. The worker reports its registered activity names when it connects, and
+DTS validates they match the declaration before advertising worker capacity.
+
+## Build the remote worker image
+
+From the repository root:
+
+```powershell
+docker build `
+  -f examples\serverless\Containerfile `
+  -t <public container image reference> `
+  .
+docker push <public container image reference>
+```
+
+Private preview requires the image to be publicly pullable by ADC/DTS.
+
+## Run the declarer app
+
+Install local packages from the repository root:
+
+```powershell
+pip install -e . -e .\durabletask-azuremanaged
+```
+
+Then run:
+
+```powershell
+python examples\serverless\main_app.py
+```
+
+The declarer app registers the serverless activity metadata, starts
+`hello_orchestrator`, and the remote worker sandbox executes `remote_hello`.
+The result includes `SERVERLESS_SAMPLE_MARKER=serverless-python-sample-marker`,
+proving the customer environment variable declared on the worker profile reached
+the sandbox.
diff --git a/examples/serverless/main_app.py b/examples/serverless/main_app.py
@@ -0,0 +1,84 @@
+"""Declarer app for the DTS serverless activities sample."""
+
+import os
+
+from azure.identity import DefaultAzureCredential
+
+from durabletask import client, task
+from durabletask.azuremanaged.client import DurableTaskSchedulerClient
+from durabletask.azuremanaged.extensions.serverless import ServerlessActivitiesClient
+from durabletask.azuremanaged.extensions.serverless import ServerlessWorkerProfile
+from durabletask.azuremanaged.extensions.serverless import serverless_worker_profile
+from durabletask.azuremanaged.worker import DurableTaskSchedulerWorker
+
+from activity_names import REMOTE_HELLO
+
+
+def hello_orchestrator(ctx: task.OrchestrationContext, name: str):
+    """Orchestrator that calls an activity executed by the remote worker image."""
+    return (yield ctx.call_activity(REMOTE_HELLO, input=name))
+
+
+def _get_required_env(name: str) -> str:
+    value = os.getenv(name)
+    if value:
+        return value
+    raise RuntimeError(f"Set {name} before running the serverless sample.")
+
+
+taskhub_name = os.getenv("DTS_TASK_HUB") or "ServerlessPocHub"
+endpoint = os.getenv("DTS_ENDPOINT", "http://localhost:8080")
+worker_profile_id = _get_required_env("DTS_WORKER_PROFILE_ID")
+container_image = os.getenv("DTS_SERVERLESS_CONTAINER_IMAGE", "serverless-remote-worker:local")
+sample_input = os.getenv("DTS_SAMPLE_HELLO_INPUT", "serverless Python")
+
+
+@serverless_worker_profile(worker_profile_id)
+class RemoteWorkerProfile(ServerlessWorkerProfile):
+    """Serverless worker profile used by the sample remote activity."""
+
+    def configure(self, options) -> None:
+        options.container_image = container_image
+        options.cpu = "1000m"
+        options.memory = "2048Mi"
+        options.max_concurrent_activities = 1
+        options.environment_variables["SERVERLESS_SAMPLE_MARKER"] = "serverless-python-sample-marker"
+        options.add_activity(REMOTE_HELLO)
+
+
+print(f"Using taskhub: {taskhub_name}")
+print(f"Using endpoint: {endpoint}")
+print(f"Declaring serverless activity image: {container_image}")
+
+secure_channel = endpoint.startswith("https://") or endpoint.startswith("grpcs://")
+credential = DefaultAzureCredential() if secure_channel else None
+
+serverless_client = ServerlessActivitiesClient(
+    host_address=endpoint,
+    secure_channel=secure_channel,
+    taskhub=taskhub_name,
+    token_credential=credential)
+serverless_client.enable_serverless_activities()
+
+with DurableTaskSchedulerWorker(
+        host_address=endpoint,
+        secure_channel=secure_channel,
+        taskhub=taskhub_name,
+        token_credential=credential) as worker:
+    worker.add_orchestrator(hello_orchestrator)
+    worker.use_work_item_filters()
+    worker.start()
+
+    durable_client = DurableTaskSchedulerClient(
+        host_address=endpoint,
+        secure_channel=secure_channel,
+        taskhub=taskhub_name,
+        token_credential=credential)
+    instance_id = durable_client.schedule_new_orchestration(
+        hello_orchestrator,
+        input=sample_input)
+    state = durable_client.wait_for_orchestration_completion(instance_id, timeout=120)
+    if state and state.runtime_status == client.OrchestrationStatus.COMPLETED:
+        print(f"Orchestration completed! Result: {state.serialized_output}")
+    elif state:
+        print(f"Orchestration failed: {state.failure_details}")
diff --git a/examples/serverless/remote_worker.py b/examples/serverless/remote_worker.py
@@ -0,0 +1,30 @@
+"""Remote worker image entrypoint for the DTS serverless activities sample."""
+
+import os
+import time
+
+from durabletask import task
+from durabletask.azuremanaged.extensions.serverless import ServerlessWorker
+
+from activity_names import REMOTE_HELLO
+
+
+def _remote_hello(ctx: task.ActivityContext, name: str) -> str:
+    """Activity function that runs inside the serverless worker container."""
+    sandbox_id = os.getenv("DTS_SANDBOX_ID", "unknown-sandbox")
+    marker = os.getenv("SERVERLESS_SAMPLE_MARKER", "<missing>")
+    return f"Hello {name} from Python serverless worker {sandbox_id}! SERVERLESS_SAMPLE_MARKER={marker}"
+
+
+_remote_hello.__name__ = REMOTE_HELLO
+
+
+with ServerlessWorker() as worker:
+    worker.add_activity(_remote_hello)
+    worker.start()
+    print("Python serverless remote worker is running. Press Ctrl+C to stop.")
+    try:
+        while True:
+            time.sleep(3600)
+    except KeyboardInterrupt:
+        pass
diff --git a/tests/durabletask-azuremanaged/test_sandboxes_extension.py b/tests/durabletask-azuremanaged/test_sandboxes_extension.py
@@ -309,6 +309,7 @@ def test_sandbox_activities_client_does_not_expose_worker_registration_rpc() ->
 def test_sandbox_worker_does_not_own_legacy_wakeup_server(monkeypatch) -> None:
     monkeypatch.setenv("DTS_ENDPOINT", "http://localhost:8080")
     monkeypatch.setenv("DTS_TASK_HUB", "env-hub")
+    monkeypatch.setenv("DTS_WORKER_PROFILE_ID", "env-profile")
     monkeypatch.setenv("DTS_SANDBOX_PROVIDER", "Sandbox")
 
     worker = SandboxWorker()
@@ -359,6 +360,7 @@ def OtherActivity(_ctx, value):
 def test_sandbox_worker_stop_keeps_handle_for_still_running_registration_thread(monkeypatch) -> None:
     monkeypatch.setenv("DTS_ENDPOINT", "http://localhost:8080")
     monkeypatch.setenv("DTS_TASK_HUB", "env-hub")
+    monkeypatch.setenv("DTS_WORKER_PROFILE_ID", "env-profile")
     monkeypatch.setenv("DTS_SANDBOX_PROVIDER", "Sandbox")
 
     class StillRunningThread:
@@ -385,6 +387,7 @@ def is_alive(self):
 def test_sandbox_worker_uses_scheduler_channel_without_credential(monkeypatch) -> None:
     monkeypatch.setenv("DTS_ENDPOINT", "https://example.scheduler")
     monkeypatch.setenv("DTS_TASK_HUB", "env-hub")
+    monkeypatch.setenv("DTS_WORKER_PROFILE_ID", "env-profile")
     monkeypatch.setenv("DTS_SANDBOX_PROVIDER", "Sandbox")
 
     worker = SandboxWorker()
@@ -396,6 +399,7 @@ def test_sandbox_worker_uses_scheduler_channel_without_credential(monkeypatch) -
 def test_sandbox_worker_ignores_legacy_max_activities(monkeypatch) -> None:
     monkeypatch.setenv("DTS_ENDPOINT", "https://example.scheduler")
     monkeypatch.setenv("DTS_TASK_HUB", "env-hub")
+    monkeypatch.setenv("DTS_WORKER_PROFILE_ID", "env-profile")
     monkeypatch.setenv("DTS_SANDBOX_PROVIDER", "Sandbox")
     monkeypatch.delenv("DTS_SANDBOX_MAX_ACTIVITIES", raising=False)
     monkeypatch.setenv("DTS_" + "SERVER" + "LESS_MAX_ACTIVITIES", "7")
@@ -408,6 +412,7 @@ def test_sandbox_worker_ignores_legacy_max_activities(monkeypatch) -> None:
 def test_sandbox_worker_tracks_active_activity_count_with_hooks(monkeypatch) -> None:
     monkeypatch.setenv("DTS_ENDPOINT", "https://example.scheduler")
     monkeypatch.setenv("DTS_TASK_HUB", "env-hub")
+    monkeypatch.setenv("DTS_WORKER_PROFILE_ID", "env-profile")
     monkeypatch.setenv("DTS_SANDBOX_PROVIDER", "Sandbox")
 
     worker = SandboxWorker()
@@ -425,6 +430,7 @@ def test_sandbox_worker_tracks_active_activity_count_with_hooks(monkeypatch) ->
 def test_sandbox_worker_uses_managed_identity_credential_when_injected(monkeypatch) -> None:
     monkeypatch.setenv("DTS_ENDPOINT", "https://example.scheduler")
     monkeypatch.setenv("DTS_TASK_HUB", "env-hub")
+    monkeypatch.setenv("DTS_WORKER_PROFILE_ID", "env-profile")
     monkeypatch.setenv("DTS_SANDBOX_PROVIDER", "Sandbox")
     monkeypatch.setenv("DTS_AUTHENTICATION", "ManagedIdentity")
     monkeypatch.setenv("DTS_UMI_CLIENT_ID", "worker-client-id")
@@ -440,6 +446,7 @@ def test_sandbox_worker_uses_managed_identity_credential_when_injected(monkeypat
 def test_sandbox_worker_requires_managed_identity_client_id_when_auth_enabled(monkeypatch) -> None:
     monkeypatch.setenv("DTS_ENDPOINT", "https://example.scheduler")
     monkeypatch.setenv("DTS_TASK_HUB", "env-hub")
+    monkeypatch.setenv("DTS_WORKER_PROFILE_ID", "env-profile")
     monkeypatch.setenv("DTS_SANDBOX_PROVIDER", "Sandbox")
     monkeypatch.setenv("DTS_AUTHENTICATION", "ManagedIdentity")
     monkeypatch.delenv("DTS_UMI_CLIENT_ID", raising=False)
@@ -455,6 +462,7 @@ def test_sandbox_worker_requires_managed_identity_client_id_when_auth_enabled(mo
 def test_sandbox_worker_requires_registered_activities(monkeypatch) -> None:
     monkeypatch.setenv("DTS_ENDPOINT", "http://localhost:8080")
     monkeypatch.setenv("DTS_TASK_HUB", "env-hub")
+    monkeypatch.setenv("DTS_WORKER_PROFILE_ID", "env-profile")
     monkeypatch.setenv("DTS_SANDBOX_PROVIDER", "Sandbox")
 
     worker = SandboxWorker()
@@ -470,6 +478,7 @@ def test_sandbox_worker_requires_registered_activities(monkeypatch) -> None:
 def test_sandbox_worker_requires_injected_sandbox_provider(monkeypatch) -> None:
     monkeypatch.setenv("DTS_ENDPOINT", "https://example.scheduler")
     monkeypatch.setenv("DTS_TASK_HUB", "env-hub")
+    monkeypatch.setenv("DTS_WORKER_PROFILE_ID", "env-profile")
     monkeypatch.delenv("DTS_SANDBOX_PROVIDER", raising=False)
 
     try:
@@ -483,6 +492,7 @@ def test_sandbox_worker_requires_injected_sandbox_provider(monkeypatch) -> None:
 def test_sandbox_worker_rejects_invalid_sandbox_provider(monkeypatch) -> None:
     monkeypatch.setenv("DTS_ENDPOINT", "https://example.scheduler")
     monkeypatch.setenv("DTS_TASK_HUB", "env-hub")
+    monkeypatch.setenv("DTS_WORKER_PROFILE_ID", "env-profile")
     monkeypatch.setenv("DTS_SANDBOX_PROVIDER", "ContainerApp")
 
     try:
