k8s-helper-cli 0.3.0__py3-none-any.whl → 0.4.1__py3-none-any.whl

k8s_helper/__init__.py

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

k8s_helper/cli.py

@@ -10,6 +10,7 @@ from rich.panel import Panel
 from rich.text import Text
 import time
 import time
+from kubernetes.client.rest import ApiException
 
 from .core import K8sClient
 from .config import get_config
@@ -1348,3 +1349,505 @@ def service_url(
             console.print("\n👋 Stopped watching")
     else:
         show_service_url()
+
+
+# ======================
+# MONITORING COMMANDS
+# ======================
+@app.command()
+def setup_monitoring(
+    namespace: str = typer.Option("monitoring", "--namespace", "-n", help="Namespace for monitoring stack"),
+    grafana_service_type: str = typer.Option("NodePort", "--service-type", "-t", help="Grafana service type: NodePort, LoadBalancer, ClusterIP"),
+    import_dashboard: bool = typer.Option(True, "--import-dashboard/--no-dashboard", help="Import default Kubernetes dashboard"),
+    wait: bool = typer.Option(True, "--wait/--no-wait", help="Wait for deployments to be ready"),
+    show_info: bool = typer.Option(True, "--show-info/--no-show-info", help="Show monitoring stack information after setup")
+):
+    """Deploy complete monitoring stack with Prometheus and Grafana"""
+    
+    # Validate service type
+    valid_service_types = ["NodePort", "LoadBalancer", "ClusterIP"]
+    if grafana_service_type not in valid_service_types:
+        console.print(f"❌ Invalid service type: {grafana_service_type}")
+        console.print(f"💡 Valid options: {', '.join(valid_service_types)}")
+        return
+    
+    console.print(f"🚀 Setting up monitoring stack in namespace: {namespace}")
+    console.print(f"🔧 Grafana service type: {grafana_service_type}")
+    
+    if import_dashboard:
+        console.print("📊 Will import default Kubernetes dashboard")
+    
+    # Show what will be deployed
+    console.print("\n📋 Components to deploy:")
+    console.print("   • Prometheus server with cluster monitoring configuration")
+    console.print("   • Grafana with admin credentials (admin/admin123)")
+    console.print("   • ServiceAccount and RBAC for Prometheus")
+    console.print("   • ConfigMaps for Prometheus configuration")
+    if import_dashboard:
+        console.print("   • Default Kubernetes metrics dashboard")
+    
+    try:
+        client = K8sClient()
+        
+        with console.status("Deploying monitoring stack..."):
+            result = client.setup_monitoring(
+                namespace=namespace,
+                grafana_service_type=grafana_service_type,
+                import_dashboard=import_dashboard,
+                wait_for_ready=wait
+            )
+        
+        if result['success']:
+            console.print("✅ Monitoring stack deployed successfully!")
+            
+            # Show deployment summary
+            console.print(f"\n📋 Deployment Summary:")
+            console.print(f"📍 Namespace: {result['namespace']}")
+            
+            if result['prometheus']['deployed']:
+                console.print("✅ Prometheus: Deployed")
+            else:
+                console.print("❌ Prometheus: Failed to deploy")
+            
+            if result['grafana']['deployed']:
+                console.print("✅ Grafana: Deployed")
+                console.print(f"🔑 Admin credentials: {result['grafana']['admin_user']}/{result['grafana']['admin_password']}")
+            else:
+                console.print("❌ Grafana: Failed to deploy")
+            
+            if show_info:
+                # Get and display monitoring information
+                with console.status("Retrieving monitoring stack information..."):
+                    time.sleep(2)  # Give services time to be ready
+                    info = client.get_monitoring_info(namespace)
+                
+                console.print(f"\n🔗 Monitoring Stack Information:")
+                
+                # Prometheus info
+                if info['prometheus']['running']:
+                    console.print(f"✅ Prometheus: Running")
+                    if info['prometheus']['url']:
+                        console.print(f"🔗 Prometheus URL: [blue]{info['prometheus']['url']}[/blue]")
+                    else:
+                        console.print(f"💡 Prometheus: Access via port-forward: kubectl port-forward -n {namespace} svc/prometheus-service 9090:9090")
+                else:
+                    console.print(f"⏳ Prometheus: Starting up...")
+                
+                # Grafana info
+                if info['grafana']['running']:
+                    console.print(f"✅ Grafana: Running")
+                    if info['grafana']['url']:
+                        console.print(f"🔗 Grafana URL: [blue]{info['grafana']['url']}[/blue]")
+                    else:
+                        console.print(f"💡 Grafana: Access via port-forward: kubectl port-forward -n {namespace} svc/grafana-service 3000:3000")
+                    
+                    if info['grafana']['credentials']:
+                        creds = info['grafana']['credentials']
+                        console.print(f"🔑 Login: [green]{creds['username']}[/green] / [green]{creds['password']}[/green]")
+                else:
+                    console.print(f"⏳ Grafana: Starting up...")
+                
+                # Show services
+                console.print(f"\n📋 Services:")
+                for service in info['services']:
+                    console.print(f"   • {service['name']} ({service['type']}) - IP: {service['cluster_ip']}")
+                    for port in service['ports']:
+                        port_info = f"     Port: {port['port']} → {port['target_port']}"
+                        if 'node_port' in port:
+                            port_info += f" (NodePort: {port['node_port']})"
+                        console.print(port_info)
+            
+            # Show next steps
+            console.print(f"\n🚀 Next Steps:")
+            console.print(f"   1. Access Grafana with the provided URL and credentials")
+            console.print(f"   2. Verify Prometheus data source is configured")
+            console.print(f"   3. Explore the imported Kubernetes dashboard")
+            console.print(f"   4. Create custom dashboards and alerts as needed")
+            console.print(f"\n💡 Useful commands:")
+            console.print(f"   • Check status: k8s-helper monitoring-status -n {namespace}")
+            console.print(f"   • Port-forward Grafana: kubectl port-forward -n {namespace} svc/grafana-service 3000:3000")
+            console.print(f"   • Port-forward Prometheus: kubectl port-forward -n {namespace} svc/prometheus-service 9090:9090")
+            
+        else:
+            console.print(f"❌ Failed to deploy monitoring stack: {result.get('error', 'Unknown error')}")
+            
+            # Show partial deployment info
+            if result['prometheus']['deployed']:
+                console.print("✅ Prometheus was deployed successfully")
+            if result['grafana']['deployed']:
+                console.print("✅ Grafana was deployed successfully")
+            
+            console.print("\n🛠️  Troubleshooting:")
+            console.print("   • Check cluster connectivity: kubectl get nodes")
+            console.print("   • Verify namespace permissions")
+            console.print("   • Check resource availability in the cluster")
+            console.print(f"   • View monitoring namespace: kubectl get all -n {namespace}")
+    
+    except Exception as e:
+        console.print(f"❌ Error setting up monitoring: {e}")
+        console.print("\n🛠️  Troubleshooting:")
+        console.print("   • Ensure kubectl is configured and cluster is accessible")
+        console.print("   • Check if you have sufficient permissions to create resources")
+        console.print("   • Verify the cluster has enough resources available")
+
+
+@app.command()
+def monitoring_status(
+    namespace: str = typer.Option("monitoring", "--namespace", "-n", help="Monitoring namespace"),
+    output: str = output_option
+):
+    """Show status of monitoring stack"""
+    try:
+        client = K8sClient()
+        
+        with console.status("Checking monitoring stack status..."):
+            info = client.get_monitoring_info(namespace)
+        
+        if 'error' in info:
+            console.print(f"❌ Error getting monitoring status: {info['error']}")
+            return
+        
+        if output == "table":
+            # Overview table
+            table = Table(title=f"Monitoring Stack Status - {namespace}")
+            table.add_column("Component", style="cyan")
+            table.add_column("Status", style="green")
+            table.add_column("URL", style="blue")
+            
+            # Prometheus row
+            prometheus_status = "🟢 Running" if info['prometheus']['running'] else "🔴 Not Running"
+            prometheus_url = info['prometheus']['url'] or "Port-forward required"
+            table.add_row("Prometheus", prometheus_status, prometheus_url)
+            
+            # Grafana row
+            grafana_status = "🟢 Running" if info['grafana']['running'] else "🔴 Not Running"
+            grafana_url = info['grafana']['url'] or "Port-forward required"
+            table.add_row("Grafana", grafana_status, grafana_url)
+            
+            console.print(table)
+            
+            # Credentials info
+            if info['grafana']['credentials']:
+                creds = info['grafana']['credentials']
+                console.print(f"\n🔑 Grafana Credentials:")
+                console.print(f"   Username: [green]{creds['username']}[/green]")
+                console.print(f"   Password: [green]{creds['password']}[/green]")
+            
+            # Services table
+            if info['services']:
+                services_table = Table(title="Services")
+                services_table.add_column("Name", style="cyan")
+                services_table.add_column("Type", style="magenta")
+                services_table.add_column("Cluster IP", style="yellow")
+                services_table.add_column("Ports", style="green")
+                
+                for service in info['services']:
+                    ports_str = ", ".join([
+                        f"{port['port']}:{port['target_port']}" + 
+                        (f" (NodePort: {port['node_port']})" if 'node_port' in port else "")
+                        for port in service['ports']
+                    ])
+                    services_table.add_row(
+                        service['name'],
+                        service['type'],
+                        service['cluster_ip'],
+                        ports_str
+                    )
+                
+                console.print(services_table)
+        
+        elif output == "json":
+            console.print(format_json_output(info))
+        elif output == "yaml":
+            console.print(format_yaml_output(info))
+    
+    except Exception as e:
+        console.print(f"❌ Error checking monitoring status: {e}")
+
+
+@app.command()
+def delete_monitoring(
+    namespace: str = typer.Option("monitoring", "--namespace", "-n", help="Monitoring namespace"),
+    force: bool = typer.Option(False, "--force", help="Skip confirmation prompt")
+):
+    """Delete monitoring stack"""
+    if not force:
+        if not typer.confirm(f"Are you sure you want to delete the monitoring stack in namespace '{namespace}'?"):
+            console.print("❌ Operation cancelled")
+            return
+    
+    try:
+        client = K8sClient()
+        
+        console.print(f"🗑️  Deleting monitoring stack from namespace: {namespace}")
+        
+        # Delete deployments
+        deployments_to_delete = ["prometheus", "grafana"]
+        for deployment in deployments_to_delete:
+            try:
+                with console.status(f"Deleting deployment {deployment}..."):
+                    client.apps_v1.delete_namespaced_deployment(name=deployment, namespace=namespace)
+                console.print(f"✅ Deleted deployment: {deployment}")
+            except ApiException as e:
+                if e.status == 404:
+                    console.print(f"⚠️  Deployment {deployment} not found")
+                else:
+                    console.print(f"❌ Error deleting deployment {deployment}: {e}")
+        
+        # Delete services
+        services_to_delete = ["prometheus-service", "grafana-service"]
+        for service in services_to_delete:
+            try:
+                with console.status(f"Deleting service {service}..."):
+                    client.core_v1.delete_namespaced_service(name=service, namespace=namespace)
+                console.print(f"✅ Deleted service: {service}")
+            except ApiException as e:
+                if e.status == 404:
+                    console.print(f"⚠️  Service {service} not found")
+                else:
+                    console.print(f"❌ Error deleting service {service}: {e}")
+        
+        # Delete ConfigMaps
+        configmaps_to_delete = ["prometheus-config"]
+        for configmap in configmaps_to_delete:
+            try:
+                with console.status(f"Deleting configmap {configmap}..."):
+                    client.core_v1.delete_namespaced_config_map(name=configmap, namespace=namespace)
+                console.print(f"✅ Deleted configmap: {configmap}")
+            except ApiException as e:
+                if e.status == 404:
+                    console.print(f"⚠️  ConfigMap {configmap} not found")
+                else:
+                    console.print(f"❌ Error deleting configmap {configmap}: {e}")
+        
+        # Delete ServiceAccount
+        try:
+            with console.status("Deleting ServiceAccount prometheus..."):
+                client.core_v1.delete_namespaced_service_account(name="prometheus", namespace=namespace)
+            console.print("✅ Deleted ServiceAccount: prometheus")
+        except ApiException as e:
+            if e.status == 404:
+                console.print("⚠️  ServiceAccount prometheus not found")
+            else:
+                console.print(f"❌ Error deleting ServiceAccount: {e}")
+        
+        # Delete RBAC resources
+        try:
+            from kubernetes import client as k8s_client
+            rbac_v1 = k8s_client.RbacAuthorizationV1Api()
+            with console.status("Deleting RBAC resources..."):
+                rbac_v1.delete_cluster_role(name="prometheus")
+                rbac_v1.delete_cluster_role_binding(name="prometheus")
+            console.print("✅ Deleted RBAC resources")
+        except ApiException as e:
+            if e.status == 404:
+                console.print("⚠️  RBAC resources not found")
+            else:
+                console.print(f"❌ Error deleting RBAC resources: {e}")
+        
+        console.print(f"✅ Monitoring stack cleanup completed for namespace: {namespace}")
+        console.print(f"💡 To delete the namespace entirely: kubectl delete namespace {namespace}")
+    
+    except Exception as e:
+        console.print(f"❌ Error deleting monitoring stack: {e}")
+        console.print("💡 You may need to clean up resources manually with kubectl")
+
+
+@app.command()
+def add_prometheus_target(
+    job_name: str = typer.Argument(..., help="Name for the Prometheus job"),
+    targets: str = typer.Argument(..., help="Comma-separated list of targets (e.g., 'service:port,1.2.3.4:9090')"),
+    namespace: str = typer.Option("monitoring", "--namespace", "-n", help="Monitoring namespace"),
+    metrics_path: str = typer.Option("/metrics", "--metrics-path", "-p", help="Path to metrics endpoint"),
+    scrape_interval: str = typer.Option("15s", "--scrape-interval", "-i", help="Scrape interval (e.g., 15s, 30s, 1m)")
+):
+    """Add a new target to Prometheus monitoring"""
+    if not validate_name(job_name):
+        console.print(f"❌ Invalid job name: {job_name}")
+        return
+    
+    # Parse targets
+    target_list = [target.strip() for target in targets.split(",") if target.strip()]
+    
+    if not target_list:
+        console.print("❌ No valid targets provided")
+        return
+    
+    console.print(f"🎯 Adding Prometheus target job: {job_name}")
+    console.print(f"📋 Targets: {target_list}")
+    console.print(f"📍 Namespace: {namespace}")
+    console.print(f"🛣️  Metrics path: {metrics_path}")
+    console.print(f"⏱️  Scrape interval: {scrape_interval}")
+    
+    try:
+        client = K8sClient()
+        
+        with console.status("Adding Prometheus target..."):
+            success = client.add_prometheus_target(
+                job_name=job_name,
+                targets=target_list,
+                namespace=namespace,
+                metrics_path=metrics_path,
+                scrape_interval=scrape_interval
+            )
+        
+        if success:
+            console.print(f"✅ Successfully added Prometheus target job '{job_name}'")
+            console.print(f"🔄 Prometheus configuration updated and deployment restarted")
+            console.print(f"\n💡 Next steps:")
+            console.print(f"   • Check targets in Prometheus UI: Status > Targets")
+            console.print(f"   • Verify metrics are being scraped")
+            console.print(f"   • Create Grafana dashboards for the new metrics")
+        else:
+            console.print(f"❌ Failed to add Prometheus target")
+    
+    except Exception as e:
+        console.print(f"❌ Error adding Prometheus target: {e}")
+
+
+@app.command()
+def remove_prometheus_target(
+    job_name: str = typer.Argument(..., help="Name of the Prometheus job to remove"),
+    namespace: str = typer.Option("monitoring", "--namespace", "-n", help="Monitoring namespace"),
+    force: bool = typer.Option(False, "--force", help="Skip confirmation prompt")
+):
+    """Remove a target from Prometheus monitoring"""
+    if not force:
+        if not typer.confirm(f"Are you sure you want to remove Prometheus job '{job_name}'?"):
+            console.print("❌ Operation cancelled")
+            return
+    
+    console.print(f"🗑️  Removing Prometheus target job: {job_name}")
+    console.print(f"📍 Namespace: {namespace}")
+    
+    try:
+        client = K8sClient()
+        
+        with console.status("Removing Prometheus target..."):
+            success = client.remove_prometheus_target(
+                job_name=job_name,
+                namespace=namespace
+            )
+        
+        if success:
+            console.print(f"✅ Successfully removed Prometheus target job '{job_name}'")
+            console.print(f"🔄 Prometheus configuration updated and deployment restarted")
+        else:
+            console.print(f"❌ Failed to remove Prometheus target")
+    
+    except Exception as e:
+        console.print(f"❌ Error removing Prometheus target: {e}")
+
+
+@app.command()
+def list_prometheus_targets(
+    namespace: str = typer.Option("monitoring", "--namespace", "-n", help="Monitoring namespace"),
+    output: str = output_option
+):
+    """List all Prometheus monitoring targets"""
+    try:
+        client = K8sClient()
+        
+        with console.status("Fetching Prometheus targets..."):
+            result = client.list_prometheus_targets(namespace)
+        
+        if 'error' in result:
+            console.print(f"❌ Error getting Prometheus targets: {result['error']}")
+            return
+        
+        targets = result.get('targets', [])
+        
+        if not targets:
+            console.print(f"📋 No Prometheus targets found in namespace: {namespace}")
+            console.print(f"💡 Add targets with: k8s-helper add-prometheus-target <job-name> <targets>")
+            return
+        
+        if output == "table":
+            table = Table(title=f"Prometheus Targets - {namespace}")
+            table.add_column("Job Name", style="cyan")
+            table.add_column("Type", style="magenta")
+            table.add_column("Targets", style="green")
+            table.add_column("Metrics Path", style="blue")
+            table.add_column("Scrape Interval", style="yellow")
+            
+            for target in targets:
+                job_type = target.get('type', 'static')
+                job_type_display = "🔄 Kubernetes" if job_type == 'kubernetes_discovery' else "📍 Static"
+                
+                targets_display = ", ".join(target.get('targets', []))
+                if len(targets_display) > 50:
+                    targets_display = targets_display[:47] + "..."
+                
+                table.add_row(
+                    target.get('job_name', 'unknown'),
+                    job_type_display,
+                    targets_display,
+                    target.get('metrics_path', '/metrics'),
+                    target.get('scrape_interval', 'default')
+                )
+            
+            console.print(table)
+            console.print(f"\n📊 Total jobs: {result.get('total_jobs', 0)}")
+        
+        elif output == "json":
+            console.print(format_json_output(result))
+        elif output == "yaml":
+            console.print(format_yaml_output(result))
+    
+    except Exception as e:
+        console.print(f"❌ Error listing Prometheus targets: {e}")
+
+
+@app.command()
+def update_prometheus_target(
+    job_name: str = typer.Argument(..., help="Name of the Prometheus job to update"),
+    targets: str = typer.Argument(..., help="New comma-separated list of targets"),
+    namespace: str = typer.Option("monitoring", "--namespace", "-n", help="Monitoring namespace"),
+    metrics_path: Optional[str] = typer.Option(None, "--metrics-path", "-p", help="New metrics path"),
+    scrape_interval: Optional[str] = typer.Option(None, "--scrape-interval", "-i", help="New scrape interval")
+):
+    """Update an existing Prometheus target"""
+    if not validate_name(job_name):
+        console.print(f"❌ Invalid job name: {job_name}")
+        return
+    
+    # Parse targets
+    target_list = [target.strip() for target in targets.split(",") if target.strip()]
+    
+    if not target_list:
+        console.print("❌ No valid targets provided")
+        return
+    
+    console.print(f"🔄 Updating Prometheus target job: {job_name}")
+    console.print(f"📋 New targets: {target_list}")
+    console.print(f"📍 Namespace: {namespace}")
+    
+    if metrics_path:
+        console.print(f"🛣️  New metrics path: {metrics_path}")
+    if scrape_interval:
+        console.print(f"⏱️  New scrape interval: {scrape_interval}")
+    
+    try:
+        client = K8sClient()
+        
+        with console.status("Updating Prometheus target..."):
+            success = client.update_prometheus_target(
+                job_name=job_name,
+                targets=target_list,
+                namespace=namespace,
+                metrics_path=metrics_path,
+                scrape_interval=scrape_interval
+            )
+        
+        if success:
+            console.print(f"✅ Successfully updated Prometheus target job '{job_name}'")
+            console.print(f"🔄 Prometheus configuration updated and deployment restarted")
+        else:
+            console.print(f"❌ Failed to update Prometheus target")
+    
+    except Exception as e:
+        console.print(f"❌ Error updating Prometheus target: {e}")
+
+
+if __name__ == "__main__":
+    app()