azure-deploy-cli 0.1.12__py3-none-any.whl → 1.0.0__py3-none-any.whl

azure_deploy_cli/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.12'
-__version_tuple__ = version_tuple = (0, 1, 12)
+__version__ = version = '1.0.0'
+__version_tuple__ = version_tuple = (1, 0, 0)
 
 __commit_id__ = commit_id = None

azure_deploy_cli/aca/aca_cli.py

@@ -15,14 +15,13 @@ from ..utils.logging import get_logger
 from .deploy_aca import (
     SecretKeyVaultConfig,
     bind_aca_managed_certificate,
-    build_acr_image,
     create_container_app_env,
     deploy_revision,
     generate_revision_suffix,
-    get_aca_docker_image_name,
     update_traffic_weights,
     validate_revision_suffix_and_throw,
 )
+from .yaml_loader import ContainerAppConfig, load_app_config_yaml
 
 logger = get_logger(__name__)
 
@@ -92,16 +91,16 @@ def _validate_cli_deploy(args: Any):
 
 def cli_deploy(args: Any) -> None:
     """
-    Note: this is an opinionated deployment flow for ACA.
-    Deploy Azure Container App revision without updating traffic.
+    Deploy Azure Container App revision from YAML configuration without updating traffic.
 
     This command orchestrates:
-    1. Create/get user-assigned managed identity (if specified)
-    2. Assign roles to the identity (if role config provided)
-    3. Build and push container image (if not skipped)
-    4. Deploy new revision with 0% traffic
-    5. Verify revision activation and health
-    6. Output the revision name for use in traffic management
+    1. Load container configuration from YAML
+    2. Create/get user-assigned managed identity (if specified)
+    3. Assign roles to the identity (if role config provided)
+    4. Build/push container images for all containers
+    5. Deploy new revision with 0% traffic
+    6. Verify revision activation and health
+    7. Output the revision name for use in traffic management
 
     Args:
         args: Parsed command line arguments
@@ -128,24 +127,9 @@ def cli_deploy(args: Any) -> None:
             else generate_revision_suffix(stage=args.stage)
         )
 
-        logger.critical("Building and pushing ACR image...")
-        logger.info(f"Using revision suffix '{revision_suffix}' as target image tag")
-        build_acr_image(
-            registry_server=args.registry_server,
-            dockerfile=args.dockerfile,
-            full_image_name=get_aca_docker_image_name(
-                registry_server=args.registry_server,
-                image_name=args.image_name,
-                image_tag=revision_suffix,
-            ),
-            source_full_image_name=get_aca_docker_image_name(
-                registry_server=args.registry_server,
-                image_name=args.image_name,
-                image_tag=args.existing_image_tag,
-            )
-            if args.existing_image_tag
-            else None,
-        )
+        logger.critical(f"Loading container configuration from '{args.container_config}'...")
+        app_config: ContainerAppConfig = load_app_config_yaml(args.container_config)
+        logger.critical(f"Loaded configuration with {len(app_config.containers)} container(s)")
 
         logger.critical("Setting up managed identity and roles...")
         user_identity = create_or_get_user_identity(
@@ -180,14 +164,13 @@ def cli_deploy(args: Any) -> None:
             registry_server=args.registry_server,
             registry_user=registry_user,
             registry_pass_env_name=REGISTRY_PASS_SECRET_ENV_NAME,
-            image_name=args.image_name,
-            image_tag=revision_suffix,
             revision_suffix=revision_suffix,
             location=args.location,
             stage=args.stage,
+            container_configs=app_config.containers,
             target_port=args.target_port,
-            cpu=args.cpu,
-            memory=args.memory,
+            ingress_external=args.ingress_external,
+            ingress_transport=args.ingress_transport,
             min_replicas=args.min_replicas,
             max_replicas=args.max_replicas,
             secret_key_vault_config=SecretKeyVaultConfig(
@@ -196,8 +179,6 @@ def cli_deploy(args: Any) -> None:
                 secret_names=args.env_var_secrets or [],
                 user_identity=user_identity,
             ),
-            env_var_names=args.env_vars,
-            existing_image_tag=args.existing_image_tag,
         )
 
         if args.custom_domains:
@@ -352,65 +333,57 @@ def add_commands(subparsers: argparse._SubParsersAction) -> None:
         help="Container registry server.",
     )
     deploy_parser.add_argument(
-        "--image-name",
+        "--keyvault-name",
         required=True,
         type=str,
-        help="Name of the container image.",
+        help="Name of the Key Vault for storing secrets.",
     )
+
     deploy_parser.add_argument(
-        "--existing-image-tag",
-        required=False,
+        "--stage",
+        required=True,
         type=str,
-        help=(
-            "Tag of an existing image to retag to the revision suffix. "
-            "If provided, the image with this tag will be pulled from the registry, "
-            "retagged to the revision suffix, and pushed. "
-            "If the image doesn't exist, deployment will fail."
-        ),
+        help="Deployment stage label (e.g., staging, prod) used for revision naming.",
     )
+
     deploy_parser.add_argument(
         "--target-port",
         required=True,
         type=int,
-        help="Target port for the container app.",
+        help="Target port for the container app ingress.",
     )
+
     deploy_parser.add_argument(
-        "--cpu",
-        required=True,
-        type=float,
-        help="CPU allocation for the container app.",
+        "--ingress-external",
+        required=False,
+        type=bool,
+        default=True,
+        help="Whether ingress is external (default: True).",
     )
+
     deploy_parser.add_argument(
-        "--memory",
-        required=True,
+        "--ingress-transport",
+        required=False,
         type=str,
-        help="Memory allocation for the container app (e.g., '2.0Gi').",
+        default="auto",
+        choices=["auto", "http", "http2", "tcp"],
+        help="Ingress transport protocol (default: auto).",
     )
+
     deploy_parser.add_argument(
         "--min-replicas",
         required=True,
         type=int,
         help="Minimum number of replicas for the container app.",
     )
+
     deploy_parser.add_argument(
         "--max-replicas",
         required=True,
         type=int,
         help="Maximum number of replicas for the container app.",
     )
-    deploy_parser.add_argument(
-        "--keyvault-name",
-        required=True,
-        type=str,
-        help="Name of the Key Vault for storing secrets.",
-    )
 
-    deploy_parser.add_argument(
-        "--stage",
-        required=True,
-        type=str,
-        help="Deployment stage label (e.g., staging, prod) used for revision naming.",
-    )
     deploy_parser.add_argument(
         "--env-var-secrets",
         required=False,
@@ -419,14 +392,6 @@ def add_commands(subparsers: argparse._SubParsersAction) -> None:
         help="Space-separated names of environment variables to be stored as secrets in Key Vault.",
     )
 
-    deploy_parser.add_argument(
-        "--env-vars",
-        required=False,
-        type=str,
-        nargs="+",
-        help="Space-separated names of environment variables to pass to the container.",
-    )
-
     deploy_parser.add_argument(
         "--role-config",
         required=False,
@@ -458,10 +423,11 @@ def add_commands(subparsers: argparse._SubParsersAction) -> None:
     )
 
     deploy_parser.add_argument(
-        "--dockerfile",
+        "--container-config",
         required=True,
-        type=str,
-        help="Path to the Dockerfile for building the container image.",
+        type=Path,
+        help="Path to YAML file containing container configurations "
+        "(includes image names, cpu, memory, env_vars, probes, ingress, and scale settings)",
     )
 
     deploy_parser.set_defaults(func=cli_deploy)

azure_deploy_cli/aca/deploy_aca.py

@@ -30,13 +30,15 @@ from azure.mgmt.appcontainers.models import (
     TrafficWeight,
     UserAssignedIdentity,
 )
-from azure.mgmt.appcontainers.models import Configuration as ContainerAppConfiguration
+from azure.mgmt.appcontainers.models import (
+    Configuration as ContainerAppConfiguration,
+)
 from azure.mgmt.keyvault.models import SecretCreateOrUpdateParameters, SecretProperties
 
 from ..identity.models import ManagedIdentity
 from ..utils import docker
 from ..utils.logging import get_logger
-from .model import RevisionDeploymentResult, SecretKeyVaultConfig
+from .model import ContainerConfig, RevisionDeploymentResult, SecretKeyVaultConfig
 
 logger = get_logger(__name__)
 
@@ -195,6 +197,45 @@ def create_container_app_env(
         return None
 
 
+def build_container_images(
+    container_configs: list[ContainerConfig],
+    registry_server: str,
+    revision_suffix: str,
+) -> list[str]:
+    image_names = []
+
+    for container_config in container_configs:
+        image_tag = revision_suffix
+        target_full_image_name = get_aca_docker_image_name(
+            registry_server, container_config.image_name, image_tag
+        )
+
+        if container_config.existing_image_tag:
+            logger.info(
+                f"Retagging existing image '{container_config.image_name}:"
+                f"{container_config.existing_image_tag}' to '{image_tag}'..."
+            )
+            source_full_image_name = get_aca_docker_image_name(
+                registry_server, container_config.image_name, container_config.existing_image_tag
+            )
+            docker.pull_retag_and_push_image(source_full_image_name, target_full_image_name)
+            logger.success(f"Image retagged successfully to '{image_tag}'")
+        elif container_config.dockerfile:
+            logger.info(
+                f"Building image '{container_config.image_name}' from "
+                f"Dockerfile '{container_config.dockerfile}'..."
+            )
+            build_acr_image(
+                dockerfile=container_config.dockerfile,
+                full_image_name=target_full_image_name,
+                registry_server=registry_server,
+            )
+            logger.success("Image built successfully")
+        image_names.append(target_full_image_name)
+
+    return image_names
+
+
 def deploy_revision(
     client: ContainerAppsAPIClient,
     subscription_id: str,
@@ -205,84 +246,106 @@ def deploy_revision(
     registry_server: str,
     registry_user: str,
     registry_pass_env_name: str,
-    image_name: str,
-    image_tag: str,
+    revision_suffix: str,
     location: str,
     stage: str,
+    container_configs: list[ContainerConfig],  # list[ContainerConfig] from yaml_loader
     target_port: int,
-    cpu: float,
-    memory: str,
+    ingress_external: bool,
+    ingress_transport: str,
     min_replicas: int,
     max_replicas: int,
     secret_key_vault_config: SecretKeyVaultConfig,
-    env_var_names: list[str],
-    revision_suffix: str,
-    existing_image_tag: str | None = None,
 ) -> RevisionDeploymentResult:
     """
