k8s-helper-cli 0.2.6__tar.gz → 0.3.0__tar.gz

{k8s_helper_cli-0.2.6 → k8s_helper_cli-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: k8s-helper-cli
-Version: 0.2.6
+Version: 0.3.0
 Summary: A simplified Python wrapper for common Kubernetes operations
 Author-email: Harshit Chatterjee <harshitchatterjee50@gmail.com>
 License-Expression: MIT
@@ -573,6 +573,15 @@ k8s-helper create-deployment my-app nginx:latest --replicas 3 --namespace my-nam
 # Scale a deployment
 k8s-helper scale-deployment my-app --replicas 5 --namespace my-namespace
 
+# Perform a rolling update
+k8s-helper rolling-update my-app --image nginx:1.21 --namespace my-namespace
+
+# Rolling update with multiple changes
+k8s-helper rolling-update my-app --image nginx:1.21 --replicas 3 --env "ENV=prod" --namespace my-namespace
+
+# Rolling update with status monitoring
+k8s-helper rolling-update my-app --image nginx:1.21 --show-status --namespace my-namespace
+
 # Delete a deployment
 k8s-helper delete-deployment my-app --namespace my-namespace
 

{k8s_helper_cli-0.2.6 → k8s_helper_cli-0.3.0}/README.md

@@ -546,6 +546,15 @@ k8s-helper create-deployment my-app nginx:latest --replicas 3 --namespace my-nam
 # Scale a deployment
 k8s-helper scale-deployment my-app --replicas 5 --namespace my-namespace
 
+# Perform a rolling update
+k8s-helper rolling-update my-app --image nginx:1.21 --namespace my-namespace
+
+# Rolling update with multiple changes
+k8s-helper rolling-update my-app --image nginx:1.21 --replicas 3 --env "ENV=prod" --namespace my-namespace
+
+# Rolling update with status monitoring
+k8s-helper rolling-update my-app --image nginx:1.21 --show-status --namespace my-namespace
+
 # Delete a deployment
 k8s-helper delete-deployment my-app --namespace my-namespace
 

{k8s_helper_cli-0.2.6 → k8s_helper_cli-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "k8s-helper-cli"
-version = "0.2.6"
+version = "0.3.0"
 description = "A simplified Python wrapper for common Kubernetes operations"
 readme = "README.md"
 authors = [

{k8s_helper_cli-0.2.6 → k8s_helper_cli-0.3.0}/src/k8s_helper/__init__.py

@@ -20,7 +20,7 @@ from .utils import (
     create_service_manifest
 )
 
-__version__ = "0.2.6"
+__version__ = "0.3.0"
 __author__ = "Harshit Chatterjee"
 __email__ = "harshitchatterjee50@gmail.com"
 

{k8s_helper_cli-0.2.6 → k8s_helper_cli-0.3.0}/src/k8s_helper/cli.py

@@ -175,6 +175,117 @@ def scale_deployment(
             console.print(f"❌ Failed to scale deployment {name}")
 
 
+@app.command()
+def rolling_update(
+    name: str = typer.Argument(..., help="Deployment name"),
+    image: Optional[str] = typer.Option(None, "--image", "-i", help="New container image"),
+    replicas: Optional[int] = typer.Option(None, "--replicas", "-r", help="New number of replicas"),
+    port: Optional[int] = typer.Option(None, "--port", "-p", help="New container port"),
+    env: Optional[str] = typer.Option(None, "--env", "-e", help="New environment variables (KEY1=value1,KEY2=value2)"),
+    labels: Optional[str] = typer.Option(None, "--labels", "-l", help="New labels (key1=value1,key2=value2)"),
+    namespace: Optional[str] = namespace_option,
+    wait: bool = typer.Option(True, "--wait/--no-wait", help="Wait for rollout to complete"),
+    timeout: int = typer.Option(300, "--timeout", "-t", help="Timeout in seconds for rollout completion"),
+    show_status: bool = typer.Option(False, "--show-status", "-s", help="Show rollout status during update")
+):
+    """Perform a rolling update on a deployment"""
+    if not validate_name(name):
+        console.print(f"❌ Invalid deployment name: {name}")
+        return
+    
+    # Validate that at least one parameter is provided
+    if not any([image, replicas is not None, port, env, labels]):
+        console.print("❌ At least one update parameter must be provided")
+        console.print("   Use --image, --replicas, --port, --env, or --labels")
+        return
+    
+    # Validate image if provided
+    if image and not validate_image(image):
+        console.print(f"❌ Invalid image name: {image}")
+        return
+    
+    # Parse environment variables and labels
+    env_vars = parse_env_vars(env) if env else None
+    label_dict = parse_labels(labels) if labels else None
+    
+    ns = namespace or get_config().get_namespace()
+    client = K8sClient(namespace=ns)
+    
+    # Show what will be updated
+    console.print(f"🔄 Performing rolling update on deployment: {name}")
+    console.print(f"📍 Namespace: {ns}")
+    
+    updates = []
+    if image:
+        updates.append(f"🖼️  Image: {image}")
+    if replicas is not None:
+        updates.append(f"📊 Replicas: {replicas}")
+    if port:
+        updates.append(f"🚪 Port: {port}")
+    if env_vars:
+        updates.append(f"🔧 Environment variables: {list(env_vars.keys())}")
+    if label_dict:
+        updates.append(f"🏷️  Labels: {list(label_dict.keys())}")
+    
+    console.print("📋 Updates to apply:")
+    for update in updates:
+        console.print(f"   • {update}")
+    
+    # Perform the rolling update
+    with console.status(f"Applying rolling update to {name}..."):
+        success = client.rolling_update_deployment(
+            name=name,
+            image=image,
+            replicas=replicas,
+            env_vars=env_vars,
+            labels=label_dict,
+            container_port=port
+        )
+    
+    if not success:
+        console.print(f"❌ Failed to start rolling update for deployment {name}")
+        return
+    
+    console.print(f"✅ Rolling update initiated for deployment {name}")
+    
+    if wait:
+        console.print(f"⏳ Waiting for rollout to complete (timeout: {timeout}s)...")
+        
+        if show_status:
+            # Show rolling status updates
+            start_time = time.time()
+            while time.time() - start_time < timeout:
+                status = client.get_rollout_status(name)
+                if status:
+                    console.print(f"📊 Status: {status['ready_replicas']}/{status['desired_replicas']} ready, "
+                                f"{status['updated_replicas']} updated, {status['available_replicas']} available")
+                    
+                    # Check if rollout is complete
+                    if (status['ready_replicas'] == status['desired_replicas'] and
+                        status['updated_replicas'] == status['desired_replicas'] and
+                        status['available_replicas'] == status['desired_replicas']):
+                        break
+                
+                time.sleep(3)
+        
+        # Wait for rollout completion
+        if client.wait_for_rollout_complete(name, timeout):
+            console.print("✅ Rolling update completed successfully!")
+            
+            # Show final status
+            final_status = client.get_rollout_status(name)
+            if final_status:
+                console.print(f"📊 Final status: {final_status['ready_replicas']}/{final_status['desired_replicas']} replicas ready")
+            
+            console.print(f"🎉 Deployment {name} is now running with the updated configuration")
+        else:
+            console.print(f"❌ Rolling update timed out after {timeout} seconds")
+            console.print("💡 Check rollout status with: kubectl rollout status deployment/{name}")
+    else:
+        console.print(f"💡 Monitor rollout progress with: kubectl rollout status deployment/{name}")
+        console.print(f"💡 Or use: k8s-helper rolling-update {name} --show-status --wait")
+
+
 @app.command()
 def list_deployments(
     namespace: Optional[str] = namespace_option,
@@ -748,65 +859,61 @@ def create_eks_cluster(
         
         if wait:
             console.print("⏳ Waiting for cluster to become active...")
-            with console.status("Waiting for cluster to be ready..."):
-                if eks_client.wait_for_cluster_active(name):
-                    console.print("✅ EKS cluster is now active!")
-                    
-                    # Show cluster status
-                    status = eks_client.get_cluster_status(name)
-                    console.print(f"🔗 Endpoint: {status['endpoint']}")
-                    
-                    # If node group was created, wait for it too
-                    if create_nodegroup and 'nodegroup_info' in cluster_info:
-                        nodegroup_name = cluster_info['nodegroup_info']['nodegroup_name']
-                        console.print(f"⏳ Waiting for node group {nodegroup_name} to become active...")
-                        with console.status("Waiting for node group to be ready..."):
-                            if eks_client.wait_for_nodegroup_active(name, nodegroup_name):
-                                console.print("✅ Node group is now active!")
-                                console.print("🎉 Cluster is ready with worker nodes!")
-                            else:
-                                console.print("❌ Timeout waiting for node group to become active")
-                    elif create_nodegroup and not wait:
-                        # Create node group now that cluster is active
-                        nodegroup_name = cluster_info.get('node_group_name') or f"{name}-nodegroup"
-                        console.print(f"🔧 Creating node group: {nodegroup_name}")
-                        try:
-                            with console.status("Creating node group..."):
-                                nodegroup_info = eks_client.create_nodegroup(
-                                    cluster_name=name,
-                                    nodegroup_name=nodegroup_name,
-                                    instance_types=instance_type_list,
-                                    ami_type=ami_type,
-                                    capacity_type=capacity_type,
-                                    scaling_config=scaling_config
-                                    # No SSH key for automatic creation
-                                )
-                            console.print(f"✅ Node group creation initiated: {nodegroup_name}")
-                            console.print(f"📋 Node group ARN: {nodegroup_info['nodegroup_arn']}")
-                            
-                            console.print(f"⏳ Waiting for node group to become active...")
-                            with console.status("Waiting for node group to be ready..."):
-                                if eks_client.wait_for_nodegroup_active(name, nodegroup_name):
-                                    console.print("✅ Node group is now active!")
-                                    console.print("🎉 Cluster is ready with worker nodes!")
-                                else:
-                                    console.print("❌ Timeout waiting for node group to become active")
-                        except Exception as e:
-                            console.print(f"❌ Failed to create node group: {e}")
-                    
-                    # Show next steps
-                    console.print(f"\n🚀 Next steps:")
-                    console.print(f"   1. Configure kubectl: aws eks update-kubeconfig --name {name} --region {region}")
-                    if create_nodegroup:
-                        console.print(f"   2. Verify nodes: kubectl get nodes")
-                        console.print(f"   3. Verify connection: kubectl get svc")
-                        console.print(f"   4. Deploy applications: k8s-helper apply <app-name> <image>")
+            if eks_client.wait_for_cluster_active(name):
+                console.print("✅ EKS cluster is now active!")
+                
+                # Show cluster status
+                status = eks_client.get_cluster_status(name)
+                console.print(f"🔗 Endpoint: {status['endpoint']}")
+                
+                # If node group was created, wait for it too
+                if create_nodegroup and 'nodegroup_info' in cluster_info:
+                    nodegroup_name = cluster_info['nodegroup_info']['nodegroup_name']
+                    console.print(f"⏳ Waiting for node group {nodegroup_name} to become active...")
+                    if eks_client.wait_for_nodegroup_active(name, nodegroup_name):
+                        console.print("✅ Node group is now active!")
+                        console.print("🎉 Cluster is ready with worker nodes!")
                     else:
-                        console.print(f"   2. Create node group: k8s-helper create-nodegroup {name}")
-                        console.print(f"   3. Verify connection: kubectl get svc")
-                        console.print(f"   4. Deploy applications: k8s-helper apply <app-name> <image>")
+                        console.print("❌ Timeout waiting for node group to become active")
+                elif create_nodegroup and not wait:
+                    # Create node group now that cluster is active
+                    nodegroup_name = cluster_info.get('node_group_name') or f"{name}-nodegroup"
+                    console.print(f"🔧 Creating node group: {nodegroup_name}")
+                    try:
+                        nodegroup_info = eks_client.create_nodegroup(
+                            cluster_name=name,
+                            nodegroup_name=nodegroup_name,
+                            instance_types=instance_type_list,
+                            ami_type=ami_type,
+                            capacity_type=capacity_type,
+                            scaling_config=scaling_config
+                            # No SSH key for automatic creation
+                        )
+                        console.print(f"✅ Node group creation initiated: {nodegroup_name}")
+                        console.print(f"📋 Node group ARN: {nodegroup_info['nodegroup_arn']}")
+                        
+                        console.print(f"⏳ Waiting for node group to become active...")
+                        if eks_client.wait_for_nodegroup_active(name, nodegroup_name):
+                            console.print("✅ Node group is now active!")
+                            console.print("🎉 Cluster is ready with worker nodes!")
+                        else:
+                            console.print("❌ Timeout waiting for node group to become active")
+                    except Exception as e:
+                        console.print(f"❌ Failed to create node group: {e}")
+                
+                # Show next steps
+                console.print(f"\n🚀 Next steps:")
+                console.print(f"   1. Configure kubectl: aws eks update-kubeconfig --name {name} --region {region}")
+                if create_nodegroup:
+                    console.print(f"   2. Verify nodes: kubectl get nodes")
+                    console.print(f"   3. Verify connection: kubectl get svc")
+                    console.print(f"   4. Deploy applications: k8s-helper apply <app-name> <image>")
                 else:
-                    console.print("❌ Timeout waiting for cluster to become active")
+                    console.print(f"   2. Create node group: k8s-helper create-nodegroup {name}")
+                    console.print(f"   3. Verify connection: kubectl get svc")
+                    console.print(f"   4. Deploy applications: k8s-helper apply <app-name> <image>")
+            else:
+                console.print("❌ Timeout waiting for cluster to become active")
         else:
             console.print(f"💡 Use 'aws eks update-kubeconfig --name {name} --region {region}' to configure kubectl")
     
@@ -907,17 +1014,16 @@ def create_nodegroup(
         
         if wait:
             console.print("⏳ Waiting for node group to become active...")
-            with console.status("Waiting for node group to be ready..."):
-                if eks_client.wait_for_nodegroup_active(cluster_name, nodegroup_name):
-                    console.print("✅ Node group is now active!")
-                    console.print("🎉 You can now deploy workloads!")
-                    
-                    # Show next steps
-                    console.print(f"\n🚀 Next steps:")
-                    console.print(f"   1. Verify nodes: kubectl get nodes")
-                    console.print(f"   2. Deploy applications: k8s-helper apply <app-name> <image>")
-                else:
-                    console.print("❌ Timeout waiting for node group to become active")
+            if eks_client.wait_for_nodegroup_active(cluster_name, nodegroup_name):
+                console.print("✅ Node group is now active!")
+                console.print("🎉 You can now deploy workloads!")
+                
+                # Show next steps
+                console.print(f"\n🚀 Next steps:")
+                console.print(f"   1. Verify nodes: kubectl get nodes")
+                console.print(f"   2. Deploy applications: k8s-helper apply <app-name> <image>")
+            else:
+                console.print("❌ Timeout waiting for node group to become active")
         else:
             console.print(f"💡 Use 'kubectl get nodes' to check when nodes are ready")
     

{k8s_helper_cli-0.2.6 → k8s_helper_cli-0.3.0}/src/k8s_helper/core.py

@@ -834,6 +834,150 @@ class K8sClient:
             print(f"❌ Error scaling deployment '{name}': {e}")
             return False
 
+    def rolling_update_deployment(self, name: str, image: str = None, 
+                                 replicas: int = None, env_vars: Optional[Dict[str, str]] = None,
+                                 labels: Optional[Dict[str, str]] = None,
+                                 container_port: int = None) -> bool:
+        """Perform a rolling update on a deployment
+        
+        Args:
+            name: Deployment name
+            image: New container image (optional)
+            replicas: New replica count (optional)
+            env_vars: New environment variables (optional)
+            labels: New labels (optional)
+            container_port: New container port (optional)
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            # Get current deployment
+            deployment = self.apps_v1.read_namespaced_deployment(
+                name=name,
+                namespace=self.namespace
+            )
+            
+            # Update image if provided
+            if image:
+                for container in deployment.spec.template.spec.containers:
+                    if container.name == name:  # Update main container
+                        container.image = image
+                        break
+            
+            # Update replicas if provided
+            if replicas is not None:
+                deployment.spec.replicas = replicas
+            
+            # Update environment variables if provided
+            if env_vars:
+                for container in deployment.spec.template.spec.containers:
+                    if container.name == name:  # Update main container
+                        env = [client.V1EnvVar(name=k, value=v) for k, v in env_vars.items()]
+                        container.env = env
+                        break
+            
+            # Update labels if provided
+            if labels:
+                if deployment.spec.template.metadata.labels:
+                    deployment.spec.template.metadata.labels.update(labels)
+                else:
+                    deployment.spec.template.metadata.labels = labels
+                
+                # Also update selector labels if they match
+                if deployment.spec.selector.match_labels:
+                    deployment.spec.selector.match_labels.update(labels)
+            
+            # Update container port if provided
+            if container_port:
+                for container in deployment.spec.template.spec.containers:
+                    if container.name == name:  # Update main container
+                        if container.ports:
+                            container.ports[0].container_port = container_port
+                        else:
+                            container.ports = [client.V1ContainerPort(container_port=container_port)]
+                        break
+            
+            # Apply the rolling update
+            self.apps_v1.patch_namespaced_deployment(
+                name=name,
+                namespace=self.namespace,
+                body=deployment
+            )
+            
+            return True
+        except ApiException as e:
+            print(f"❌ Error performing rolling update on deployment '{name}': {e}")
+            return False
+
+    def wait_for_rollout_complete(self, name: str, timeout: int = 300) -> bool:
+        """Wait for a deployment rollout to complete
+        
+        Args:
+            name: Deployment name
+            timeout: Timeout in seconds
+            
+        Returns:
+            True if rollout completed successfully, False otherwise
+        """
+        try:
+            start_time = time.time()
+            while time.time() - start_time < timeout:
+                deployment = self.apps_v1.read_namespaced_deployment(
+                    name=name,
+                    namespace=self.namespace
+                )
+                
+                # Check if rollout is complete
+                if (deployment.status.ready_replicas == deployment.spec.replicas and
+                    deployment.status.updated_replicas == deployment.spec.replicas and
+                    deployment.status.available_replicas == deployment.spec.replicas):
+                    return True
+                
+                time.sleep(2)
+            
+            return False
+        except ApiException as e:
+            print(f"❌ Error waiting for rollout: {e}")
+            return False
+
+    def get_rollout_status(self, name: str) -> Dict[str, Any]:
+        """Get deployment rollout status
+        
+        Args:
+            name: Deployment name
+            
+        Returns:
+            Dictionary with rollout status information
+        """
+        try:
+            deployment = self.apps_v1.read_namespaced_deployment(
+                name=name,
+                namespace=self.namespace
+            )
+            
+            return {
+                'name': deployment.metadata.name,
+                'desired_replicas': deployment.spec.replicas,
+                'current_replicas': deployment.status.replicas or 0,
+                'updated_replicas': deployment.status.updated_replicas or 0,
+                'ready_replicas': deployment.status.ready_replicas or 0,
+                'available_replicas': deployment.status.available_replicas or 0,
+                'unavailable_replicas': deployment.status.unavailable_replicas or 0,
+                'conditions': [
+                    {
+                        'type': condition.type,
+                        'status': condition.status,
+                        'reason': condition.reason,
+                        'message': condition.message,
+                        'last_update_time': condition.last_update_time
+                    } for condition in (deployment.status.conditions or [])
+                ]
+            }
+        except ApiException as e:
+            print(f"❌ Error getting rollout status: {e}")
+            return {}
+
     def list_deployments(self) -> List[Dict[str, Any]]:
         """List all deployments in the namespace"""
         try:

{k8s_helper_cli-0.2.6 → k8s_helper_cli-0.3.0}/src/k8s_helper_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: k8s-helper-cli
-Version: 0.2.6
+Version: 0.3.0
 Summary: A simplified Python wrapper for common Kubernetes operations
 Author-email: Harshit Chatterjee <harshitchatterjee50@gmail.com>
 License-Expression: MIT
@@ -573,6 +573,15 @@ k8s-helper create-deployment my-app nginx:latest --replicas 3 --namespace my-nam
 # Scale a deployment
 k8s-helper scale-deployment my-app --replicas 5 --namespace my-namespace
 
+# Perform a rolling update
+k8s-helper rolling-update my-app --image nginx:1.21 --namespace my-namespace
+
+# Rolling update with multiple changes
+k8s-helper rolling-update my-app --image nginx:1.21 --replicas 3 --env "ENV=prod" --namespace my-namespace
+
+# Rolling update with status monitoring
+k8s-helper rolling-update my-app --image nginx:1.21 --show-status --namespace my-namespace
+
 # Delete a deployment
 k8s-helper delete-deployment my-app --namespace my-namespace