k8s-helper-cli 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

k8s_helper/__init__.py

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

k8s_helper/cli.py

@@ -8,6 +8,8 @@ from rich.console import Console
 from rich.table import Table
 from rich.panel import Panel
 from rich.text import Text
+import time
+import time
 
 from .core import K8sClient
 from .config import get_config
@@ -21,7 +23,8 @@ from .utils import (
     validate_name,
     validate_image,
     parse_env_vars,
-    parse_labels
+    parse_labels,
+    format_age
 )
 from . import __version__
 
@@ -451,10 +454,15 @@ def apply(
     service_type: str = typer.Option("ClusterIP", help="Service type"),
     env: Optional[str] = typer.Option(None, "--env", "-e", help="Environment variables"),
     labels: Optional[str] = typer.Option(None, "--labels", "-l", help="Labels"),
+    init_container: Optional[str] = typer.Option(None, "--init-container", help="Init container (name:image:command)"),
+    init_env: Optional[str] = typer.Option(None, "--init-env", help="Init container environment variables"),
+    pvc: Optional[str] = typer.Option(None, "--pvc", help="PVC to mount (name:mount_path)"),
+    secret: Optional[str] = typer.Option(None, "--secret", help="Secret to mount (name:mount_path)"),
     namespace: Optional[str] = namespace_option,
-    wait: bool = typer.Option(True, "--wait/--no-wait", help="Wait for deployment to be ready")
+    wait: bool = typer.Option(True, "--wait/--no-wait", help="Wait for deployment to be ready"),
+    show_url: bool = typer.Option(True, "--show-url/--no-show-url", help="Show service URL after deployment")
 ):
-    """Deploy an application (deployment + service)"""
+    """Deploy an application (deployment + service) with advanced features"""
     if not validate_name(name):
         console.print(f"❌ Invalid application name: {name}")
         return