-    Deploy a new revision without updating traffic weights.
+    Deploy a new revision with multiple containers without updating traffic weights.
 
     This function creates a new revision with existing traffic preserved and checks
     if the activation succeeds. Returns revision information for use in subsequent
     traffic management operations.
 
-    The image_tag parameter should be the revision suffix when building images with
-    revision-specific tags for rollback support.
-
     Args:
-        revision_suffix: Optional pre-generated revision suffix. If not provided,
-                        one will be generated.
-        existing_image_tag: If provided, the image with this tag will be pulled,
-                           retagged to image_tag, and pushed. If not provided,
-                           the existing behavior is used (check for image with
-                           image_tag and push or build as needed).
+        client: ContainerAppsAPIClient instance
+        subscription_id: Azure subscription ID
+        resource_group: Resource group name
+        container_app_env: Managed environment for the container app
+        user_identity: User-assigned managed identity
+        container_app_name: Name of the container app
+        registry_server: Container registry server URL
+        registry_user: Registry username
+        registry_pass_env_name: Name of the registry password environment variable
+        revision_suffix: Revision suffix for naming
+        location: Azure location
+        stage: Deployment stage label
+        container_configs: List of ContainerConfig objects from YAML
+        target_port: Target port for ingress
+        ingress_external: Whether ingress is external
+        ingress_transport: Ingress transport protocol
+        min_replicas: Minimum number of replicas
+        max_replicas: Maximum number of replicas
+        secret_key_vault_config: Key Vault configuration for secrets
 
     Returns:
         RevisionDeploymentResult with revision name and status information
 
     Raises:
