initial update

modules/python/clients/aks_client.py

@@ -464,12 +464,13 @@ def scale_node_pool(
                 node_pool.count = node_count
 
                 logger.info(f"Scaling node pool {node_pool_name} to {node_count} nodes")
-                self.aks_client.agent_pools.begin_create_or_update(
+                poller = self.aks_client.agent_pools.begin_create_or_update(
                     resource_group_name=self.resource_group,
                     resource_name=cluster_name,
                     agent_pool_name=node_pool_name,
                     parameters=node_pool,
                 )
+                poller.result()  # Wait for Azure control plane to finish before proceeding
 
                 logger.info(
                     f"Waiting for {node_count} nodes in pool {node_pool_name} to be ready..."
@@ -676,12 +677,13 @@ def _progressive_scale(
                         "cluster_info", self.get_cluster_data(cluster_name)
                     )
                     node_pool.count = step  # Update node count in the node pool object
-                    result = self.aks_client.agent_pools.begin_create_or_update(
+                    poller = self.aks_client.agent_pools.begin_create_or_update(
                         resource_group_name=self.resource_group,
                         resource_name=cluster_name,
                         agent_pool_name=node_pool_name,
                         parameters=node_pool,
                     )
+                    result = poller.result()  # Wait for Azure control plane to finish before proceeding
 
                     # Use agentpool=node_pool_name as default label if not specified
                     label_selector = f"agentpool={node_pool_name}"

modules/python/crud/azure/node_pool_crud.py

@@ -8,6 +8,7 @@
 
 import logging
 import time
+import yaml
 
 from clients.aks_client import AKSClient
 from utils.logger_config import get_logger, setup_logging
@@ -270,3 +271,121 @@ def all(
             logger.error(error_msg)
             errors.append(error_msg)
             return False
+
+    def create_deployment(
+        self,
+        node_pool_name,
+        replicas=10,
+        manifest_dir=None,
+        number_of_deployments=1,
+        label_selector="app=nginx-container",
+        namespace="default"
+    ):
+        """
+        Create Kubernetes deployments after node pool operations.
+
+        Args:
+            node_pool_name: Name of the node pool to target
+            deployment_name: Base name for the deployments
+            namespace: Kubernetes namespace (default: "default")
+            replicas: Number of deployment replicas per deployment (default: 10)
+            manifest_dir: Directory containing Kubernetes manifest files
+            number_of_deployments: Number of deployments to create (default: 1)
+
+        Returns:
+            True if all deployment creations were successful, False otherwise
+        """
+        logger.info("Creating %d deployment(s)", number_of_deployments)
+        logger.info("Target node pool: %s", node_pool_name)
+        logger.info("Replicas per deployment: %d", replicas)
+        logger.info("Using manifest directory: %s", manifest_dir)
+
+        try:
+            # Get Kubernetes client from AKS client
+            k8s_client = self.aks_client.k8s_client
+
+            if not k8s_client:
+                logger.error("Kubernetes client not available")
+                return False
+
+            successful_deployments = 0
+
+            # Loop through number of deployments
+            for deployment_index in range(1, number_of_deployments + 1):
+                logger.info("Creating deployment %d/%d", deployment_index, number_of_deployments)
+
+                try:
+                    if manifest_dir:
+                        # Use the template path from manifest_dir
+                        template_path = f"{manifest_dir}/deployment.yml"
+                    else:
+                        # Use default template path
+                        template_path = "modules/python/crud/workload_templates/deployment.yml"
+
+                    # Generate deployment name
+                    deployment_name = f"myapp-{node_pool_name}-{deployment_index}"
+
+                    # Create deployment template using k8s_client.create_template
+                    deployment_template = k8s_client.create_template(
+                        template_path,
+                        {
+                            "DEPLOYMENT_REPLICAS": replicas,
+                            "NODE_POOL_NAME": node_pool_name,
+                            "INDEX": deployment_index,
+                            "LABEL_VALUE": label_selector.split("=", 1)[-1],
+                        }
+                    )
+
+                    # Apply each document in the rendered multi-doc template
+                    for doc in yaml.safe_load_all(deployment_template):
+                        if doc:
+                            k8s_client.apply_manifest_from_file(manifest_dict=doc)
+
+                    logger.info("Applied manifest for deployment %s", deployment_name)
+
+                    # Wait for deployment to be available (successful deployment verification)
+                    logger.info("Waiting for deployment %s to become available...", deployment_name)
+                    deployment_ready = k8s_client.wait_for_condition(
+                        resource_type="deployment",
+                        wait_condition_type="available",
+                        resource_name=deployment_name,
+                        namespace=namespace,
+                        timeout_seconds=self.step_timeout
+                    )
+
+                    if deployment_ready:
+                        logger.info("Deployment %s is successfully available", deployment_name)
+
+                        # Additionally wait for pods to be ready
+                        logger.info("Waiting for pods of deployment %s to be ready...", deployment_name)
+                        k8s_client.wait_for_pods_ready(
+                            operation_timeout_in_minutes=5,
+                            namespace=namespace,
+                            pod_count=replicas,
+                            label_selector=label_selector
+                        )
+
+                        logger.info("Successfully created and verified deployment %d", deployment_index)
+                        successful_deployments += 1
+                    else:
+                        logger.error("Deployment %s failed to become available within timeout", deployment_name)
+                        continue
+
+                except Exception as e:
+                    logger.error("Failed to create deployment %d: %s", deployment_index, e)
+                    # Continue with next deployment instead of failing completely
+                    continue
+
+            # Check if all deployments were successful
+            if successful_deployments == number_of_deployments:
+                logger.info("Successfully created all %d deployment(s)", number_of_deployments)
+                return True
+            if successful_deployments > 0:
+                logger.warning("Created %d/%d deployment(s)", successful_deployments, number_of_deployments)
+                return False
+            logger.error("Failed to create any deployments")
+            return False
+
+        except Exception as e:
+            logger.error("Failed to create deployments: %s", e)
+            return False

modules/python/crud/main.py

@@ -146,6 +146,33 @@ def handle_node_pool_operation(node_pool_crud, args):
         logger.error(f"Error during '{command}' operation: {str(e)}")
         return 1
 
+def handle_workload_operations(node_pool_crud, args):
+    """Handle workload operations (deployment, statefulset, jobs) based on the command"""
+    command = args.command
+    result = None
+
+    try:
+        if command == "deployment":
+            # Prepare deploy arguments
+            deploy_kwargs = {
+                "node_pool_name": args.node_pool_name,
+                "replicas": args.replicas,
+                "manifest_dir": args.manifest_dir,
+                "number_of_deployments": args.number_of_deployments
+            }
+
+            result = node_pool_crud.create_deployment(**deploy_kwargs)
+        else:
+            logger.error("Unknown workload command: '%s'", command)
+            return 1
+        # Check if the operation was successful
+        if result is False:
+            logger.error(f"Operation '{command}' failed")
+            return 1
+        return 0
+    except Exception as e:
+        logger.error(f"Error during '{command}' operation: {str(e)}")
+        return 1
 
 def handle_node_pool_all(node_pool_crud, args):
     """Handle the all-in-one node pool operation command (create, scale up, scale down, delete)"""
@@ -320,6 +347,31 @@ def main():
     )
     all_parser.set_defaults(func=handle_node_pool_operation)
 
+    # Deployment command - add after the "all" command parser
+    deployment_parser = subparsers.add_parser(
+        "deployment", parents=[common_parser], help="create deployments"
+    )
+    deployment_parser.add_argument("--node-pool-name", required=True, help="Node pool name")
+    deployment_parser.add_argument(
+        "--number-of-deployments",
+        type=int,
+        default=1,
+        help="Number of deployments"
+    )
+    deployment_parser.add_argument(
+        "--replicas",
+        type=int,
+        default=10,
+        help="Number of deployment replicas"
+    )
+    deployment_parser.add_argument(
+        "--manifest-dir",
+        required=True,
+        help="Directory containing Kubernetes manifest files for the deployment"
+    )
+
+    deployment_parser.set_defaults(func=handle_workload_operations)
+
     # Arguments provided, run node pool operations and collect benchmark results
     try:
         args = parser.parse_args()

modules/python/crud/workload_templates/deployment.yml

@@ -0,0 +1,34 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: myapp-{{NODE_POOL_NAME}}-{{INDEX}}
+  labels:
+    app: {{LABEL_VALUE}}
+spec:
+  template:
+    metadata:
+      name:
+      labels:
+        app: {{LABEL_VALUE}}
+    spec:
+      containers:
+        - name: {{LABEL_VALUE}}
+          image: mcr.microsoft.com/oss/nginx/nginx:1.21.6
+          ports:
+            - containerPort: 80
+  replicas: {{DEPLOYMENT_REPLICAS}}
+  selector:
+    matchLabels:
+      app: {{LABEL_VALUE}}
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: myapp-{{NODE_POOL_NAME}}-{{INDEX}}
+spec:
+  ports:
+    - port: 80
+      name: myapp
+  clusterIP: None
+  selector:
+    app: {{LABEL_VALUE}}

modules/python/requirements.txt

@@ -12,4 +12,4 @@ coverage==7.6.12
 semver==3.0.4
 requests==2.32.4
 pyyaml==6.0.2
-pyOpenSSL==24.0.0
+pyopenssl>=24.0.0