@@ -471,6 +479,80 @@ def apply(
     
     console.print(f"🚀 Deploying application: {name}")
     
+    # Prepare init containers
+    init_containers = []
+    if init_container:
+        try:
+            parts = init_container.split(":")
+            if len(parts) >= 2:
+                init_name, init_image = parts[0], parts[1]
+                init_command = parts[2].split(" ") if len(parts) > 2 else None
+                
+                init_env_vars = parse_env_vars(init_env) if init_env else None
+                
+                init_containers.append({
+                    'name': init_name,
+                    'image': init_image,
+                    'command': init_command,
+                    'env_vars': init_env_vars
+                })
+                
+                console.print(f"🔧 Init container: {init_name} ({init_image})")
+            else:
+                console.print(f"❌ Invalid init container format: {init_container}")
+                return
+        except Exception as e:
+            console.print(f"❌ Error parsing init container: {e}")
+            return
+    
+    # Prepare volumes and volume mounts
+    volumes = []
+    volume_mounts = []
+    
+    if pvc:
+        try:
+            pvc_parts = pvc.split(":")
+            if len(pvc_parts) == 2:
+                pvc_name, mount_path = pvc_parts
+                volumes.append({
+                    'name': f"{pvc_name}-volume",
+                    'type': 'pvc',
+                    'claim_name': pvc_name
+                })
+                volume_mounts.append({
+                    'name': f"{pvc_name}-volume",
+                    'mount_path': mount_path
+                })
+                console.print(f"💾 PVC mount: {pvc_name} → {mount_path}")
+            else:
+                console.print(f"❌ Invalid PVC format: {pvc}")
+                return
+        except Exception as e:
+            console.print(f"❌ Error parsing PVC: {e}")
+            return
+    
+    if secret:
+        try:
+            secret_parts = secret.split(":")
+            if len(secret_parts) == 2:
+                secret_name, mount_path = secret_parts
+                volumes.append({
+                    'name': f"{secret_name}-volume",
+                    'type': 'secret',
+                    'secret_name': secret_name
+                })
+                volume_mounts.append({
+                    'name': f"{secret_name}-volume",
+                    'mount_path': mount_path
+                })
+                console.print(f"🔐 Secret mount: {secret_name} → {mount_path}")
+            else:
+                console.print(f"❌ Invalid secret format: {secret}")
+                return
+        except Exception as e:
+            console.print(f"❌ Error parsing secret: {e}")
+            return
+    
     # Create deployment
     with console.status(f"Creating deployment {name}..."):
         deployment_result = client.create_deployment(
@@ -479,7 +561,10 @@ def apply(
             replicas=replicas,
             container_port=port,
             env_vars=env_vars,
-            labels=label_dict
+            labels=label_dict,
+            init_containers=init_containers if init_containers else None,
+            volume_mounts=volume_mounts if volume_mounts else None,
+            volumes=volumes if volumes else None
         )
     
     if not deployment_result:
@@ -508,6 +593,36 @@ def apply(
                 console.print(f"✅ Application {name} is ready")
             else:
                 console.print(f"❌ Application {name} failed to become ready")
+    
+    # Show service URL if requested
+    if show_url:
+        console.print(f"\n🔗 Service URL Information:")
+        
+        # Wait a moment for service to be ready
+        time.sleep(2)
+        
+        url_info = client.get_service_url(f"{name}-service", ns)
+        if url_info:
+            console.print(f"🔧 Service Type: {url_info['type']}")
+            console.print(f"🖥️  Cluster IP: {url_info['cluster_ip']}")
+            
+            if url_info['type'] == 'LoadBalancer':
+                if url_info.get('aws_elb'):
+                    console.print(f"🌐 AWS ELB DNS: [green]{url_info['elb_dns_name']}[/green]")
+                    console.print(f"🔗 External URL: [blue]{url_info['external_url']}[/blue]")
+                elif url_info.get('external_url'):
+                    console.print(f"🔗 External URL: [blue]{url_info['external_url']}[/blue]")
+                else:
+                    console.print(f"⏳ LoadBalancer provisioning... Use 'k8s-helper service-url {name}-service' to check status")
+            
+            elif url_info['type'] == 'NodePort':
+                if url_info.get('external_url'):
+                    console.print(f"🔗 NodePort URL: [blue]{url_info['external_url']}[/blue]")
+            
+            elif url_info['type'] == 'ClusterIP':
+                console.print(f"💡 ClusterIP service - accessible within cluster at {url_info['cluster_ip']}:{port}")
+        else:
+            console.print("❌ Could not retrieve service URL information")
 
 
 @app.command()
@@ -536,5 +651,327 @@ def cleanup(
             console.print(f"⚠️  Partial cleanup completed for application {name}")
 
 
-if __name__ == "__main__":
-    app()
+# ======================
+# EKS COMMANDS
+# ======================
+@app.command()
+def create_eks_cluster(
+    name: str = typer.Argument(..., help="Cluster name"),
+    region: str = typer.Option("us-west-2", "--region", "-r", help="AWS region"),
+    version: str = typer.Option("1.29", "--version", "-v", help="Kubernetes version"),
+    node_group: str = typer.Option(None, "--node-group", help="Node group name"),
+    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"),
+    wait: bool = typer.Option(True, "--wait/--no-wait", help="Wait for cluster to be ready")
+):
+    """Create an AWS EKS cluster"""
+    if not validate_name(name):
+        console.print(f"❌ Invalid cluster name: {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 EKS cluster: {name}")
+        console.print(f"📍 Region: {region}")
+        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})")
+        
+        with console.status("Creating EKS cluster..."):
+            cluster_info = eks_client.create_cluster(
+                cluster_name=name,
+                version=version,
+                node_group_name=node_group,
+                instance_types=instance_type_list,
+                scaling_config=scaling_config
+            )
+        
+        console.print(f"✅ EKS cluster creation initiated")
+        console.print(f"📋 Cluster ARN: {cluster_info['cluster_arn']}")
+        console.print(f"🕐 Created at: {cluster_info['created_at']}")
+        
+        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']}")
+                else:
+                    console.print("❌ Timeout waiting for cluster to become active")
+        else:
+            console.print("💡 Use 'aws eks update-kubeconfig --name {name} --region {region}' to configure kubectl")
+    
+    except Exception as e:
+        console.print(f"❌ Failed to create EKS cluster: {e}")
+
+
+# ======================
+# SECRET COMMANDS
+# ======================
+@app.command()
+def create_secret(
+    name: str = typer.Argument(..., help="Secret name"),
+    data: str = typer.Option(..., "--data", "-d", help="Secret data (key1=value1,key2=value2)"),
+    secret_type: str = typer.Option("Opaque", "--type", "-t", help="Secret type"),
+    namespace: Optional[str] = namespace_option
+):
+    """Create a Kubernetes secret"""
+    if not validate_name(name):
+        console.print(f"❌ Invalid secret name: {name}")
+        return
+    
+    # Parse data
+    try:
+        data_dict = {}
+        for pair in data.split(","):
+            if "=" in pair:
+                key, value = pair.split("=", 1)
+                data_dict[key.strip()] = value.strip()
+            else:
+                console.print(f"❌ Invalid data format: {pair}")
+                return
+        
+        if not data_dict:
+            console.print("❌ No valid data provided")
+            return
+        
+        ns = namespace or get_config().get_namespace()
+        client = K8sClient(namespace=ns)
+        
+        with console.status(f"Creating secret {name}..."):
+            result = client.create_secret(name, data_dict, secret_type, ns)
+        
+        if result:
+            console.print(f"✅ Secret {name} created successfully")
+            console.print(f"📋 Type: {secret_type}")
+            console.print(f"🔑 Keys: {list(data_dict.keys())}")
+        else:
+            console.print(f"❌ Failed to create secret {name}")
+    
+    except Exception as e:
+        console.print(f"❌ Error creating secret: {e}")
+
+
+@app.command()
+def list_secrets(
+    namespace: Optional[str] = namespace_option,
+    output: str = output_option
+):
+    """List secrets"""
+    ns = namespace or get_config().get_namespace()
+    client = K8sClient(namespace=ns)
+    
+    secrets = client.list_secrets(ns)
+    
+    if output == "table":
+        table = Table(title=f"Secrets in {ns}")
+        table.add_column("Name", style="cyan")
+        table.add_column("Type", style="magenta")
+        table.add_column("Keys", style="green")
+        table.add_column("Age", style="blue")
+        
+        for secret in secrets:
+            age = format_age(secret['created_at'])
+            keys = ", ".join(secret['data_keys'])
+            table.add_row(secret['name'], secret['type'], keys, age)
+        
+        console.print(table)
+    elif output == "yaml":
+        console.print(format_yaml_output(secrets))
+    elif output == "json":
+        console.print(format_json_output(secrets))
+
+
+@app.command()
+def delete_secret(
+    name: str = typer.Argument(..., help="Secret name"),
+    namespace: Optional[str] = namespace_option
+):
+    """Delete a secret"""
+    ns = namespace or get_config().get_namespace()
+    client = K8sClient(namespace=ns)
+    
+    if typer.confirm(f"Are you sure you want to delete secret {name}?"):
+        with console.status(f"Deleting secret {name}..."):
+            if client.delete_secret(name, ns):
+                console.print(f"✅ Secret {name} deleted successfully")
+            else:
+                console.print(f"❌ Failed to delete secret {name}")
+
+
+# ======================
+# PVC COMMANDS
+# ======================
+@app.command()
+def create_pvc(
+    name: str = typer.Argument(..., help="PVC name"),
+    size: str = typer.Argument(..., help="Storage size (e.g., 10Gi, 100Mi)"),
+    access_modes: str = typer.Option("ReadWriteOnce", "--access-modes", "-a", help="Access modes (comma-separated)"),
+    storage_class: Optional[str] = typer.Option(None, "--storage-class", "-s", help="Storage class"),
+    namespace: Optional[str] = namespace_option
+):
+    """Create a Persistent Volume Claim"""
+    if not validate_name(name):
+        console.print(f"❌ Invalid PVC name: {name}")
+        return
+    
+    # Parse access modes
+    access_modes_list = [mode.strip() for mode in access_modes.split(",")]
+    
+    ns = namespace or get_config().get_namespace()
+    client = K8sClient(namespace=ns)
+    
+    with console.status(f"Creating PVC {name}..."):
+        result = client.create_pvc(
+            name=name,
+            size=size,
+            access_modes=access_modes_list,
+            storage_class=storage_class,
+            namespace=ns
+        )
+    
+    if result:
+        console.print(f"✅ PVC {name} created successfully")
+        console.print(f"💾 Size: {size}")
+        console.print(f"🔐 Access modes: {access_modes_list}")
+        if storage_class:
+            console.print(f"📦 Storage class: {storage_class}")
+    else:
+        console.print(f"❌ Failed to create PVC {name}")
+
+
+@app.command()
+def list_pvcs(
+    namespace: Optional[str] = namespace_option,
+    output: str = output_option
+):
+    """List Persistent Volume Claims"""
+    ns = namespace or get_config().get_namespace()
+    client = K8sClient(namespace=ns)
+    
+    pvcs = client.list_pvcs(ns)
+    
+    if output == "table":
+        table = Table(title=f"PVCs in {ns}")
+        table.add_column("Name", style="cyan")
+        table.add_column("Status", style="magenta")
+        table.add_column("Volume", style="green")
+        table.add_column("Size", style="blue")
+        table.add_column("Access Modes", style="yellow")
+        table.add_column("Storage Class", style="red")
+        table.add_column("Age", style="blue")
+        
+        for pvc in pvcs:
+            age = format_age(pvc['created_at'])
+            status_color = "green" if pvc['status'] == 'Bound' else "yellow"
+            table.add_row(
+                pvc['name'],
+                f"[{status_color}]{pvc['status']}[/{status_color}]",
+                pvc['volume_name'] or "N/A",
+                pvc['size'],
+                ", ".join(pvc['access_modes']),
+                pvc['storage_class'] or "N/A",
+                age
+            )
+        
+        console.print(table)
+    elif output == "yaml":
+        console.print(format_yaml_output(pvcs))
+    elif output == "json":
+        console.print(format_json_output(pvcs))
+
+
+@app.command()
+def delete_pvc(
+    name: str = typer.Argument(..., help="PVC name"),
+    namespace: Optional[str] = namespace_option
+):
+    """Delete a Persistent Volume Claim"""
+    ns = namespace or get_config().get_namespace()
+    client = K8sClient(namespace=ns)
+    
+    if typer.confirm(f"Are you sure you want to delete PVC {name}?"):
+        with console.status(f"Deleting PVC {name}..."):
+            if client.delete_pvc(name, ns):
+                console.print(f"✅ PVC {name} deleted successfully")
+            else:
+                console.print(f"❌ Failed to delete PVC {name}")
+
+
+# ======================
+# SERVICE URL COMMAND
+# ======================
+@app.command()
+def service_url(
+    name: str = typer.Argument(..., help="Service name"),
+    namespace: Optional[str] = namespace_option,
+    watch: bool = typer.Option(False, "--watch", "-w", help="Watch for URL changes")
+):
+    """Get service URL including AWS ELB URLs"""
+    ns = namespace or get_config().get_namespace()
+    client = K8sClient(namespace=ns)
+    
+    def show_service_url():
+        url_info = client.get_service_url(name, ns)
+        if not url_info:
+            console.print(f"❌ Service {name} not found")
+            return False
+        
+        console.print(f"\n🔗 Service URL Information for [cyan]{name}[/cyan]")
+        console.print(f"📍 Namespace: {url_info['namespace']}")
+        console.print(f"🔧 Type: {url_info['type']}")
+        console.print(f"🖥️  Cluster IP: {url_info['cluster_ip']}")
+        
+        # Show ports
+        console.print("\n📋 Ports:")
+        for port in url_info['ports']:
+            console.print(f"  • {port['port']}/{port['protocol']} → {port['target_port']}")
+        
+        # Show external access
+        if url_info['type'] == 'LoadBalancer':
+            if url_info.get('aws_elb'):
+                console.print(f"\n🌐 AWS ELB DNS: [green]{url_info['elb_dns_name']}[/green]")
+                console.print(f"🔗 External URL: [blue]{url_info['external_url']}[/blue]")
+            elif url_info.get('external_url'):
+                console.print(f"\n🔗 External URL: [blue]{url_info['external_url']}[/blue]")
+            elif url_info.get('status'):
+                console.print(f"\n⏳ Status: {url_info['status']}")
+        
+        elif url_info['type'] == 'NodePort':
+            if url_info.get('external_url'):
+                console.print(f"\n🔗 NodePort URL: [blue]{url_info['external_url']}[/blue]")
+                console.print(f"🖥️  Node IP: {url_info['node_ip']}")
+                console.print(f"🚪 Node Port: {url_info['node_port']}")
+        
+        elif url_info['type'] == 'ClusterIP':
+            console.print(f"\n💡 ClusterIP service - only accessible within cluster")
+        
+        return True
+    
+    if watch:
+        console.print("👁️  Watching for service URL changes (Ctrl+C to stop)")
+        try:
+            while True:
+                show_service_url()
+                time.sleep(5)
+        except KeyboardInterrupt:
+            console.print("\n👋 Stopped watching")
+    else:
+        show_service_url()

k8s_helper/core.py

@@ -2,8 +2,211 @@ from kubernetes import client, config
 from kubernetes.client.rest import ApiException
 from typing import Dict, List, Optional, Any
 import yaml
+import time
+import base64
+import boto3
+import json
+from botocore.exceptions import ClientError, NoCredentialsError
 
 
+class EKSClient:
+    """AWS EKS client for cluster management"""
+    
+    def __init__(self, region: str = "us-west-2"):
+        """Initialize EKS client
+        
+        Args:
+            region: AWS region for EKS operations
+        """
+        self.region = region
+        try:
+            self.eks_client = boto3.client('eks', region_name=region)
+            self.ec2_client = boto3.client('ec2', region_name=region)
+            self.iam_client = boto3.client('iam', region_name=region)
+        except (NoCredentialsError, ClientError) as e:
+            raise Exception(f"AWS credentials not found or invalid: {e}")
+    
+    def create_cluster(self, cluster_name: str, version: str = "1.29", 
+                      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:
+        """Create an EKS cluster
+        
+        Args:
+            cluster_name: Name of the EKS cluster
+            version: Kubernetes version
+            subnets: List of subnet IDs
+            security_groups: List of security group IDs
+            role_arn: IAM role ARN for the cluster
+            node_group_name: Name for 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 for node group
+            
+        Returns:
+            Dict containing cluster information
+        """
+        try:
+            # Use default values if not provided
+            if subnets is None:
+                subnets = self._get_default_subnets()
+            
+            if role_arn is None:
+                role_arn = self._create_or_get_cluster_role()
+            
+            if instance_types is None:
+                instance_types = ["t3.medium"]
+            
+            if scaling_config is None:
+                scaling_config = {
+                    "minSize": 1,
+                    "maxSize": 3,
+                    "desiredSize": 2
+                }
+            
+            # Create cluster
+            cluster_response = self.eks_client.create_cluster(
+                name=cluster_name,
+                version=version,
+                roleArn=role_arn,
+                resourcesVpcConfig={
+                    'subnetIds': subnets,
+                    'securityGroupIds': security_groups or [],
+                    'endpointConfigPublic': True,
+                    'endpointConfigPrivate': True
+                },
+                logging={
+                    'enable': True,
+                    'types': ['api', 'audit', 'authenticator', 'controllerManager', 'scheduler']
+                }
+            )
+            
+            cluster_info = {
+                'cluster_name': cluster_name,
+                'status': 'CREATING',
+                'cluster_arn': cluster_response['cluster']['arn'],
+                'endpoint': cluster_response['cluster'].get('endpoint', 'Not available yet'),
+                'version': version,
+                'role_arn': role_arn,
+                'subnets': subnets,
+                'created_at': cluster_response['cluster']['createdAt']
+            }
+            
+            # If node group name is provided, we'll create it after cluster is active
+            if node_group_name:
+                cluster_info['node_group_name'] = node_group_name
+                cluster_info['instance_types'] = instance_types
+                cluster_info['scaling_config'] = scaling_config
+            
+            return cluster_info
+            
+        except ClientError as e:
+            raise Exception(f"Failed to create EKS cluster: {e}")
+    
+    def _get_default_subnets(self) -> List[str]:
+        """Get default subnets for EKS cluster"""
+        try:
+            response = self.ec2_client.describe_subnets()
+            subnets = []
+            for subnet in response['Subnets']:
+                if subnet['State'] == 'available':
+                    subnets.append(subnet['SubnetId'])
+            
+            if len(subnets) < 2:
+                raise Exception("Need at least 2 subnets for EKS cluster")
+            
+            return subnets[:2]  # Return first 2 available subnets
+            
+        except ClientError as e:
+            raise Exception(f"Failed to get default subnets: {e}")
+    
+    def _create_or_get_cluster_role(self) -> str:
+        """Create or get IAM role for EKS cluster"""
+        role_name = "eks-cluster-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": "eks.amazonaws.com"
+                            },
+                            "Action": "sts:AssumeRole"
+                        }
+                    ]
+                }
+                
+                response = self.iam_client.create_role(
+                    RoleName=role_name,
+                    AssumeRolePolicyDocument=json.dumps(trust_policy),
+                    Description="EKS cluster role created by k8s-helper"
+                )
+                
+                # Attach required policies
+                policies = [
+                    "arn:aws:iam::aws:policy/AmazonEKSClusterPolicy"
+                ]
+                
+                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 cluster role: {e}")
+    
+    def get_cluster_status(self, cluster_name: str) -> Dict:
+        """Get EKS cluster status"""
+        try:
+            response = self.eks_client.describe_cluster(name=cluster_name)
+            cluster = response['cluster']
+            
+            return {
+                'name': cluster['name'],
+                'status': cluster['status'],
+                'endpoint': cluster.get('endpoint', 'Not available'),
+                'version': cluster['version'],
+                'platform_version': cluster['platformVersion'],
+                'created_at': cluster['createdAt'],
+                'arn': cluster['arn']
+            }
+            
+        except ClientError as e:
+            raise Exception(f"Failed to get cluster status: {e}")
+    
+    def wait_for_cluster_active(self, cluster_name: str, timeout: int = 1800) -> bool:
+        """Wait for EKS cluster to become active"""
+        import time
+        start_time = time.time()
+        
+        while time.time() - start_time < timeout:
+            try:
+                status = self.get_cluster_status(cluster_name)
+                if status['status'] == 'ACTIVE':
+                    return True
+                elif status['status'] == 'FAILED':
+                    raise Exception(f"Cluster creation failed")
+                
+                time.sleep(30)  # Check every 30 seconds
+                
+            except Exception as e:
+                raise Exception(f"Error waiting for cluster: {e}")
+        
+        return False
+
 class K8sClient:
     def __init__(self, namespace="default"):
         try:
@@ -20,8 +223,26 @@ class K8sClient:
     # ======================
     def create_deployment(self, name: str, image: str, replicas: int = 1, 
                          container_port: int = 80, env_vars: Optional[Dict[str, str]] = None,
-                         labels: Optional[Dict[str, str]] = None) -> Optional[Any]:
-        """Create a Kubernetes deployment"""
+                         labels: Optional[Dict[str, str]] = None, 
+                         init_containers: Optional[List[Dict]] = None,
+                         volume_mounts: Optional[List[Dict]] = None,
+                         volumes: Optional[List[Dict]] = None) -> Optional[Any]:
+        """Create a Kubernetes deployment
+        
+        Args:
+            name: Deployment name
+            image: Container image
+            replicas: Number of replicas
+            container_port: Container port
+            env_vars: Environment variables
+            labels: Labels for the deployment
+            init_containers: List of init container specifications
+            volume_mounts: List of volume mounts for the main container
+            volumes: List of volumes for the pod
+            
+        Returns:
+            Deployment object if successful, None otherwise
+        """
         if labels is None:
             labels = {"app": name}
         
@@ -30,16 +251,90 @@ class K8sClient:
         if env_vars:
             env = [client.V1EnvVar(name=k, value=v) for k, v in env_vars.items()]
         