-        RuntimeError: If the deployment fails or if existing_image_tag is provided
-                     but the image doesn't exist
+        RuntimeError: If the deployment fails or image operations fail
     """
+    validate_revision_suffix_and_throw(revision_suffix, stage)
+
     logger.info(f"Deploying new revision for Container App '{container_app_name}'...")
+    logger.info(f"Building and deploying {len(container_configs)} container(s)...")
+
     secret_key_vault_config.secret_names.append(registry_pass_env_name)
-    secrets, env_vars = _prepare_secrets_and_env_vars(
+    secrets, env_vars_dict = _prepare_secrets_and_env_vars(
         secret_config=secret_key_vault_config,
         subscription_id=subscription_id,
-        env_var_names=env_var_names,
+        env_var_names=[
+            env_var
+            for container_config in container_configs
+            for env_var in container_config.env_vars
+        ],
         resource_group=resource_group,
     )
 
-    validate_revision_suffix_and_throw(revision_suffix, stage)
-    revision_name = generate_revision_name(container_app_name, revision_suffix, stage)
-    full_image_name = get_aca_docker_image_name(registry_server, image_name, image_tag)
-
-    # Handle image retagging if existing_image_tag is provided
-    if existing_image_tag:
-        logger.info(f"Retagging existing image with tag '{existing_image_tag}' to '{image_tag}'...")
-        source_full_image_name = get_aca_docker_image_name(
-            registry_server, image_name, existing_image_tag
+    full_image_names = build_container_images(container_configs, registry_server, revision_suffix)
+    if len(full_image_names) != len(container_configs):
+        raise RuntimeError("Mismatch in number of built images and container configurations.")
+
+    # prepare container definitions
+    containers: list[Container] = []
+    for target_full_image_name, container_config in zip(
+        full_image_names, container_configs, strict=True
+    ):
+        container_env_vars = [
+            env_var for env_var in env_vars_dict if env_var.name in container_config.env_vars
+        ]
+        containers.append(
+            Container(
+                image=target_full_image_name,
+                name=container_config.name,
+                env=container_env_vars,
+                resources=ContainerResources(
+                    cpu=container_config.cpu, memory=container_config.memory
+                ),
+                probes=container_config.probes,
+            )
         )
-        target_full_image_name = get_aca_docker_image_name(registry_server, image_name, image_tag)
-
-        try:
-            docker.pull_retag_and_push_image(source_full_image_name, target_full_image_name)
-        except RuntimeError as e:
-            logger.error(f"Failed to retag image from '{existing_image_tag}' to '{image_tag}': {e}")
-            raise RuntimeError(
-                f"Image with tag '{existing_image_tag}' does not exist or retagging failed. "
-                f"Please ensure the source image exists in the registry."
-            ) from e
 
+    # prepare ingress with existing traffic weights
     existing_app = _get_container_app(client, resource_group, container_app_name)
     existing_traffic_weights = None
     if existing_app and existing_app.configuration and existing_app.configuration.ingress:
         existing_traffic_weights = existing_app.configuration.ingress.traffic
-
-    logger.info(
-        f"Deploying revision '{revision_name}' with image '{full_image_name}'"
-        + " and existing traffic preserved"
+    ingress: Ingress = Ingress(
+        external=ingress_external,
+        target_port=target_port,
+        transport=ingress_transport,
+        traffic=existing_traffic_weights,  # Preserve existing traffic
     )
+
+    revision_name = generate_revision_name(container_app_name, revision_suffix, stage)
+    logger.info(f"Deploying revision '{revision_name}' with existing traffic preserved")
     poller = client.container_apps.begin_create_or_update(
         resource_group_name=resource_group,
         container_app_name=container_app_name,
@@ -290,12 +353,7 @@ def deploy_revision(
             location=location,
             environment_id=container_app_env.id,
             configuration=ContainerAppConfiguration(
-                ingress=Ingress(
-                    external=True,
-                    target_port=target_port,
-                    transport="auto",
-                    traffic=existing_traffic_weights,  # Preserve existing traffic
-                ),
+                ingress=ingress,
                 registries=[
                     RegistryCredentials(
                         server=registry_server,
@@ -308,14 +366,7 @@ def deploy_revision(
             ),
             template=Template(
                 revision_suffix=revision_suffix,
-                containers=[
-                    Container(
-                        image=full_image_name,
-                        name=container_app_name,
-                        env=env_vars,
-                        resources=ContainerResources(cpu=cpu, memory=f"{memory}Gi"),
-                    )
-                ],
+                containers=containers,
                 scale=Scale(min_replicas=min_replicas, max_replicas=max_replicas),
             ),
             identity=ManagedServiceIdentity(

azure_deploy_cli/aca/model.py

@@ -1,6 +1,9 @@
 from dataclasses import dataclass
+from typing import Any
 
+from azure.mgmt.appcontainers.models import ContainerAppProbe
 from azure.mgmt.keyvault import KeyVaultManagementClient
+from pydantic import BaseModel, Field, field_validator
 
 from ..identity.models import ManagedIdentity
 
@@ -33,3 +36,46 @@ class RevisionDeploymentResult:
             and self.provisioning_state == "Provisioned"
             and self.running_state not in ("Stopped", "Degraded", "Failed")
         )
+
+
+class ContainerConfig(BaseModel):
+    """Configuration for a single container from YAML."""
+
+    name: str
+    image_name: str = Field(..., description="Just the image name, no registry or tag")
+    cpu: float
+    memory: str
+    env_vars: list[str] = Field(
+        default_factory=list, description="List of environment variable names to load"
+    )
+    probes: list[ContainerAppProbe] | None = Field(
+        default=None, description="List of probe configurations"
+    )
+    existing_image_tag: str | None = Field(default=None, description="Optional tag to retag from")
+    dockerfile: str | None = Field(default=None, description="Optional dockerfile path")
+
+    def post_init(self):
+        if not (self.dockerfile or self.existing_image_tag):
+            raise ValueError(
+                f"Container '{self.name}' must have either 'dockerfile' "
+                f"or 'existing_image_tag' specified"
+            )
+
+    @field_validator("probes", mode="before")
+    @classmethod
+    def parse_probes(cls, v: list[dict[str, Any]] | None) -> list[ContainerAppProbe] | None:
+        """Parse probe dictionaries to ContainerAppProbe objects."""
+        if v is None:
+            return None
+        return [ContainerAppProbe(**probe_data) for probe_data in v]
+
+    class Config:
+        """Pydantic configuration for ContainerConfig."""
+
+        arbitrary_types_allowed = True
+
+
+class ContainerAppConfig(BaseModel):
+    containers: list[ContainerConfig] = Field(
+        ..., min_length=1, description="List of container configurations"
+    )

azure_deploy_cli/aca/yaml_loader.py

@@ -0,0 +1,53 @@
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from .model import ContainerAppConfig
+
+
+def load_app_config_yaml(yaml_path: Path) -> ContainerAppConfig:
+    """
+    Load container configurations from YAML file using Pydantic for validation.
+
+    The YAML should have the following structure:
+    ```yaml
+    containers:
+      - name: my-app
+        image_name: my-image  # Just the image name
+        cpu: 0.5
+        memory: "1.0Gi"
+        env_vars:  # List of env var names to load from environment
+          - ENV_VAR1
+          - ENV_VAR2
+        dockerfile: ./Dockerfile  # optional
+        existing_image_tag: v1.0  # optional
+        probes:  # optional - use snake_case keys
+          - type: Liveness
+            http_get:
+              path: /health
+              port: 8080
+            initial_delay_seconds: 10
+            period_seconds: 30
+    ```
+
+    Args:
+        yaml_path: Path to the YAML configuration file
+
+    Returns:
+        List of ContainerConfig instances
+
+    Raises:
+        ValueError: If YAML structure is invalid or validation fails
+    """
+    with open(yaml_path) as f:
+        data: dict[str, Any] = yaml.safe_load(f)
+
+    if not data:
+        raise ValueError("YAML file is empty")
+
+    try:
+        app_config = ContainerAppConfig(**data)
+        return app_config
+    except Exception as e:
+        raise ValueError(f"Invalid YAML configuration: {e}") from e

azure_deploy_cli/utils/docker.py

@@ -3,6 +3,34 @@
 import subprocess
 from pathlib import Path
 
+from .logging import get_logger
+
+logger = get_logger(__name__)
+
+
+def _run_and_stream(cmd: list[str], show_output: bool = True) -> int:
+    """Run a command and stream output to stderr in real-time.
+
+    Args:
+        cmd: Command and arguments to run
+        show_output: Whether to display output to stderr
+
+    Returns:
+        The return code of the process
+    """
+    process = subprocess.Popen(
+        cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+    )
+    if process.stdout is not None:
+        for line in iter(process.stdout.readline, ""):
+            if line and show_output:
+                logger.info(line.rstrip("\n"))
+        process.stdout.close()
+    return process.wait()
+
 
 def image_exists(full_image_name: str) -> bool:
     """
