Customizable Deployment server settings

docs/book/getting-started/deploying-zenml/deploy-with-docker.md

@@ -256,7 +256,6 @@ The following secure headers environment variables are supported:
 * **ZENML\_SERVER\_SECURE\_HEADERS\_SERVER**: The `Server` HTTP header value used to identify the server. The default value is the ZenML server ID.
 * **ZENML\_SERVER\_SECURE\_HEADERS\_HSTS**: The `Strict-Transport-Security` HTTP header value. The default value is `max-age=63072000; includeSubDomains`.
 * **ZENML\_SERVER\_SECURE\_HEADERS\_XFO**: The `X-Frame-Options` HTTP header value. The default value is `SAMEORIGIN`.
-* **ZENML\_SERVER\_SECURE\_HEADERS\_XXP**: The `X-XSS-Protection` HTTP header value. The default value is `0`. NOTE: this header is deprecated and should not be customized anymore. The `Content-Security-Policy` header should be used instead.
 * **ZENML\_SERVER\_SECURE\_HEADERS\_CONTENT**: The `X-Content-Type-Options` HTTP header value. The default value is `nosniff`.
 * **ZENML\_SERVER\_SECURE\_HEADERS\_CSP**: The `Content-Security-Policy` HTTP header value. This is by default set to a strict CSP policy that only allows content from the origins required by the ZenML dashboard. NOTE: customizing this header is discouraged, as it may cause the ZenML dashboard to malfunction.
 * **ZENML\_SERVER\_SECURE\_HEADERS\_REFERRER**: The `Referrer-Policy` HTTP header value. The default value is `no-referrer-when-downgrade`.

docs/book/how-to/containerization/containerization.md

@@ -354,7 +354,16 @@ you already want this automatic detection in current versions of ZenML, set `dis
     docker_settings = DockerSettings(install_stack_requirements=False)
     ```
 
-7.  **Install Local Projects**:
+7.  **Control Deployment Requirements**:
+    By default, if you have a Deployer stack component in your active stack, ZenML installs the requirements needed by the deployment application configured in your deployment settings. You can disable this behavior if needed:
+
+    ```python
+    from zenml.config import DockerSettings
+
+    docker_settings = DockerSettings(install_deployment_requirements=False)
+    ```
+
+8.  **Install Local Projects**:
     If your code requires the installation of some local code files as a python package, you can specify a command
     that installs it as follows:
     ```python

examples/weather_agent/pipelines/weather_agent.py

@@ -1,6 +1,8 @@
 """Weather Agent Pipeline."""
 
 import os
+import time
+from typing import Any, Dict
 
 from pipelines.hooks import (
     InitConfig,
@@ -10,16 +12,105 @@
 from steps import analyze_weather_with_llm, get_weather
 
 from zenml import pipeline
-from zenml.config import DockerSettings
+from zenml.config import DeploymentSettings, DockerSettings
 
 # Import enums for type-safe capture mode configuration
-from zenml.config.docker_settings import PythonPackageInstaller
+from zenml.config.deployment_settings import (
+    EndpointMethod,
+    EndpointSpec,
+    MiddlewareSpec,
+    SecureHeadersConfig,
+)
 from zenml.config.resource_settings import ResourceSettings
 
 docker_settings = DockerSettings(
     requirements=["openai"],
     prevent_build_reuse=True,
-    python_package_installer=PythonPackageInstaller.UV,
+)
+
+
+async def health_detailed() -> Dict[str, Any]:
+    """Detailed health check with system metrics."""
+    import psutil
+
+    return {
+        "status": "healthy",
+        "cpu_percent": psutil.cpu_percent(),
+        "memory_percent": psutil.virtual_memory().percent,
+        "disk_percent": psutil.disk_usage("/").percent,
+    }
+
+
+class RequestTimingMiddleware:
+    """ASGI middleware to measure request processing time.
+
+    Uses the standard ASGI interface (scope, receive, send) which works
+    across all ASGI frameworks: FastAPI, Django, Starlette, Quart, etc.
+    """
+
+    def __init__(self, app):
+        """Initialize the middleware.
+
+        Args:
+            app: The ASGI application to wrap.
+        """
+        self.app = app
+
+    async def __call__(self, scope, receive, send):
+        """Process ASGI request with timing measurement.
+
+        Args:
+            scope: ASGI connection scope (contains request info).
+            receive: Async callable to receive ASGI events.
+            send: Async callable to send ASGI events.
+        """
+        if scope["type"] != "http":
+            return await self.app(scope, receive, send)
+
+        start_time = time.time()
+
+        async def send_wrapper(message):
+            """Intercept response to add timing header."""
+            if message["type"] == "http.response.start":
+                process_time = (time.time() - start_time) * 1000
+                headers = list(message.get("headers", []))
+                headers.append(
+                    (
+                        b"x-process-time-ms",
+                        str(process_time).encode(),
+                    )
+                )
+                message = {**message, "headers": headers}
+
+            await send(message)
+
+        await self.app(scope, receive, send_wrapper)
+
+
+deployment_settings = DeploymentSettings(
+    custom_endpoints=[
+        EndpointSpec(
+            path="/health/detailed",
+            method=EndpointMethod.GET,
+            handler=health_detailed,
+            auth_required=False,
+        ),
+    ],
+    custom_middlewares=[
+        MiddlewareSpec(
+            middleware=RequestTimingMiddleware,
+            order=10,
+        ),
+    ],
+    dashboard_files_path="ui",
+    secure_headers=SecureHeadersConfig(
+        csp=(
+            "default-src 'none'; "
+            "script-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net; "
+            "connect-src 'self' https://cdn.jsdelivr.net; "
+            "style-src 'self' 'unsafe-inline'"
+        ),
+    ),
 )
 
 environment = {}
@@ -34,6 +125,10 @@
     on_cleanup=cleanup_hook,
     settings={
         "docker": docker_settings,
+        "deployment": deployment_settings,
+        "deployer": {
+            "generate_auth_key": True,
+        },
         "deployer.gcp": {
             "allow_unauthenticated": True,
             # "location": "us-central1",
@@ -54,14 +149,8 @@
 )
 def weather_agent(
     city: str = "London",
-) -> str:
-    """Weather agent pipeline optimized for run-only serving.
-
-    Automatically uses run-only architecture for millisecond-class latency:
-    - Zero database writes
-    - Zero filesystem operations
-    - In-memory step output handoff
-    - Perfect for real-time inference
+) -> tuple[Dict[str, float], str]:
+    """Weather agent pipeline.
 
     Args:
         city: City name to analyze weather for
@@ -71,4 +160,4 @@ def weather_agent(
     """
     weather_data = get_weather(city=city)
     result = analyze_weather_with_llm(weather_data=weather_data, city=city)
-    return result
+    return weather_data, result