k8s-helper-cli 0.2.2__tar.gz → 0.2.4__tar.gz

{k8s_helper_cli-0.2.2 → k8s_helper_cli-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: k8s-helper-cli
-Version: 0.2.2
+Version: 0.2.4
 Summary: A simplified Python wrapper for common Kubernetes operations
 Author-email: Harshit Chatterjee <harshitchatterjee50@gmail.com>
 License-Expression: MIT

{k8s_helper_cli-0.2.2 → k8s_helper_cli-0.2.4}/pyproject.toml

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

{k8s_helper_cli-0.2.2 → k8s_helper_cli-0.2.4}/src/k8s_helper/__init__.py

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

{k8s_helper_cli-0.2.2 → k8s_helper_cli-0.2.4}/src/k8s_helper/cli.py

@@ -664,7 +664,10 @@ def create_eks_cluster(
     min_size: int = typer.Option(1, "--min-size", help="Minimum number of nodes"),
     max_size: int = typer.Option(3, "--max-size", help="Maximum number of nodes"),
     desired_size: int = typer.Option(2, "--desired-size", help="Desired number of nodes"),
-    wait: bool = typer.Option(True, "--wait/--no-wait", help="Wait for cluster to be ready")
+    wait: bool = typer.Option(True, "--wait/--no-wait", help="Wait for cluster to be ready"),
+    create_nodegroup: bool = typer.Option(True, "--create-nodegroup/--no-nodegroup", help="Create node group automatically"),
+    ami_type: str = typer.Option("AL2_x86_64", "--ami-type", help="AMI type for nodes"),
+    capacity_type: str = typer.Option("ON_DEMAND", "--capacity-type", help="Capacity type: ON_DEMAND or SPOT")
 ):
     """Create an AWS EKS cluster"""
     if not validate_name(name):
@@ -690,15 +693,22 @@ def create_eks_cluster(
         console.print(f"🎯 Version: {version}")
         console.print(f"💻 Instance types: {instance_type_list}")
         console.print(f"📊 Scaling: {min_size}-{max_size} nodes (desired: {desired_size})")
+        console.print(f"🛠️  AMI Type: {ami_type}")
+        console.print(f"⚡ Capacity Type: {capacity_type}")
         
         # Show what will be created
-        console.print("\n🔧 EKS Requirements:")
+        console.print("\n🔧 EKS Resources to create:")
         console.print("   • IAM roles for cluster and node groups")
         console.print("   • VPC subnets in at least 2 availability zones")
         console.print("   • Security groups for cluster communication")
         console.print("   • EKS cluster control plane")
-        if node_group:
-            console.print("   • Managed node group with EC2 instances")
+        if create_nodegroup:
+            if node_group:
+                console.print(f"   • Managed node group: {node_group}")
+            else:
+                console.print(f"   • Managed node group: {name}-nodegroup")
+        else:
+            console.print("   • ⚠️  No node group (cluster will have no worker nodes)")
         
         with console.status("Creating EKS cluster and required resources..."):
             cluster_info = eks_client.create_cluster(
@@ -706,7 +716,11 @@ def create_eks_cluster(
                 version=version,
                 node_group_name=node_group,
                 instance_types=instance_type_list,
-                scaling_config=scaling_config
+                scaling_config=scaling_config,
+                ami_type=ami_type,
+                capacity_type=capacity_type,
+                create_nodegroup=create_nodegroup,
+                wait_for_cluster=wait
             )
         
         console.print(f"✅ EKS cluster creation initiated")
@@ -716,6 +730,22 @@ def create_eks_cluster(
         if 'subnets' in cluster_info:
             console.print(f"🌐 Subnets: {cluster_info['subnets']}")
         
+        # Show node group information
+        if create_nodegroup:
+            if 'nodegroup_info' in cluster_info:
+                nodegroup_info = cluster_info['nodegroup_info']
+                console.print(f"\n✅ Node group creation initiated")
+                console.print(f"📋 Node group name: {nodegroup_info['nodegroup_name']}")
+                console.print(f"📋 Node group ARN: {nodegroup_info['nodegroup_arn']}")
+                console.print(f"💻 Instance types: {nodegroup_info['instance_types']}")
+                console.print(f"📊 Scaling config: {nodegroup_info['scaling_config']}")
+            elif 'nodegroup_error' in cluster_info:
+                console.print(f"\n⚠️  Node group creation failed: {cluster_info['nodegroup_error']}")
+                console.print(f"💡 You can create it manually later using: k8s-helper create-nodegroup {name}")
+            elif 'node_group_name' in cluster_info:
+                console.print(f"\n📋 Node group will be created: {cluster_info['node_group_name']}")
+                console.print(f"💡 Create it after cluster is active: k8s-helper create-nodegroup {name}")
+        
         if wait:
             console.print("⏳ Waiting for cluster to become active...")
             with console.status("Waiting for cluster to be ready..."):
@@ -726,11 +756,53 @@ def create_eks_cluster(
                     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
+                                )
+                            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}")
-                    console.print(f"   2. Verify connection: kubectl get svc")
-                    console.print(f"   3. Deploy applications: k8s-helper apply <app-name> <image>")
+                    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(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:
@@ -758,7 +830,161 @@ def create_eks_cluster(
             console.print("   • Ensure you have a default VPC or create one")
             console.print("   • Verify subnet CIDR ranges don't overlap")
 
+@app.command()
+def create_nodegroup(
+    cluster_name: str = typer.Argument(..., help="EKS cluster name"),
+    nodegroup_name: str = typer.Argument(..., help="Node group name"),
+    region: str = typer.Option("us-west-2", "--region", "-r", help="AWS region"),
+    instance_types: str = typer.Option("t3.medium", "--instance-types", help="EC2 instance types (comma-separated)"),
+    min_size: int = typer.Option(1, "--min-size", help="Minimum number of nodes"),
+    max_size: int = typer.Option(3, "--max-size", help="Maximum number of nodes"),
+    desired_size: int = typer.Option(2, "--desired-size", help="Desired number of nodes"),
+    ami_type: str = typer.Option("AL2_x86_64", "--ami-type", help="AMI type for nodes"),
+    capacity_type: str = typer.Option("ON_DEMAND", "--capacity-type", help="Capacity type: ON_DEMAND or SPOT"),
+    wait: bool = typer.Option(True, "--wait/--no-wait", help="Wait for node group to be ready")
+):
+    """Create an EKS managed node group"""
+    if not validate_name(cluster_name):
+        console.print(f"❌ Invalid cluster name: {cluster_name}")
+        return
+    
+    if not validate_name(nodegroup_name):
+        console.print(f"❌ Invalid node group name: {nodegroup_name}")
+        return
+    
+    try:
+        from .core import EKSClient
+        
+        eks_client = EKSClient(region=region)
+        
+        # Parse instance types
+        instance_type_list = [t.strip() for t in instance_types.split(",")]
+        
+        scaling_config = {
+            "minSize": min_size,
+            "maxSize": max_size,
+            "desiredSize": desired_size
+        }
+        
+        console.print(f"🚀 Creating node group: {nodegroup_name}")
+        console.print(f"📋 For cluster: {cluster_name}")
+        console.print(f"📍 Region: {region}")
+        console.print(f"💻 Instance types: {instance_type_list}")
+        console.print(f"📊 Scaling: {min_size}-{max_size} nodes (desired: {desired_size})")
+        console.print(f"🛠️  AMI Type: {ami_type}")
+        console.print(f"⚡ Capacity Type: {capacity_type}")
+        
+        # Check if cluster exists and is active
+        try:
+            cluster_status = eks_client.get_cluster_status(cluster_name)
+            if cluster_status['status'] != 'ACTIVE':
+                console.print(f"❌ Cluster {cluster_name} is not active (status: {cluster_status['status']})")
+                console.print("💡 Wait for cluster to become active before creating node group")
+                return
+        except Exception as e:
+            console.print(f"❌ Cluster {cluster_name} not found: {e}")
+            return
+        
+        with console.status("Creating node group..."):
+            nodegroup_info = eks_client.create_nodegroup(
+                cluster_name=cluster_name,
+                nodegroup_name=nodegroup_name,
+                instance_types=instance_type_list,
+                ami_type=ami_type,
+                capacity_type=capacity_type,
+                scaling_config=scaling_config
+            )
+        
+        console.print(f"✅ Node group creation initiated")
+        console.print(f"📋 Node group ARN: {nodegroup_info['nodegroup_arn']}")
+        console.print(f"🕐 Created at: {nodegroup_info['created_at']}")
+        console.print(f"💻 Instance types: {nodegroup_info['instance_types']}")
+        console.print(f"📊 Scaling config: {nodegroup_info['scaling_config']}")
+        
+        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")
+        else:
+            console.print(f"💡 Use 'kubectl get nodes' to check when nodes are ready")
+    
+    except Exception as e:
+        error_message = str(e)
+        console.print(f"❌ Failed to create node group: {error_message}")
+        
+        # Provide helpful guidance based on error type
+        if "Node group role" in error_message:
+            console.print("\n🛠️  Troubleshooting:")
+            console.print("   • The tool will automatically create required IAM roles")
+            console.print("   • Ensure you have IAM permissions to create roles")
+            console.print("   • Check AWS IAM console for existing roles")
+        elif "subnets" in error_message:
+            console.print("\n🛠️  Troubleshooting:")
+            console.print("   • Node groups require valid subnets")
+            console.print("   • Ensure cluster subnets are properly configured")
+            console.print("   • Check VPC and subnet configuration")
 
+@app.command()
+def list_nodegroups(
+    cluster_name: str = typer.Argument(..., help="EKS cluster name"),
+    region: str = typer.Option("us-west-2", "--region", "-r", help="AWS region"),
+    output: str = output_option
+):
+    """List node groups for an EKS cluster"""
+    if not validate_name(cluster_name):
+        console.print(f"❌ Invalid cluster name: {cluster_name}")
+        return
+    
+    try:
+        from .core import EKSClient
+        
+        eks_client = EKSClient(region=region)
+        
+        with console.status("Fetching node groups..."):
+            nodegroups = eks_client.list_nodegroups(cluster_name)
+        
+        if not nodegroups:
+            console.print(f"📋 No node groups found for cluster: {cluster_name}")
+            console.print(f"💡 Create one with: k8s-helper create-nodegroup {cluster_name} <nodegroup-name>")
+            return
+        
+        if output == "table":
+            table = Table(title=f"Node Groups for {cluster_name}")
+            table.add_column("Name", style="cyan")
+            table.add_column("Status", style="green")
+            table.add_column("Instance Types", style="blue")
+            table.add_column("Capacity Type", style="yellow")
+            table.add_column("Scaling Config", style="magenta")
+            table.add_column("Created", style="white")
+            
+            for ng in nodegroups:
+                scaling = f"{ng['scaling_config']['minSize']}-{ng['scaling_config']['maxSize']} (desired: {ng['scaling_config']['desiredSize']})"
+                table.add_row(
+                    ng['name'],
+                    ng['status'],
+                    ', '.join(ng['instance_types']),
+                    ng['capacity_type'],
+                    scaling,
+                    format_age(ng['created_at'])
+                )
+            
+            console.print(table)
+        elif output == "json":
+            console.print(format_json_output(nodegroups))
+        elif output == "yaml":
+            console.print(format_yaml_output(nodegroups))
+    
+    except Exception as e:
+        console.print(f"❌ Failed to list node groups: {e}")
 # ======================
 # SECRET COMMANDS
 # ======================

{k8s_helper_cli-0.2.2 → k8s_helper_cli-0.2.4}/src/k8s_helper/core.py

@@ -30,7 +30,8 @@ class EKSClient:
                       subnets: List[str] = None, security_groups: List[str] = None,
                       role_arn: str = None, node_group_name: str = None,
                       instance_types: List[str] = None, ami_type: str = "AL2_x86_64",
-                      capacity_type: str = "ON_DEMAND", scaling_config: Dict = None) -> Dict:
+                      capacity_type: str = "ON_DEMAND", scaling_config: Dict = None,
+                      create_nodegroup: bool = True, wait_for_cluster: bool = False) -> Dict:
         """Create an EKS cluster
         
         Args:
@@ -44,6 +45,8 @@ class EKSClient:
             ami_type: AMI type for nodes
             capacity_type: Capacity type (ON_DEMAND or SPOT)
             scaling_config: Scaling configuration for node group
+            create_nodegroup: Whether to create a node group automatically
+            wait_for_cluster: Whether to wait for cluster to be active before returning
             
         Returns:
             Dict containing cluster information
@@ -74,12 +77,16 @@ class EKSClient:
                 resourcesVpcConfig={
                     'subnetIds': subnets,
                     'securityGroupIds': security_groups or [],
-                    'endpointConfigPublic': True,
-                    'endpointConfigPrivate': True
+                    'endpointPublicAccess': True,
+                    'endpointPrivateAccess': True
                 },
                 logging={
-                    'enable': True,
-                    'types': ['api', 'audit', 'authenticator', 'controllerManager', 'scheduler']
+                    'clusterLogging': [
+                        {
+                            'types': ['api', 'audit', 'authenticator', 'controllerManager', 'scheduler'],
+                            'enabled': True
+                        }
+                    ]
                 }
             )
             
@@ -94,11 +101,34 @@ class EKSClient:
                 'created_at': cluster_response['cluster']['createdAt']
             }
             
-            # If node group name is provided, we'll create it after cluster is active
-            if node_group_name:
+            # Create node group if requested
+            if create_nodegroup:
+                if node_group_name is None:
+                    node_group_name = f"{cluster_name}-nodegroup"
+                
                 cluster_info['node_group_name'] = node_group_name
                 cluster_info['instance_types'] = instance_types
                 cluster_info['scaling_config'] = scaling_config
+                cluster_info['create_nodegroup'] = True
+                
+                # If wait_for_cluster is True, create the node group after cluster is active
+                if wait_for_cluster:
+                    if self.wait_for_cluster_active(cluster_name):
+                        try:
+                            nodegroup_info = self.create_nodegroup(
+                                cluster_name=cluster_name,
+                                nodegroup_name=node_group_name,
+                                instance_types=instance_types,
+                                ami_type=ami_type,
+                                capacity_type=capacity_type,
+                                scaling_config=scaling_config,
+                                subnets=subnets
+                            )
+                            cluster_info['nodegroup_info'] = nodegroup_info
+                        except Exception as e:
+                            cluster_info['nodegroup_error'] = str(e)
+                    else:
+                        cluster_info['nodegroup_error'] = "Cluster creation timed out"
             
             return cluster_info
             
@@ -256,6 +286,318 @@ class EKSClient:
             else:
                 raise Exception(f"Failed to create or get cluster role: {e}")
     
+    def _create_or_get_nodegroup_role(self) -> str:
+        """Create or get IAM role for EKS node group"""
+        role_name = "eks-nodegroup-role"
+        
+        try:
+            # Check if role exists
+            response = self.iam_client.get_role(RoleName=role_name)
+            return response['Role']['Arn']
+            
+        except ClientError as e:
+            if e.response['Error']['Code'] == 'NoSuchEntity':
+                # Create the role
+                trust_policy = {
+                    "Version": "2012-10-17",
+                    "Statement": [
+                        {
+                            "Effect": "Allow",
+                            "Principal": {
+                                "Service": "ec2.amazonaws.com"
+                            },
+                            "Action": "sts:AssumeRole"
+                        }
+                    ]
+                }
+                
+                response = self.iam_client.create_role(
+                    RoleName=role_name,
+                    AssumeRolePolicyDocument=json.dumps(trust_policy),
+                    Description="EKS node group role created by k8s-helper"
+                )
+                
+                # Attach required policies for node group
+                policies = [
+                    "arn:aws:iam::aws:policy/AmazonEKSWorkerNodePolicy",
+                    "arn:aws:iam::aws:policy/AmazonEKS_CNI_Policy",
+                    "arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryReadOnly"
+                ]
+                
+                for policy in policies:
+                    self.iam_client.attach_role_policy(
+                        RoleName=role_name,
+                        PolicyArn=policy
+                    )
+                
+                return response['Role']['Arn']
+            else:
+                raise Exception(f"Failed to create or get node group role: {e}")
+    
+    def create_nodegroup(self, cluster_name: str, nodegroup_name: str, 
+                        instance_types: List[str] = None, ami_type: str = "AL2_x86_64",
+                        capacity_type: str = "ON_DEMAND", scaling_config: Dict = None,
+                        subnets: List[str] = None, node_role_arn: str = None) -> Dict:
+        """Create an EKS managed node group
+        
+        Args:
+            cluster_name: Name of the EKS cluster
+            nodegroup_name: Name of the node group
+            instance_types: List of EC2 instance types
+            ami_type: AMI type for nodes
+            capacity_type: Capacity type (ON_DEMAND or SPOT)
+            scaling_config: Scaling configuration
+            subnets: List of subnet IDs
+            node_role_arn: IAM role ARN for nodes
+            
+        Returns:
+            Dict containing node group information
+        """
+        try:
+            # Use defaults if not provided
+            if instance_types is None:
+                instance_types = ["t3.medium"]
+            
+            if scaling_config is None:
+                scaling_config = {
+                    "minSize": 1,
+                    "maxSize": 3,
+                    "desiredSize": 2
+                }
+            
+            if node_role_arn is None:
+                node_role_arn = self._create_or_get_nodegroup_role()
+            
+            if subnets is None:
+                # Get cluster's subnets
+                cluster_info = self.get_cluster_status(cluster_name)
+                cluster_details = self.eks_client.describe_cluster(name=cluster_name)
+                subnets = cluster_details['cluster']['resourcesVpcConfig']['subnetIds']
+            
+            # Create the node group
+            response = self.eks_client.create_nodegroup(
+                clusterName=cluster_name,
+                nodegroupName=nodegroup_name,
+                scalingConfig=scaling_config,
+                instanceTypes=instance_types,
+                amiType=ami_type,
+                capacityType=capacity_type,
+                nodeRole=node_role_arn,
+                subnets=subnets,
+                remoteAccess={
+                    'ec2SshKey': None  # SSH key is optional
+                }
+            )
+            
+            return {
+                'nodegroup_name': nodegroup_name,
+                'cluster_name': cluster_name,
+                'status': 'CREATING',
+                'nodegroup_arn': response['nodegroup']['nodegroupArn'],
+                'instance_types': instance_types,
+                'ami_type': ami_type,
+                'capacity_type': capacity_type,
+                'scaling_config': scaling_config,
+                'created_at': response['nodegroup']['createdAt'],
+                'node_role_arn': node_role_arn
+            }
+            
+        except ClientError as e:
+            raise Exception(f"Failed to create node group: {e}")
+    
+    def get_nodegroup_status(self, cluster_name: str, nodegroup_name: str) -> Dict:
+        """Get EKS node group status"""
+        try:
+            response = self.eks_client.describe_nodegroup(
+                clusterName=cluster_name,
+                nodegroupName=nodegroup_name
+            )
+            nodegroup = response['nodegroup']
+            
+            return {
+                'name': nodegroup['nodegroupName'],
+                'cluster_name': cluster_name,
+                'status': nodegroup['status'],
+                'instance_types': nodegroup['instanceTypes'],
+                'ami_type': nodegroup['amiType'],
+                'capacity_type': nodegroup['capacityType'],
+                'scaling_config': nodegroup['scalingConfig'],
+                'created_at': nodegroup['createdAt'],
+                'arn': nodegroup['nodegroupArn']
+            }
+            
+        except ClientError as e:
+            raise Exception(f"Failed to get node group status: {e}")
+    
+    def wait_for_nodegroup_active(self, cluster_name: str, nodegroup_name: str, timeout: int = 1200) -> bool:
+        """Wait for EKS node group to become active"""
+        import time
+        start_time = time.time()
+        
+        while time.time() - start_time < timeout:
+            try:
+                status = self.get_nodegroup_status(cluster_name, nodegroup_name)
+                if status['status'] == 'ACTIVE':
+                    return True
+                elif status['status'] in ['CREATE_FAILED', 'DEGRADED']:
+                    raise Exception(f"Node group creation failed with status: {status['status']}")
+                
+                time.sleep(30)  # Check every 30 seconds
+                
+            except Exception as e:
+                raise Exception(f"Error waiting for node group: {e}")
+        
+        return False
+    
+    def list_nodegroups(self, cluster_name: str) -> List[Dict]:
+        """List all node groups for a cluster"""
+        try:
+            response = self.eks_client.list_nodegroups(clusterName=cluster_name)
+            nodegroups = []
+            
+            for nodegroup_name in response['nodegroups']:
+                try:
+                    nodegroup_info = self.get_nodegroup_status(cluster_name, nodegroup_name)
+                    nodegroups.append(nodegroup_info)
+                except Exception as e:
+                    # Skip node groups that can't be described
+                    continue
+            
+            return nodegroups
+            
+        except ClientError as e:
+            raise Exception(f"Failed to list node groups: {e}")
+    
+    def create_nodegroup_with_instance_profile(self, cluster_name: str, nodegroup_name: str, 
+                                              instance_types: List[str] = None, ami_type: str = "AL2_x86_64",
+                                              capacity_type: str = "ON_DEMAND", scaling_config: Dict = None,
+                                              subnets: List[str] = None, node_role_arn: str = None,
+                                              instance_profile: str = None) -> Dict:
+        """Create an EKS managed node group with a specific instance profile
+        
+        Args:
+            cluster_name: Name of the EKS cluster
+            nodegroup_name: Name of the node group
+            instance_types: List of EC2 instance types
+            ami_type: AMI type for nodes
+            capacity_type: Capacity type (ON_DEMAND or SPOT)
+            scaling_config: Scaling configuration
+            subnets: List of subnet IDs
+            node_role_arn: IAM role ARN for nodes
+            instance_profile: EC2 instance profile name
+            
+        Returns:
+            Dict containing node group information
+        """
+        try:
+            # Use defaults if not provided
+            if instance_types is None:
+                instance_types = ["t3.medium"]
+            
+            if scaling_config is None:
+                scaling_config = {
+                    "minSize": 1,
+                    "maxSize": 3,
+                    "desiredSize": 2
+                }
+            
+            if node_role_arn is None:
+                node_role_arn = self._create_or_get_nodegroup_role()
+            
+            if subnets is None:
+                # Get cluster's subnets
+                cluster_info = self.get_cluster_status(cluster_name)
+                cluster_details = self.eks_client.describe_cluster(name=cluster_name)
+                subnets = cluster_details['cluster']['resourcesVpcConfig']['subnetIds']
+            
+            # Create the node group
+            response = self.eks_client.create_nodegroup(
+                clusterName=cluster_name,
+                nodegroupName=nodegroup_name,
+                scalingConfig=scaling_config,
+                instanceTypes=instance_types,
+                amiType=ami_type,
+                capacityType=capacity_type,
+                nodeRole=node_role_arn,
+                subnets=subnets,
+                remoteAccess={
+                    'ec2SshKey': None  # SSH key is optional
+                },
+                instanceProfile=instance_profile
+            )
+            
+            return {
+                'nodegroup_name': nodegroup_name,
+                'cluster_name': cluster_name,
+                'status': 'CREATING',
+                'nodegroup_arn': response['nodegroup']['nodegroupArn'],
+                'instance_types': instance_types,
+                'ami_type': ami_type,
+                'capacity_type': capacity_type,
+                'scaling_config': scaling_config,
+                'created_at': response['nodegroup']['createdAt'],
+                'node_role_arn': node_role_arn,
+                'instance_profile': instance_profile
+            }
+            
+        except ClientError as e:
+            raise Exception(f"Failed to create node group with instance profile: {e}")
+    
+    def update_nodegroup_scaling_config(self, cluster_name: str, nodegroup_name: str, 
+                                       scaling_config: Dict) -> bool:
+        """Update the scaling configuration of a node group"""
+        try:
+            # Get current node group configuration
+            nodegroup = self.get_nodegroup_status(cluster_name, nodegroup_name)
+            
+            # Update scaling configuration
+            response = self.eks_client.update_nodegroup_config(
+                clusterName=cluster_name,
+                nodegroupName=nodegroup_name,
+                scalingConfig=scaling_config
+            )
+            
+            print(f"✅ Node group '{nodegroup_name}' scaling configuration updated")
+            return True
+            
+        except ClientError as e:
+            print(f"❌ Error updating node group scaling configuration: {e}")
+            return False
+    
+    def update_nodegroup_instance_type(self, cluster_name: str, nodegroup_name: str, 
+                                      instance_types: List[str]) -> bool:
+        """Update the instance type of a node group"""
+        try:
+            # Get current node group configuration
+            nodegroup = self.get_nodegroup_status(cluster_name, nodegroup_name)
+            
+            # Update instance type
+            response = self.eks_client.update_nodegroup_config(
+                clusterName=cluster_name,
+                nodegroupName=nodegroup_name,
+                instanceTypes=instance_types
+            )
+            
+            print(f"✅ Node group '{nodegroup_name}' instance type updated")
+            return True
+            
+        except ClientError as e:
+            print(f"❌ Error updating node group instance type: {e}")
+            return False
+    
+    def delete_nodegroup(self, cluster_name: str, nodegroup_name: str) -> bool:
+        """Delete an EKS managed node group"""
+        try:
+            self.eks_client.delete_nodegroup(
+                clusterName=cluster_name,
+                nodegroupName=nodegroup_name
+            )
+            print(f"✅ Node group '{nodegroup_name}' deletion initiated")
+            return True
+        except ClientError as e:
+            print(f"❌ Error deleting node group '{nodegroup_name}': {e}")
+            return False
+
     def get_cluster_status(self, cluster_name: str) -> Dict:
         """Get EKS cluster status"""
         try:

{k8s_helper_cli-0.2.2 → k8s_helper_cli-0.2.4}/src/k8s_helper_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: k8s-helper-cli
-Version: 0.2.2
+Version: 0.2.4
 Summary: A simplified Python wrapper for common Kubernetes operations
 Author-email: Harshit Chatterjee <harshitchatterjee50@gmail.com>
 License-Expression: MIT