@@ -14,12 +42,8 @@ def image_exists(full_image_name: str) -> bool:
     Returns:
         True if the image exists locally, False otherwise
     """
-    check_image_result = subprocess.run(
-        ["docker", "image", "inspect", full_image_name],
-        capture_output=True,
-        text=True,
-    )
-    return check_image_result.returncode == 0
+    returncode = _run_and_stream(["docker", "image", "inspect", full_image_name], show_output=False)
+    return returncode == 0
 
 
 def push_image(full_image_name: str) -> None:
@@ -32,13 +56,9 @@ def push_image(full_image_name: str) -> None:
     Raises:
         RuntimeError: If the docker push command fails
     """
-    push_result = subprocess.run(
-        ["docker", "push", full_image_name],
-        capture_output=True,
-        text=True,
-    )
-    if push_result.returncode != 0:
-        raise RuntimeError(f"Docker push failed {push_result.stderr}")
+    returncode = _run_and_stream(["docker", "push", full_image_name])
+    if returncode != 0:
+        raise RuntimeError("Docker push failed")
 
 
 def pull_image(full_image_name: str) -> None:
@@ -51,13 +71,9 @@ def pull_image(full_image_name: str) -> None:
     Raises:
         RuntimeError: If the docker pull command fails
     """
-    pull_result = subprocess.run(
-        ["docker", "pull", full_image_name],
-        capture_output=True,
-        text=True,
-    )
-    if pull_result.returncode != 0:
-        raise RuntimeError(f"Docker pull failed: {pull_result.stderr}")
+    returncode = _run_and_stream(["docker", "pull", full_image_name])
+    if returncode != 0:
+        raise RuntimeError("Docker pull failed")
 
 
 def tag_image(source_image: str, target_image: str) -> None:
@@ -71,13 +87,9 @@ def tag_image(source_image: str, target_image: str) -> None:
     Raises:
         RuntimeError: If the docker tag command fails
     """
