support mdc local mode (Azure#30357)

* update

* add null check

* add doc

* initialize env var and volumes as empty dict

* use dict update

* use update

---------

Co-authored-by: Jun Min <[email protected]>

Author: mjaow

sdk/ml/azure-ai-ml/azure/ai/ml/_local_endpoints/mdc_config_resolver.py

@@ -0,0 +1,81 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+import json
+import os.path
+from pathlib import Path
+
+from azure.ai.ml.entities._deployment.data_collector import DataCollector
+
+
+class MdcConfigResolver(object):
+
+    """Represents the contents of mdc config and handles writing the mdc configuration to User's system.
+
+    :param data_collector: model data collector entity
+    :type data_collector: DataCollector
+    """
+
+    def __init__(
+        self,
+        data_collector: DataCollector,
+    ):
+        self.environment_variables = {}
+        self.volumes = {}
+        self.mdc_config = None
+        self.config_path = "/etc/mdc-config.json"
+        self.local_config_name = "mdc-config.json"
+        self._construct(data_collector)
+
+    def _construct(self, data_collector: DataCollector) -> None:
+        """Internal use only.
+
+        Constructs the mdc configuration based on entity.
+        """
+        if not data_collector.collections:
+            return
+
+        if len(data_collector.collections) <= 0:
+            return
+
+        sampling_percentage = int(data_collector.sampling_rate * 100) if data_collector.sampling_rate else 100
+
+        self.mdc_config = {"collections": {}, "runMode": "local"}
+        custom_logging_enabled = False
+        for k, v in data_collector.collections.items():
+            if v.enabled and v.enabled.lower() == "true":
+                lower_k = k.lower()
+
+                if lower_k not in ("request", "response"):
+                    custom_logging_enabled = True
+
+                self.mdc_config["collections"][lower_k] = {
+                    "enabled": True,
+                    "sampling_percentage": int(v.sampling_rate * 100) if v.sampling_rate else sampling_percentage,
+                }
+
+        if not custom_logging_enabled:
+            self.mdc_config = None
+            return
+
+        if data_collector.request_logging and data_collector.request_logging.capture_headers:
+            self.mdc_config["captureHeaders"] = data_collector.request_logging.capture_headers
+
+    def write_file(self, directory_path: str) -> None:
+        """Writes this mdc configuration to a file in provided directory.
+
+        :param directory_path: absolute path of local directory to write Dockerfile.
+        :type directory_path: str
+        """
+        if not self.mdc_config:
+            return
+
+        mdc_setting_path = str(Path(directory_path, self.local_config_name).resolve())
+        with open(mdc_setting_path, "w") as f:
+            d = json.dumps(self.mdc_config)
+            f.write(f"{d}")
+
+        self.environment_variables = {"AZUREML_MDC_CONFIG_PATH": self.config_path}
+        local_path = os.path.join(directory_path, self.local_config_name)
+
+        self.volumes = {f"{local_path}:{self.config_path}:z": {local_path: {"bind": self.config_path}}}

sdk/ml/azure-ai-ml/azure/ai/ml/operations/_local_deployment_helper.py

@@ -19,6 +19,7 @@
     get_deployment_json_from_container,
     get_status_from_container,
 )
+from azure.ai.ml._local_endpoints.mdc_config_resolver import MdcConfigResolver
 from azure.ai.ml._local_endpoints.validators.code_validator import get_code_configuration_artifacts
 from azure.ai.ml._local_endpoints.validators.environment_validator import get_environment_artifacts
 from azure.ai.ml._local_endpoints.validators.model_validator import get_model_artifacts
@@ -259,6 +260,17 @@ def _create_deployment(
             **image_context.environment,
             **user_environment_variables,
         }