+        # Volume mounts for main container
+        volume_mounts_obj = []
+        if volume_mounts:
+            for vm in volume_mounts:
+                volume_mounts_obj.append(client.V1VolumeMount(
+                    name=vm.get('name'),
+                    mount_path=vm.get('mount_path'),
+                    read_only=vm.get('read_only', False)
+                ))
+        
+        # Main container
         container = client.V1Container(
             name=name,
             image=image,
             ports=[client.V1ContainerPort(container_port=container_port)],
-            env=env if env else None
+            env=env if env else None,
+            volume_mounts=volume_mounts_obj if volume_mounts_obj else None
         )
 
+        # Init containers
+        init_containers_obj = []
+        if init_containers:
+            for init_container in init_containers:
+                init_env = []
+                if init_container.get('env_vars'):
+                    init_env = [client.V1EnvVar(name=k, value=v) 
+                              for k, v in init_container['env_vars'].items()]
+                
+                init_volume_mounts = []
+                if init_container.get('volume_mounts'):
+                    for vm in init_container['volume_mounts']:
+                        init_volume_mounts.append(client.V1VolumeMount(
+                            name=vm.get('name'),
+                            mount_path=vm.get('mount_path'),
+                            read_only=vm.get('read_only', False)
+                        ))
+                
+                init_containers_obj.append(client.V1Container(
+                    name=init_container['name'],
+                    image=init_container['image'],
+                    command=init_container.get('command'),
+                    args=init_container.get('args'),
+                    env=init_env if init_env else None,
+                    volume_mounts=init_volume_mounts if init_volume_mounts else None
+                ))
+        
+        # Volumes
+        volumes_obj = []
+        if volumes:
+            for volume in volumes:
+                if volume.get('type') == 'pvc':
+                    volumes_obj.append(client.V1Volume(
+                        name=volume['name'],
+                        persistent_volume_claim=client.V1PersistentVolumeClaimVolumeSource(
+                            claim_name=volume['claim_name']
+                        )
+                    ))
+                elif volume.get('type') == 'secret':
+                    volumes_obj.append(client.V1Volume(
+                        name=volume['name'],
+                        secret=client.V1SecretVolumeSource(
+                            secret_name=volume['secret_name']
+                        )
+                    ))
+                elif volume.get('type') == 'configmap':
+                    volumes_obj.append(client.V1Volume(
+                        name=volume['name'],
+                        config_map=client.V1ConfigMapVolumeSource(
+                            name=volume['config_map_name']
+                        )
+                    ))
+                elif volume.get('type') == 'empty_dir':
+                    volumes_obj.append(client.V1Volume(
+                        name=volume['name'],
+                        empty_dir=client.V1EmptyDirVolumeSource()
+                    ))
+
         template = client.V1PodTemplateSpec(
             metadata=client.V1ObjectMeta(labels=labels),
-            spec=client.V1PodSpec(containers=[container])
+            spec=client.V1PodSpec(
+                containers=[container],
+                init_containers=init_containers_obj if init_containers_obj else None,
+                volumes=volumes_obj if volumes_obj else None
+            )
         )
 
         spec = client.V1DeploymentSpec(
@@ -468,6 +763,299 @@ class K8sClient:
             print(f"❌ Error describing service '{name}': {e}")
             return None
 
+    # ======================
+    # SECRET OPERATIONS
+    # ======================
+    def create_secret(self, name: str, data: Dict[str, str], 
+                     secret_type: str = "Opaque", namespace: str = None) -> Optional[Any]:
+        """Create a Kubernetes secret
+        
+        Args:
+            name: Name of the secret
+            data: Dictionary of key-value pairs for the secret
+            secret_type: Type of secret (Opaque, kubernetes.io/tls, etc.)
+            namespace: Namespace (uses default if not provided)
+            
+        Returns:
+            Secret object if successful, None otherwise
+        """
+        try:
+            ns = namespace or self.namespace
+            
+            # Encode data as base64
+            encoded_data = {}
+            for key, value in data.items():
+                encoded_data[key] = base64.b64encode(value.encode()).decode()
+            
+            secret = client.V1Secret(
+                metadata=client.V1ObjectMeta(name=name, namespace=ns),
+                type=secret_type,
+                data=encoded_data
+            )
+            
+            result = self.core_v1.create_namespaced_secret(
+                namespace=ns,
+                body=secret
+            )
+            
+            return result
+            
+        except ApiException as e:
+            print(f"❌ Error creating secret: {e}")
+            return None
+    
+    def get_secret(self, name: str, namespace: str = None) -> Optional[Dict]:
+        """Get a Kubernetes secret
+        
+        Args:
+            name: Name of the secret
+            namespace: Namespace (uses default if not provided)
+            
+        Returns:
+            Dictionary containing secret data
+        """
+        try:
+            ns = namespace or self.namespace
+            result = self.core_v1.read_namespaced_secret(name=name, namespace=ns)
+            
+            # Decode base64 data
+            decoded_data = {}
+            if result.data:
+                for key, value in result.data.items():
+                    decoded_data[key] = base64.b64decode(value).decode()
+            
+            return {
+                'name': result.metadata.name,
+                'namespace': result.metadata.namespace,
+                'type': result.type,
+                'data': decoded_data,
+                'created_at': result.metadata.creation_timestamp
+            }
+            
+        except ApiException as e:
+            print(f"❌ Error getting secret: {e}")
+            return None
+    
+    def delete_secret(self, name: str, namespace: str = None) -> bool:
+        """Delete a Kubernetes secret"""
+        try:
+            ns = namespace or self.namespace
+            self.core_v1.delete_namespaced_secret(name=name, namespace=ns)
+            return True
+        except ApiException as e:
+            print(f"❌ Error deleting secret: {e}")
+            return False
+    
+    def list_secrets(self, namespace: str = None) -> List[Dict]:
+        """List all secrets in a namespace"""
+        try:
+            ns = namespace or self.namespace
+            result = self.core_v1.list_namespaced_secret(namespace=ns)
+            
+            secrets = []
+            for secret in result.items:
+                secrets.append({
+                    'name': secret.metadata.name,
+                    'namespace': secret.metadata.namespace,
+                    'type': secret.type,
+                    'data_keys': list(secret.data.keys()) if secret.data else [],
+                    'created_at': secret.metadata.creation_timestamp
+                })
+            
+            return secrets
+            
+        except ApiException as e:
+            print(f"❌ Error listing secrets: {e}")
+            return []
+
+    # ======================
+    # PVC OPERATIONS
+    # ======================
+    def create_pvc(self, name: str, size: str, access_modes: List[str] = None,
+                   storage_class: str = None, namespace: str = None) -> Optional[Any]:
+        """Create a Persistent Volume Claim
+        
+        Args:
+            name: Name of the PVC
+            size: Size of the volume (e.g., '10Gi', '100Mi')
+            access_modes: List of access modes (default: ['ReadWriteOnce'])
+            storage_class: Storage class name
+            namespace: Namespace (uses default if not provided)
+            
+        Returns:
+            PVC object if successful, None otherwise
+        """
+        try:
+            ns = namespace or self.namespace
+            
+            if access_modes is None:
+                access_modes = ['ReadWriteOnce']
+            
+            # Create PVC specification
+            pvc_spec = client.V1PersistentVolumeClaimSpec(
+                access_modes=access_modes,
+                resources=client.V1ResourceRequirements(
+                    requests={'storage': size}
+                )
+            )
+            
+            if storage_class:
+                pvc_spec.storage_class_name = storage_class
+            
+            pvc = client.V1PersistentVolumeClaim(
+                metadata=client.V1ObjectMeta(name=name, namespace=ns),
+                spec=pvc_spec
+            )
+            
+            result = self.core_v1.create_namespaced_persistent_volume_claim(
+                namespace=ns,
+                body=pvc
+            )
+            
+            return result
+            
+        except ApiException as e:
+            print(f"❌ Error creating PVC: {e}")
+            return None
+    
+    def get_pvc(self, name: str, namespace: str = None) -> Optional[Dict]:
+        """Get a Persistent Volume Claim"""
+        try:
+            ns = namespace or self.namespace
+            result = self.core_v1.read_namespaced_persistent_volume_claim(name=name, namespace=ns)
+            
+            return {
+                'name': result.metadata.name,
+                'namespace': result.metadata.namespace,
+                'status': result.status.phase,
+                'volume_name': result.spec.volume_name,
+                'access_modes': result.spec.access_modes,
+                'storage_class': result.spec.storage_class_name,
+                'size': result.spec.resources.requests.get('storage', 'Unknown'),
+                'created_at': result.metadata.creation_timestamp
+            }
+            
+        except ApiException as e:
+            print(f"❌ Error getting PVC: {e}")
+            return None
+    
+    def delete_pvc(self, name: str, namespace: str = None) -> bool:
+        """Delete a Persistent Volume Claim"""
+        try:
+            ns = namespace or self.namespace
+            self.core_v1.delete_namespaced_persistent_volume_claim(name=name, namespace=ns)
+            return True
+        except ApiException as e:
+            print(f"❌ Error deleting PVC: {e}")
+            return False
+    
+    def list_pvcs(self, namespace: str = None) -> List[Dict]:
+        """List all PVCs in a namespace"""
+        try:
+            ns = namespace or self.namespace
+            result = self.core_v1.list_namespaced_persistent_volume_claim(namespace=ns)
+            
+            pvcs = []
+            for pvc in result.items:
+                pvcs.append({
+                    'name': pvc.metadata.name,
+                    'namespace': pvc.metadata.namespace,
+                    'status': pvc.status.phase,
+                    'volume_name': pvc.spec.volume_name,
+                    'access_modes': pvc.spec.access_modes,
+                    'storage_class': pvc.spec.storage_class_name,
+                    'size': pvc.spec.resources.requests.get('storage', 'Unknown'),
+                    'created_at': pvc.metadata.creation_timestamp
+                })
+            
+            return pvcs
+            
+        except ApiException as e:
+            print(f"❌ Error listing PVCs: {e}")
+            return []
+
+    # ======================
+    # SERVICE URL OPERATIONS
+    # ======================
+    def get_service_url(self, name: str, namespace: str = None) -> Optional[Dict]:
+        """Get service URL, including AWS ELB URLs for LoadBalancer services
+        
+        Args:
+            name: Name of the service
+            namespace: Namespace (uses default if not provided)
+            
+        Returns:
+            Dictionary containing service URL information
+        """
+        try:
+            ns = namespace or self.namespace
+            service = self.core_v1.read_namespaced_service(name=name, namespace=ns)
+            
+            service_type = service.spec.type
+            ports = []
+            for port in service.spec.ports:
+                ports.append({
+                    'port': port.port,
+                    'target_port': port.target_port,
+                    'protocol': port.protocol,
+                    'name': port.name
+                })
+            
+            result = {
+                'name': name,
+                'namespace': ns,
+                'type': service_type,
+                'ports': ports,
+                'cluster_ip': service.spec.cluster_ip
+            }
+            
+            if service_type == 'LoadBalancer':
+                # Check for AWS ELB
+                ingress = service.status.load_balancer.ingress
+                if ingress:
+                    for ing in ingress:
+                        if ing.hostname:  # AWS ELB uses hostname
+                            result['external_url'] = f"http://{ing.hostname}"
+                            result['external_hostname'] = ing.hostname
+                            
+                            # Check if it's an AWS ELB
+                            if 'elb.amazonaws.com' in ing.hostname:
+                                result['aws_elb'] = True
+                                result['elb_dns_name'] = ing.hostname
+                        elif ing.ip:  # Some cloud providers use IP
+                            result['external_url'] = f"http://{ing.ip}"
+                            result['external_ip'] = ing.ip
+                
+                # If no ingress yet, service might still be provisioning
+                if not ingress:
+                    result['status'] = 'Provisioning LoadBalancer...'
+            
+            elif service_type == 'NodePort':
+                # For NodePort, we need to get node IPs
+                nodes = self.core_v1.list_node()
+                if nodes.items:
+                    node_ip = None
+                    for node in nodes.items:
+                        for address in node.status.addresses:
+                            if address.type == 'ExternalIP':
+                                node_ip = address.address
+                                break
+                        if node_ip:
+                            break
+                    
+                    if node_ip:
+                        for port in service.spec.ports:
+                            if port.node_port:
+                                result['external_url'] = f"http://{node_ip}:{port.node_port}"
+                                result['node_ip'] = node_ip
+                                result['node_port'] = port.node_port
+            
+            return result
+            
+        except ApiException as e:
+            print(f"❌ Error getting service URL: {e}")
+            return None
+
     # ======================
     # UTILITY METHODS
     # ======================

{k8s_helper_cli-0.2.0.dist-info → k8s_helper_cli-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: k8s-helper-cli
-Version: 0.2.0
+Version: 0.2.1
 Summary: A simplified Python wrapper for common Kubernetes operations
 Author-email: Harshit Chatterjee <harshitchatterjee50@gmail.com>
 License-Expression: MIT
@@ -14,6 +14,8 @@ Requires-Dist: kubernetes>=26.1.0
 Requires-Dist: typer>=0.9.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: pyyaml>=6.0
+Requires-Dist: boto3>=1.26.0
+Requires-Dist: botocore>=1.29.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-mock>=3.10.0; extra == "dev"
@@ -30,8 +32,13 @@ A simplified Python wrapper for common Kubernetes operations that makes it easy
 ## Features
 
 - ✅ **Pod Management**: Create, delete, and list pods
-- ✅ **Deployment Management**: Create, delete, scale, and list deployments
-- ✅ **Service Management**: Create, delete, and list services
+- ✅ **Deployment Management**: Create, delete, scale, and list deployments with init containers
+- ✅ **Service Management**: Create, delete, list services with URL retrieval
+- ✅ **AWS EKS Integration**: Create and manage EKS clusters with automatic configuration
+- ✅ **Secrets Management**: Create, list, and delete Kubernetes secrets
+- ✅ **Persistent Volume Claims**: Create, list, and delete PVCs with multiple access modes
+- ✅ **Service URL Discovery**: Get service URLs including AWS ELB DNS names
+- ✅ **Advanced Deployments**: Support for init containers, volume mounts, and complex configurations
 - ✅ **Resource Monitoring**: Get logs, events, and resource descriptions
 - ✅ **Easy Configuration**: Simple configuration management
 - ✅ **Formatted Output**: Beautiful table, YAML, and JSON output formats
@@ -60,6 +67,13 @@ pip install -e .
 
 **Important**: k8s-helper requires an active Kubernetes cluster connection. Without a properly configured kubectl and accessible cluster, the commands will fail with configuration errors.
 
+### AWS EKS Features Prerequisites
+
+For AWS EKS integration features:
+- AWS CLI configured with appropriate credentials (`aws configure`)
+- AWS IAM permissions for EKS, EC2, and IAM operations
+- boto3 package (automatically installed with k8s-helper-cli)
+
 ### Setting up Kubernetes (Choose one):
 
 1. **Local Development**: 
@@ -702,6 +716,112 @@ k8s-helper --install-completion zsh
 k8s-helper --show-completion bash
 ```
 
+### AWS EKS Integration
+
+```bash
+# Create an EKS cluster
+k8s-helper create-eks-cluster my-cluster --region us-west-2 --version 1.29
+
+# Create EKS cluster with custom settings
+k8s-helper create-eks-cluster my-cluster \
+  --region us-east-1 \
+  --instance-types t3.medium,t3.large \
+  --min-size 2 \
+  --max-size 10 \
+  --desired-size 3 \
+  --node-group my-nodes \
+  --wait
+
+# Note: Requires AWS credentials configured (aws configure)
+```
+
+### Secrets Management
+
+```bash
+# Create a secret
+k8s-helper create-secret my-secret --data "username=admin,password=secret123"
+
+# Create a TLS secret
+k8s-helper create-secret tls-secret --data "tls.crt=cert_content,tls.key=key_content" --type kubernetes.io/tls
+
+# List secrets
+k8s-helper list-secrets --namespace my-namespace
+
+# Delete a secret
+k8s-helper delete-secret my-secret --namespace my-namespace
+```
+
+### Persistent Volume Claims (PVC)
+
+```bash
+# Create a PVC
+k8s-helper create-pvc my-storage 10Gi --access-modes ReadWriteOnce
+
+# Create PVC with specific storage class
+k8s-helper create-pvc my-storage 50Gi --storage-class fast-ssd --access-modes ReadWriteMany
+
+# List PVCs
+k8s-helper list-pvcs --namespace my-namespace
+
+# Delete a PVC
+k8s-helper delete-pvc my-storage --namespace my-namespace
+```
+
+### Service URL Retrieval
+
+```bash
+# Get service URL (including AWS ELB URLs)
+k8s-helper service-url my-service --namespace my-namespace
+
+# Watch for URL changes (useful for LoadBalancer provisioning)
+k8s-helper service-url my-service --watch --namespace my-namespace
+
+# Shows:
+# - ClusterIP access information
+# - NodePort URLs
+# - AWS ELB DNS names for LoadBalancer services
+# - External IPs and hostnames
+```
+
+### Enhanced Application Deployment
+
+```bash
+# Deploy with init container
+k8s-helper apply my-app nginx:latest \
+  --init-container "init-db:postgres:13:pg_isready -h db" \
+  --init-env "PGHOST=db,PGPORT=5432"
+
+# Deploy with PVC mount
+k8s-helper apply my-app nginx:latest \
+  --pvc "my-storage:/data" \
+  --replicas 2
+
+# Deploy with secret mount
+k8s-helper apply my-app nginx:latest \
+  --secret "my-secret:/etc/secrets" \
+  --port 8080
+
+# Deploy with LoadBalancer and show URL
+k8s-helper apply my-app nginx:latest \
+  --service-type LoadBalancer \
+  --wait \
+  --show-url
+
+# Complex deployment with multiple features
+k8s-helper apply my-app nginx:latest \
+  --replicas 3 \
+  --port 8080 \
+  --service-type LoadBalancer \
+  --env "ENV=production,DEBUG=false" \
+  --labels "app=my-app,version=v1.0" \
+  --init-container "migrate:migrate-tool:latest:migrate up" \
+  --init-env "DB_HOST=postgres,DB_PORT=5432" \
+  --secret "db-secret:/etc/db" \
+  --pvc "app-storage:/var/data" \
+  --wait \
+  --show-url
+```
+
 ## Real-World Examples
 
 ### 1. Simple Web Application

k8s_helper_cli-0.2.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+k8s_helper/__init__.py,sha256=7hcwl8Rhdl6fyIr3J2O8SCUXHfEujbuJ0rGVIiGRgAI,2666
+k8s_helper/cli.py,sha256=qcFNAfKska-Ouqr2ILoFoLxEyXPgoqaWvl4y64dMkCU,36366
+k8s_helper/config.py,sha256=P7YdfyvCHprrNs2J9DRb3RrClylfTTh5hfTtDzLug0A,6867
+k8s_helper/core.py,sha256=UK1fwFyZiWl8ajrNy7n5w6Lgo6b6T6DiZFH4BvRyQUY,44844
+k8s_helper/utils.py,sha256=wYgTd5ktyuI-EiVcfW7FrxA7MzXY5odrEKQgmMVdueY,9496
+k8s_helper_cli-0.2.1.dist-info/licenses/LICENSE,sha256=tXPvVl3gLVc6e0qCEoLH9KjeA7z4JVL78UybpvGtBCw,1096
+k8s_helper_cli-0.2.1.dist-info/METADATA,sha256=a7oedjwmqQ4-dEoDFR0k3R1BCTTDH_MmET2_zbgXG2w,26956
+k8s_helper_cli-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+k8s_helper_cli-0.2.1.dist-info/entry_points.txt,sha256=IoCMWUZ6mn90LwzQzEy5YkWOwvogDdZ6ycqUWAzCFTQ,50
+k8s_helper_cli-0.2.1.dist-info/top_level.txt,sha256=x9A1jflyer-z2cFnkqk5B42juoH2q0fy5hkT9upsTG8,11
+k8s_helper_cli-0.2.1.dist-info/RECORD,,

k8s_helper_cli-0.2.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-k8s_helper/__init__.py,sha256=Q2GcFYJIwXQ5EmkCG5Tm8NKEKU6e4pKvNsUD1PSZkxg,2666
-k8s_helper/cli.py,sha256=s7O2sxkdrrpVyZcqL9tEQg4gYytkmBSzESqiflx-Xc4,18722
-k8s_helper/config.py,sha256=P7YdfyvCHprrNs2J9DRb3RrClylfTTh5hfTtDzLug0A,6867
-k8s_helper/core.py,sha256=gCQkJSEQ3_ectExB9h1rFvI56Egysg50eVgYtpfquH0,21066
-k8s_helper/utils.py,sha256=wYgTd5ktyuI-EiVcfW7FrxA7MzXY5odrEKQgmMVdueY,9496
-k8s_helper_cli-0.2.0.dist-info/licenses/LICENSE,sha256=tXPvVl3gLVc6e0qCEoLH9KjeA7z4JVL78UybpvGtBCw,1096
-k8s_helper_cli-0.2.0.dist-info/METADATA,sha256=Q4WVmlwoAhp5IT1vgiOGOB-HHv1Xof3uwgpHQpapbUM,23379
-k8s_helper_cli-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-k8s_helper_cli-0.2.0.dist-info/entry_points.txt,sha256=IoCMWUZ6mn90LwzQzEy5YkWOwvogDdZ6ycqUWAzCFTQ,50
-k8s_helper_cli-0.2.0.dist-info/top_level.txt,sha256=x9A1jflyer-z2cFnkqk5B42juoH2q0fy5hkT9upsTG8,11
-k8s_helper_cli-0.2.0.dist-info/RECORD,,