Python SDK for AI agent monitoring, LLM cost tracking, benchmarking, and more. Integrates with most LLMs and agent frameworks including CrewAI, Agno, OpenAI Agents SDK, Langchain, Autogen, AG2, and CamelAI
Python agentagentopsagents-sdkaianthropicautogencost-estimationcrewaievalsevaluation-metricsgroqlangchainllmmistralollamaopenaiopenai-agents
import os
import subprocess
import click
from .backend import Pod
from . import DeploymentConfig, execute_serve
from .backend.event import EventStatus
from .environment import EKS_CLUSTER_NAME, AWS_REGION, AWS_PROFILE, KUBECONFIG_PATH, BUILDER_NAMESPACE, ALB_SHARED_GROUP_NAME
@click.group()
def cli():
"""Jockey - Kubernetes deployment management tool."""
pass
@cli.command()
@click.option('--namespace', default='default', help='Kubernetes namespace to list pods from')
def list_instances(namespace):
"""List all running pod instances in the namespace."""
try:
pods = Pod.filter(namespace=namespace)
if not pods:
click.echo(f"No running instances found in namespace '{namespace}'.")
return
click.echo(f"Found {len(pods)} running instance(s) in namespace '{namespace}':\n")
for pod in pods:
status = "●" if pod.ready else "○"
phase = pod.phase or "Unknown"
node = pod.node_name or "N/A"
click.echo(f"{status} {pod.name}")
click.echo(f" Phase: {phase}")
click.echo(f" Node: {node}")
click.echo(f" Restarts: {pod.restart_count}")
if pod.pod_ip:
click.echo(f" IP: {pod.pod_ip}")
click.echo()
except Exception as e:
click.echo(f"Error listing instances: {e}", err=True)
raise click.Abort()
@cli.command()
@click.option('--namespace', default='default', help='Kubernetes namespace')
@click.argument('pod_name')
def stop_pod(namespace, pod_name):
"""Stop (delete) a pod by name."""
try:
click.echo(f"🛑 Stopping pod '{pod_name}' in namespace '{namespace}'...")
success = Pod.delete_by_name(name=pod_name, namespace=namespace)
if success:
click.echo(f"✅ Pod '{pod_name}' deleted successfully!")
else:
click.echo(
f"❌ Failed to delete pod '{pod_name}' - it may not exist or you may not have permission."
)
raise click.Abort()
except Exception as e:
click.echo(f"❌ Error stopping pod: {e}", err=True)
raise click.Abort()
@cli.command()
@click.option('--namespace', default='default', help='Kubernetes namespace')
@click.argument('deployment_name')
def stop_deployment(namespace, deployment_name):
"""Stop (delete) a deployment by name."""
try:
from .backend.models.deployment import Deployment
click.echo(f"🛑 Stopping deployment '{deployment_name}' in namespace '{namespace}'...")
# Check if deployment exists first
deployment = Deployment.get(name=deployment_name, namespace=namespace)
if not deployment:
click.echo(f"❌ Deployment '{deployment_name}' not found in namespace '{namespace}'.")
raise click.Abort()
# Delete the deployment
success = Deployment.delete_by_name(name=deployment_name, namespace=namespace)
if success:
click.echo(f"✅ Deployment '{deployment_name}' deleted successfully!")
click.echo("💡 All pods managed by this deployment will be terminated.")
else:
click.echo(f"❌ Failed to delete deployment '{deployment_name}'.")
raise click.Abort()
except Exception as e:
click.echo(f"❌ Error stopping deployment: {e}", err=True)
raise click.Abort()
@cli.command()
def setup_kubeconfig():
"""Generate kubeconfig for EKS cluster using AWS CLI."""
try:
# Assert required environment variables are set
if not EKS_CLUSTER_NAME:
raise ValueError("EKS_CLUSTER_NAME")
if not AWS_REGION:
raise ValueError("AWS_REGION")
# Ensure config directory exists
os.makedirs(os.path.dirname(KUBECONFIG_PATH), exist_ok=True)
click.echo(f"Generating kubeconfig for cluster: {EKS_CLUSTER_NAME}")
click.echo(f"Region: {AWS_REGION}")
# Run aws eks update-kubeconfig command
cmd = [
'aws',
'eks',
'update-kubeconfig',
'--region',
AWS_REGION,
'--name',
EKS_CLUSTER_NAME,
'--kubeconfig',
KUBECONFIG_PATH,
]
if AWS_PROFILE:
cmd.extend(['--profile', AWS_PROFILE])
result = subprocess.run(cmd, capture_output=True, text=True)
if result.returncode == 0:
click.echo("✅ Kubeconfig generated successfully!")
click.echo(f"Config saved to: {KUBECONFIG_PATH}")
else:
click.echo("❌ Failed to generate kubeconfig:")
click.echo(result.stderr)
raise click.Abort()
except ValueError as e:
click.echo(f"❌ Missing required environment variable: {e}")
click.echo("Please ensure EKS_CLUSTER_NAME and AWS_REGION are set in your .env file")
raise click.Abort()
except FileNotFoundError:
click.echo("❌ awscli not found. Please install it first.")
raise click.Abort()
except Exception as e:
click.echo(f"❌ Error generating kubeconfig: {e}")
raise click.Abort()
@cli.command()
def setup_builder():
"""Setup builder namespace and create AWS credentials secret from local AWS CLI."""
try:
from .environment import KUBECONFIG_PATH, AWS_PROFILE
click.echo("🔧 Setting up builder namespace and AWS credentials...")
# Create builder namespace
cmd = ['kubectl', '--kubeconfig', KUBECONFIG_PATH, 'create', 'namespace', BUILDER_NAMESPACE]
result = subprocess.run(cmd, capture_output=True, text=True)
if result.returncode == 0:
click.echo("✅ Builder namespace created")
elif "already exists" in result.stderr:
click.echo("✅ Builder namespace already exists")
else:
click.echo(f"❌ Failed to create builder namespace: {result.stderr}")
raise click.Abort()
# Get AWS credentials from local AWS CLI
aws_cmd = ['aws', 'configure', 'get', 'aws_access_key_id']
if AWS_PROFILE:
aws_cmd.extend(['--profile', AWS_PROFILE])
access_key_result = subprocess.run(aws_cmd, capture_output=True, text=True)
if access_key_result.returncode != 0:
click.echo("❌ Failed to get AWS access key from local AWS CLI")
click.echo(" Please ensure AWS CLI is configured with 'aws configure'")
raise click.Abort()
aws_cmd = ['aws', 'configure', 'get', 'aws_secret_access_key']
if AWS_PROFILE:
aws_cmd.extend(['--profile', AWS_PROFILE])
secret_key_result = subprocess.run(aws_cmd, capture_output=True, text=True)
if secret_key_result.returncode != 0:
click.echo("❌ Failed to get AWS secret key from local AWS CLI")
click.echo(" Please ensure AWS CLI is configured with 'aws configure'")
raise click.Abort()
access_key = access_key_result.stdout.strip()
secret_key = secret_key_result.stdout.strip()
if not access_key or not secret_key:
click.echo("❌ AWS credentials are empty")
click.echo(" Please ensure AWS CLI is configured with 'aws configure'")
raise click.Abort()
# Delete existing secret if it exists
delete_cmd = ['kubectl', '--kubeconfig', KUBECONFIG_PATH, 'delete', 'secret', 'aws-credentials', '-n', BUILDER_NAMESPACE]
subprocess.run(delete_cmd, capture_output=True, text=True) # Ignore errors
# Create aws-credentials secret in builder namespace
secret_cmd = [
'kubectl', '--kubeconfig', KUBECONFIG_PATH, 'create', 'secret', 'generic', 'aws-credentials',
f'--from-literal=access-key={access_key}',
f'--from-literal=secret-key={secret_key}',
'--namespace', BUILDER_NAMESPACE
]
result = subprocess.run(secret_cmd, capture_output=True, text=True)
if result.returncode == 0:
click.echo("✅ AWS credentials secret created in builder namespace")
else:
click.echo(f"❌ Failed to create AWS credentials secret: {result.stderr}")
raise click.Abort()
click.echo("🎉 Builder namespace setup complete!")
click.echo(" • Builder namespace created")
click.echo(" • AWS credentials secret created from local AWS CLI")
except FileNotFoundError:
click.echo("❌ kubectl or aws CLI not found. Please install them first.")
raise click.Abort()
except Exception as e:
click.echo(f"❌ Error setting up builder namespace: {e}", err=True)
raise click.Abort()
@cli.command()
@click.option('--name', help='Name for the test image (defaults to configured repository)')
@click.option('--namespace', default='default', help='Kubernetes namespace for build context')
@click.option('--template', default='test', help='Docker template to use (test or python-agent)')
def test_build(name, namespace, template):
"""Test image build and push with streaming progress."""
try:
from .backend.models.image import Image
from .backend.event import EventStatus
from jockey.environment import IMAGE_REGISTRY, IMAGE_REPOSITORY
# Use default repository if no name provided
image_name = name or IMAGE_REPOSITORY
click.echo("🔨 Testing image build and push:")
click.echo(f" Name: {image_name}")
click.echo(f" Namespace: {namespace}")
click.echo(f" Template: {template}")
click.echo(" Builder: Kaniko in-cluster")
click.echo(f" Registry: {IMAGE_REGISTRY}")
click.echo()
image = Image(
name=image_name,
tag='test',
namespace=namespace,
dockerfile_template=template,
)
click.echo("🔨 Building and pushing image...")
for event in image.build():
if event.status == EventStatus.STARTED:
click.echo(f" Started building {image.image_name}")
elif event.status == EventStatus.PROGRESS and event.message:
# Show build steps but filter out excessive output
message = event.message.strip()
if message and not message.startswith(' ---'):
click.echo(f" {message}")
elif event.status == EventStatus.COMPLETED:
click.echo(f"✅ Build completed: {image.image_name}")
click.echo(f"✅ Image pushed to registry: {image.url}")
click.echo("💡 Image available for deployments in cluster!")
return
elif event.status == EventStatus.ERROR:
click.echo(f"❌ Build failed: {event.message}")
raise click.Abort()
except Exception as e:
click.echo(f"❌ Error during build test: {e}", err=True)
raise click.Abort()
@cli.command()
@click.option('--namespace', default=BUILDER_NAMESPACE, help=f'Kubernetes namespace (defaults to {BUILDER_NAMESPACE})')
@click.option('--follow', '-f', is_flag=True, help='Follow/stream logs in real-time')
def logs_builder(namespace, follow):
"""Show logs from the most recent builder pod."""
try:
# Search only in the builder namespace (or specified namespace)
pods = Pod.filter(namespace=namespace, label_selector="job-name")
builder_pods = [p for p in pods if p.name.startswith('builder-')]
if not builder_pods:
click.echo(f"No builder pods found in namespace '{namespace}'.")
return
# Sort by creation time (most recent first)
builder_pods.sort(key=lambda p: p.creation_timestamp or "", reverse=True)
latest_builder = builder_pods[0]
click.echo(f"📋 Showing logs for builder pod: {latest_builder.name}")
click.echo(f" Namespace: {latest_builder.namespace}")
click.echo(f" Phase: {latest_builder.phase}")
click.echo(f" Created: {latest_builder.creation_timestamp}")
click.echo()
# Use kubectl to follow logs
import subprocess
from .environment import KUBECONFIG_PATH
cmd = ['kubectl', '--kubeconfig', KUBECONFIG_PATH, 'logs', latest_builder.name, '-n', latest_builder.namespace]
if follow:
cmd.append('--follow')
# Stream logs directly to terminal
process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
try:
for line in process.stdout:
click.echo(line.rstrip())
except KeyboardInterrupt:
process.terminate()
click.echo("\n🛑 Log streaming stopped.")
process.wait()
except Exception as e:
click.echo(f"❌ Error getting builder logs: {e}", err=True)
raise click.Abort()
@cli.command()
@click.option('--name', help='Name for the test application (defaults to configured repository)')
@click.option('--namespace', default='default', help='Kubernetes namespace')
@click.option('--template', default='test', help='Docker template to use (test, simple-api, or python-agent)')
def deploy_test(name, namespace, template):
"""Deploy a minimal test application with health checks."""
from jockey.environment import IMAGE_REGISTRY, IMAGE_REPOSITORY
# Use default repository if no name provided
click.echo(f"🚀 Starting test deployment: {name or IMAGE_REPOSITORY}")
click.echo(f" Namespace: {namespace}")
click.echo(f" Template: {template}")
click.echo(f" Registry: {IMAGE_REGISTRY}")
click.echo()
# Create deployment config without repository
config = DeploymentConfig(
namespace=namespace,
tag='test',
dockerfile_template=template,
ports=[8080], # Simple API runs on port 8080
)
# Deploy with progress events and capture the return value
generator = execute_serve(config)
deployment = None
try:
for event in generator:
if hasattr(event, 'event_type'):
if event.event_type == 'build':
if event.status == EventStatus.STARTED:
click.echo("🔨 Building Docker image...")
elif event.status == EventStatus.PROGRESS and event.message:
click.echo(f" {event.message.strip()}")
elif event.status == EventStatus.COMPLETED:
click.echo(f"✅ Build completed: {name or IMAGE_REPOSITORY}:test")
elif event.status == EventStatus.ERROR:
click.echo(f"❌ Build failed: {event.message}")
raise click.Abort()
elif event.event_type == 'push':
if event.status == EventStatus.STARTED:
click.echo("📤 Pushing to registry...")
elif event.status == EventStatus.PROGRESS and event.message:
# Only show important push messages
if 'digest:' in event.message or 'Pushed' in event.message:
click.echo(f" {event.message}")
elif event.status == EventStatus.COMPLETED:
click.echo(f"✅ Push completed: {event.image_url}")
elif event.status == EventStatus.ERROR:
click.echo(f"❌ Push failed: {event.message}")
raise click.Abort()
elif event.event_type == 'deployment':
if event.status == EventStatus.STARTED:
click.echo("🚀 Deploying to Kubernetes...")
elif event.status == EventStatus.PROGRESS:
click.echo(f" {event.message}")
elif event.status == EventStatus.COMPLETED:
click.echo(f"✅ Deployment ready: {event.message}")
elif event.status == EventStatus.ERROR:
click.echo(f"❌ Deployment failed: {event.message}")
raise click.Abort()
except StopIteration as e:
# Capture the return value from the generator
deployment = e.value
if deployment:
click.echo("\n🎉 Test deployment successful!")
click.echo(f" Name: {deployment.name}")
click.echo(f" Image: {deployment.image_url}")
click.echo(f" Namespace: {deployment.namespace}")
click.echo("\n💡 Use 'jockey list-instances' to check status")
else:
click.echo("⚠️ Deployment completed but no final deployment object returned")
@cli.command()
@click.option('--namespace', default='default', help='Kubernetes namespace to search')
def list_alb_ingresses(namespace):
"""List all ingresses using the shared ALB."""
try:
from .backend.models.service import Ingress
click.echo(f"🔍 Searching for ingresses using shared ALB: {ALB_SHARED_GROUP_NAME}")
click.echo(f" Namespace: {namespace}")
click.echo()
ingresses = Ingress.filter(namespace=namespace)
shared_alb_ingresses = []
for ingress in ingresses:
annotations = ingress.data.metadata.annotations or {}
group_name = annotations.get('alb.ingress.kubernetes.io/group.name', '')
if group_name == ALB_SHARED_GROUP_NAME:
shared_alb_ingresses.append(ingress)
if not shared_alb_ingresses:
click.echo(f"No ingresses found using shared ALB group: {ALB_SHARED_GROUP_NAME}")
return
click.echo(f"Found {len(shared_alb_ingresses)} ingress(es) using shared ALB:")
click.echo()
for ingress in shared_alb_ingresses:
annotations = ingress.data.metadata.annotations or {}
hostname = ingress.hostname or "N/A"
alb_hostname = ingress.load_balancer_hostname or "Pending"
tags = annotations.get('alb.ingress.kubernetes.io/tags', 'N/A')
click.echo(f"📋 {ingress.name}")
click.echo(f" Hostname: {hostname}")
click.echo(f" ALB Hostname: {alb_hostname}")
click.echo(f" Tags: {tags}")
click.echo(f" Namespace: {ingress.namespace}")
click.echo()
except Exception as e:
click.echo(f"❌ Error listing ALB ingresses: {e}", err=True)
raise click.Abort()
@cli.command()
def alb_status():
"""Check the status of the shared ALB configuration."""
try:
from .backend.models.service import Ingress
click.echo(f"🔍 Checking shared ALB status: {ALB_SHARED_GROUP_NAME}")
click.echo()
# Get all ingresses across all namespaces
all_ingresses = []
namespaces = ['default', 'kube-system', 'agentops-deploy'] # Common namespaces
for namespace in namespaces:
try:
ingresses = Ingress.filter(namespace=namespace)
all_ingresses.extend(ingresses)
except:
continue # Skip if namespace doesn't exist or no access
shared_alb_ingresses = []
for ingress in all_ingresses:
annotations = ingress.data.metadata.annotations or {}
group_name = annotations.get('alb.ingress.kubernetes.io/group.name', '')
if group_name == ALB_SHARED_GROUP_NAME:
shared_alb_ingresses.append(ingress)
if not shared_alb_ingresses:
click.echo(f"⚠️ No ingresses found using shared ALB group: {ALB_SHARED_GROUP_NAME}")
click.echo(" This means the shared ALB is not yet provisioned.")
return
# Check ALB status
alb_hostnames = set()
ready_count = 0
for ingress in shared_alb_ingresses:
alb_hostname = ingress.load_balancer_hostname
if alb_hostname:
alb_hostnames.add(alb_hostname)
ready_count += 1
click.echo(f"✅ Shared ALB Status:")
click.echo(f" Group Name: {ALB_SHARED_GROUP_NAME}")
click.echo(f" Total Ingresses: {len(shared_alb_ingresses)}")
click.echo(f" Ready Ingresses: {ready_count}")
click.echo(f" ALB Hostnames: {len(alb_hostnames)}")
if alb_hostnames:
click.echo(" ALB Endpoints:")
for hostname in alb_hostnames:
click.echo(f" - {hostname}")
# Show ingresses by namespace
namespace_counts = {}
for ingress in shared_alb_ingresses:
ns = ingress.namespace
namespace_counts[ns] = namespace_counts.get(ns, 0) + 1
click.echo(" Ingresses by namespace:")
for ns, count in namespace_counts.items():
click.echo(f" - {ns}: {count}")
except Exception as e:
click.echo(f"❌ Error checking ALB status: {e}", err=True)
raise click.Abort()
@cli.command()
@click.option('--namespace', default='default', help='Kubernetes namespace')
@click.argument('hostname')
def validate_alb_routing(namespace, hostname):
"""Validate that ALB routing is configured correctly for a hostname."""
try:
from .backend.models.service import Ingress
click.echo(f"🔍 Validating ALB routing for hostname: {hostname}")
click.echo(f" Namespace: {namespace}")
click.echo(f" Shared ALB Group: {ALB_SHARED_GROUP_NAME}")
click.echo()
ingresses = Ingress.filter(namespace=namespace)
matching_ingresses = []
for ingress in ingresses:
if ingress.hostname == hostname:
matching_ingresses.append(ingress)
if not matching_ingresses:
click.echo(f"❌ No ingresses found for hostname: {hostname}")
return
ingress = matching_ingresses[0]
annotations = ingress.data.metadata.annotations or {}
# Check ALB configuration
group_name = annotations.get('alb.ingress.kubernetes.io/group.name', '')
scheme = annotations.get('alb.ingress.kubernetes.io/scheme', '')
target_type = annotations.get('alb.ingress.kubernetes.io/target-type', '')
tags = annotations.get('alb.ingress.kubernetes.io/tags', '')
click.echo(f"✅ Ingress Configuration:")
click.echo(f" Name: {ingress.name}")
click.echo(f" Hostname: {ingress.hostname}")
click.echo(f" ALB Group: {group_name}")
click.echo(f" Scheme: {scheme}")
click.echo(f" Target Type: {target_type}")
click.echo(f" Tags: {tags}")
click.echo(f" ALB Hostname: {ingress.load_balancer_hostname or 'Pending'}")
# Validation checks
issues = []
if group_name != ALB_SHARED_GROUP_NAME:
issues.append(f"Group name mismatch: expected {ALB_SHARED_GROUP_NAME}, got {group_name}")
if scheme != 'internet-facing':
issues.append(f"Scheme should be 'internet-facing', got '{scheme}'")
if target_type != 'ip':
issues.append(f"Target type should be 'ip', got '{target_type}'")
if not tags:
issues.append("No ALB tags configured")
if issues:
click.echo()
click.echo("⚠️ Configuration Issues:")
for issue in issues:
click.echo(f" - {issue}")
else:
click.echo()
click.echo("✅ All validations passed!")
except Exception as e:
click.echo(f"❌ Error validating ALB routing: {e}", err=True)
raise click.Abort()
if __name__ == "__main__":
cli()