+
+        volumes = {}
+        volumes.update(image_context.volumes)
+
+        if deployment.data_collector:
+            mdc_config = MdcConfigResolver(deployment.data_collector)
+            mdc_config.write_file(deployment_directory_path)
+
+            environment_variables.update(mdc_config.environment_variables)
+            volumes.update(mdc_config.volumes)
+
         # Determine whether we need to use local context or downloaded context
         build_directory = downloaded_build_context if downloaded_build_context else deployment_directory
         self._docker_client.create_deployment(
@@ -270,7 +282,7 @@ def _create_deployment(
             dockerfile_path=None if is_byoc else dockerfile.local_path,
             conda_source_path=yaml_env_conda_file_path,
             conda_yaml_contents=yaml_env_conda_file_contents,
-            volumes=image_context.volumes,
+            volumes=volumes,
             environment=environment_variables,
             azureml_port=inference_config.scoring_route.port if is_byoc else LocalEndpointConstants.DOCKER_PORT,
             local_endpoint_mode=local_endpoint_mode,

sdk/ml/azure-ai-ml/tests/local_endpoint/unittests/test_mdc_config_resolver.py

@@ -0,0 +1,114 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+import pytest
+
+from azure.ai.ml._local_endpoints.mdc_config_resolver import MdcConfigResolver
+from azure.ai.ml.entities._deployment.data_collector import DataCollector
+from azure.ai.ml.entities._deployment.deployment_collection import DeploymentCollection
+from azure.ai.ml.entities._deployment.request_logging import RequestLogging
+
+
+@pytest.mark.unittest
+class TestMdcConfigResolver:
+    def test_resolve_mdc_config(self):
+        resolver = MdcConfigResolver(
+            data_collector=DataCollector(
+                collections={
+                    "inputs": DeploymentCollection(enabled="true", sampling_rate=0.8),
+                    "outputs": DeploymentCollection(enabled="true", sampling_rate=0.7),
+                    "request": DeploymentCollection(enabled="true", sampling_rate=0.6),
+                    "Response": DeploymentCollection(enabled="true", sampling_rate=0.5),
+                },
+                request_logging=RequestLogging(capture_headers=["aaa", "bbb"]),
+            )
+        )
+
+        mdc_config = {
+            "collections": {
+                "inputs": {"enabled": True, "sampling_percentage": 80},
+                "outputs": {"enabled": True, "sampling_percentage": 70},
+                "request": {"enabled": True, "sampling_percentage": 60},
+                "response": {"enabled": True, "sampling_percentage": 50},
+            },
+            "runMode": "local",
+            "captureHeaders": ["aaa", "bbb"],
+        }
+
+        assert mdc_config == resolver.mdc_config
+        assert {} == resolver.environment_variables
+        assert {} == resolver.volumes
+
+    def test_resolve_mdc_config_global_sampling_rate(self):
+        resolver = MdcConfigResolver(
+            data_collector=DataCollector(
+                collections={
+                    "inputs": DeploymentCollection(enabled="true"),
+                    "outputs": DeploymentCollection(enabled="true"),
+                    "request": DeploymentCollection(enabled="true"),
+                    "Response": DeploymentCollection(enabled="true"),
+                },
+                request_logging=RequestLogging(capture_headers=["aaa", "bbb"]),
+                sampling_rate=0.9,
+            )
+        )
+
+        mdc_config = {
+            "collections": {
+                "inputs": {"enabled": True, "sampling_percentage": 90},
+                "outputs": {"enabled": True, "sampling_percentage": 90},
+                "request": {"enabled": True, "sampling_percentage": 90},
+                "response": {"enabled": True, "sampling_percentage": 90},
+            },
+            "runMode": "local",
+            "captureHeaders": ["aaa", "bbb"],
+        }
+
+        assert mdc_config == resolver.mdc_config
+        assert {} == resolver.environment_variables
+        assert {} == resolver.volumes
+
+    def test_resolve_mdc_config_collections_disabled(self):
+        resolver = MdcConfigResolver(
+            data_collector=DataCollector(
+                collections={
+                    "inputs": DeploymentCollection(enabled="false"),
+                    "outputs": DeploymentCollection(enabled="false"),
+                    "request": DeploymentCollection(enabled="false"),
+                    "Response": DeploymentCollection(enabled="false"),
+                },
+                request_logging=RequestLogging(capture_headers=["aaa", "bbb"]),
+                sampling_rate=0.9,
+            )
+        )
+
+        assert not resolver.mdc_config
+        resolver.write_file("/mnt")
+        assert {} == resolver.environment_variables
+        assert {} == resolver.volumes
+
+    def test_resolve_mdc_config_no_collections(self):
+        resolver = MdcConfigResolver(data_collector=DataCollector(collections={}))
+
+        assert not resolver.mdc_config
+        resolver.write_file("/mnt")
+        assert {} == resolver.environment_variables
+        assert {} == resolver.volumes
+
+    def test_resolve_mdc_config_no_custom_logging(self):
+        resolver = MdcConfigResolver(
+            data_collector=DataCollector(
+                collections={
+                    "request": DeploymentCollection(enabled="true"),
+                    "Response": DeploymentCollection(enabled="true"),
+                },
+                request_logging=RequestLogging(capture_headers=["aaa", "bbb"]),
+                sampling_rate=0.9,
+            )
+        )
+
+        assert not resolver.mdc_config
+        resolver.write_file("/mnt")
+        assert {} == resolver.environment_variables
+        assert {} == resolver.volumes