-    tag_result = subprocess.run(
-        ["docker", "tag", source_image, target_image],
-        capture_output=True,
-        text=True,
-    )
-    if tag_result.returncode != 0:
-        raise RuntimeError(f"Docker tag failed: {tag_result.stderr}")
+    returncode = _run_and_stream(["docker", "tag", source_image, target_image])
+    if returncode != 0:
+        raise RuntimeError("Docker tag failed")
 
 
 def pull_retag_and_push_image(
@@ -116,7 +128,7 @@ def build_and_push_image(
         RuntimeError: If the docker build and push command fails
     """
     src_folder = str(Path(dockerfile).parent)
-    build_result = subprocess.run(
+    returncode = _run_and_stream(
         [
             "docker",
             "buildx",
@@ -129,9 +141,7 @@ def build_and_push_image(
             dockerfile,
             src_folder,
             "--push",
-        ],
-        capture_output=True,
-        text=True,
+        ]
     )
-    if build_result.returncode != 0:
-        raise RuntimeError(f"Docker build and push failed: {build_result.stderr}")
+    if returncode != 0:
+        raise RuntimeError("Docker build and push failed")

azure_deploy_cli/utils/logging.py

@@ -88,7 +88,7 @@ def configure_logging(level: str = "info") -> None:
     stderr_handler = logging.StreamHandler(sys.stderr)
     stderr_handler.setLevel(log_level)
     stderr_handler.addFilter(lambda record: record.levelno != STDOUT_LEVEL)
-    stderr_handler.setFormatter(ColoredFormatter("%(message)s"))
+    stderr_handler.setFormatter(ColoredFormatter("%(asctime)s %(message)s"))
     root_logger.addHandler(stderr_handler)
 
     # Handler for stdout (only for STDOUT level)

{azure_deploy_cli-0.1.12.dist-info → azure_deploy_cli-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: azure-deploy-cli
-Version: 0.1.12
+Version: 1.0.0
 Summary: Python CLI for Azure deployment automation - identity, roles, and container apps management
 Author-email: decewei <celinew1221@gmail.com>
 License: Mozilla Public License Version 2.0
@@ -399,6 +399,7 @@ Requires-Dist: azure-mgmt-keyvault
 Requires-Dist: azure-mgmt-msi
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pyyaml>=6.0
 Provides-Extra: dev
 Requires-Dist: ruff>=0.1.0; extra == "dev"
 Requires-Dist: mypy>=1.7.0; extra == "dev"
@@ -409,6 +410,7 @@ Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
 Requires-Dist: commitizen>=3.0.0; extra == "dev"
 Requires-Dist: pre-commit>=3.0.0; extra == "dev"
 Requires-Dist: types-setuptools; extra == "dev"
+Requires-Dist: types-PyYAML; extra == "dev"
 Dynamic: license-file
 
 # Azure Deploy CLI
@@ -459,11 +461,11 @@ pip install -e /path/to/scripts
 
 ### Azure Container Apps (ACA) Deployment
 
-The ACA deployment process is split into two stages for better control:
+The ACA deployment process uses YAML configuration for containers and is split into two stages for better control:
 
 #### Stage 1: Deploy Revision
 
-Deploy a new container revision without affecting traffic:
+Deploy a new container revision from YAML configuration without affecting traffic:
 
 ```bash
 azd azaca deploy \
@@ -474,25 +476,76 @@ azd azaca deploy \
   --user-assigned-identity-name my-identity \
   --container-app my-app \
   --registry-server myregistry.azurecr.io \
-  --image-name my-image \
   --stage prod \
-  --target-port 8000 \
-  --cpu 0.5 \
-  --memory 1.0 \
+  --target-port 8080 \
   --min-replicas 1 \
   --max-replicas 10 \
   --keyvault-name my-keyvault \
-  --dockerfile ./Dockerfile \
-  --env-vars ENV_VAR1 ENV_VAR2 \
+  --container-config ./container-config.yaml \
   --env-var-secrets SECRET1 SECRET2
 ```
 
 This command:
 
+- Loads container configurations from YAML file
+- Builds/pushes container images for all containers
 - Creates or updates a new revision with 0% traffic
+- Supports multiple containers with independent configurations
 - Verifies the revision is healthy and active
 - Outputs the revision name for use in traffic management
 
+**Container Configuration YAML:**
+
+The `--container-config` file specifies container settings including images, resources, environment variables, and health probes:
+
+```yaml
+containers:
+  - name: my-app
+    image_name: my-image
+    cpu: 0.5
+    memory: "1.0Gi"
+    env_vars:
+      - ENV_VAR1
+      - ENV_VAR2
+    # relative to the directory which command will run fromm
+    dockerfile: ./Dockerfile
+    probes:
+      - type: Liveness
+        http_get:
+          path: /health
+          port: 8080
+        initial_delay_seconds: 10
+        period_seconds: 30
+      - type: Readiness
+        http_get:
+          path: /ready
+          port: 8080
+        initial_delay_seconds: 5
+        period_seconds: 10
+
+  - name: sidecar
+    image_name: sidecar-image
+    cpu: 0.25
+    memory: "0.5Gi"
+    env_vars:
+      - SIDECAR_CONFIG
+    existing_image_tag: v1.0.0  # Optional: retag from existing image
+```
+
+**Configuration Fields:**
+
+- `containers` (required): List of container configurations
+  - `name`: Container name (required)
+  - `image_name`: Image name without registry/tag (required)
+  - `cpu`: CPU allocation (required, e.g., 0.5)
+  - `memory`: Memory allocation (required, e.g., "1.0Gi")
+  - `env_vars`: List of environment variable names to load (optional)
+  - `dockerfile`: Path to Dockerfile for building (required if existing_image_tag not provided)
+  - `existing_image_tag`: Tag to retag from instead of building (required if dockerfile not provided)
+  - `probes`: List of health probes (optional)
+
+**Note:** Ingress configuration (target port) and scaling parameters (min/max replicas) are specified via CLI arguments, not in the YAML file.
+
 #### Stage 2: Update Traffic Weights
 
 Update traffic distribution and deactivate old revisions:

{azure_deploy_cli-0.1.12.dist-info → azure_deploy_cli-1.0.0.dist-info}/RECORD

@@ -1,10 +1,11 @@
 azure_deploy_cli/__init__.py,sha256=Xj8ZMqmqKWc2hhR8rtSETkOmkvrFgh020MYVB_yHp4s,1134
-azure_deploy_cli/_version.py,sha256=cEPXLUpTV7EzqolnyXW8nf8Hr6IVyBji9CzB6Cq_Ar0,706
+azure_deploy_cli/_version.py,sha256=vLA4ITz09S-S435nq6yTF6l3qiSz6w4euS1rOxXgd1M,704
 azure_deploy_cli/cli.py,sha256=I1hXskorvbryjNg0XXdqLjdBuQTPKgZeW03tLHlLxzk,1663
 azure_deploy_cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-azure_deploy_cli/aca/aca_cli.py,sha256=h-AOoCBrRLV92fitzmF-t9orSHNataj23IeqxD5kY3U,17042
-azure_deploy_cli/aca/deploy_aca.py,sha256=HTLGwSSNdjDVTrQX7ZCrKDWQbd6XJLsS8NDFjuyVbjo,28426
-azure_deploy_cli/aca/model.py,sha256=-ZnJ8RaiKAHqIgWUbmrWXrUa2MTeEqKTZFyNLbo4FUM,894
+azure_deploy_cli/aca/aca_cli.py,sha256=_6c6l7iH5W2Prue3JHSHBQL12WGs9twGivmsZ9h8STU,15944
+azure_deploy_cli/aca/deploy_aca.py,sha256=puuQgP6j-0CJ9rRUFs_yBLiZkEm9bVlQUpRoSon52ac,30303
+azure_deploy_cli/aca/model.py,sha256=rCIVd9WF89g7r7AOZoCPTG6siMaZwSXNR_RzqmKRQEQ,2581
+azure_deploy_cli/aca/yaml_loader.py,sha256=awCJLx88j8ErLm-tLIdV8mFtlSQqGezIqugU0v4m9BI,1413
 azure_deploy_cli/aca/bash/aca-cert/create.sh,sha256=QOPm7b1cTguBDJ2T6Nm65rMLlG1_ccfTcev00IQ-CI0,6485
 azure_deploy_cli/aca/bash/aca-cert/destroy.sh,sha256=iao35H_c4YnZHLDpKaYeyd3I7RhHKJzSAUbNovUdcFg,1171
 azure_deploy_cli/identity/__init__.py,sha256=6s9SoMMhHjMNWNyjkQxWhp2cTbGru3bmrF56-8nCftw,919
@@ -17,14 +18,14 @@ azure_deploy_cli/identity/role.py,sha256=WlSJmn54Urar58x4HmJUC0adbeuSTPyW-0lGodv
 azure_deploy_cli/identity/service_principal.py,sha256=IDBKVVTQP4PBso0Cv0gcApexKEdXUlKEQ3sMr4OjC1U,7958
 azure_deploy_cli/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 azure_deploy_cli/utils/azure_cli.py,sha256=mQXHedduPShY6NqG4JePijWJnK3alCMxrTjqHCn2MaM,2576
-azure_deploy_cli/utils/docker.py,sha256=pMV_edtU-zDMvzygvVx2j7MEUNHBrbhXWOqL7TK1RRU,3675
+azure_deploy_cli/utils/docker.py,sha256=S-X5YkuxiC6TEphwrXlM8Hk_Ik-i_eTnmAs6ymvN4Z8,3965
 azure_deploy_cli/utils/env.py,sha256=Qoc0mlrEcyCGk6TLl0AJNfuvhdBuok_93EW2g7Clpu8,3451
 azure_deploy_cli/utils/key_vault.py,sha256=9JYE1pmoPhggU7TZXod_qmu8TgeVmdM0OEIVHPYtPvM,354
-azure_deploy_cli/utils/logging.py,sha256=9R-Kxwzp6KhvcDFwjDMRbQemcC0uPsAbhgJY41xgl8M,3801
+azure_deploy_cli/utils/logging.py,sha256=NxrhhNGnS0SWReKbwJ56A8LYLmjRd77ZBVOVQe9bgQE,3813
 azure_deploy_cli/utils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-azure_deploy_cli-0.1.12.dist-info/licenses/LICENSE,sha256=Pz2eACSxkhsGfW9_iN60pgy-enjnbGTj8df8O3ebnQQ,16726
-azure_deploy_cli-0.1.12.dist-info/METADATA,sha256=dXyhFVNHCwCZGcFjSDQ3qecdHqXFhqPmmM9R4IeuxZg,28420
-azure_deploy_cli-0.1.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-azure_deploy_cli-0.1.12.dist-info/entry_points.txt,sha256=vuN79v5YJtDi5tF3rCd5qVvCGAMEQMImRHq64B-y-KQ,91
-azure_deploy_cli-0.1.12.dist-info/top_level.txt,sha256=luw_MJJWFd2vFwCtx3wbmihlkCdlZxk1NZou1eToBtU,17
-azure_deploy_cli-0.1.12.dist-info/RECORD,,
+azure_deploy_cli-1.0.0.dist-info/licenses/LICENSE,sha256=Pz2eACSxkhsGfW9_iN60pgy-enjnbGTj8df8O3ebnQQ,16726
+azure_deploy_cli-1.0.0.dist-info/METADATA,sha256=cQtDCD1kYILhA56bgSEAoeYHsZ-HqXlpsx1hB3zGdag,30298
+azure_deploy_cli-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+azure_deploy_cli-1.0.0.dist-info/entry_points.txt,sha256=vuN79v5YJtDi5tF3rCd5qVvCGAMEQMImRHq64B-y-KQ,91
+azure_deploy_cli-1.0.0.dist-info/top_level.txt,sha256=luw_MJJWFd2vFwCtx3wbmihlkCdlZxk1NZou1eToBtU,17
+azure_deploy_cli-1.0.0.dist-info/RECORD,,