🚀 Kubernetes: Container Orchestration

🎯 Introduction

Welcome to the exciting world of Kubernetes container orchestration with TypeScript! 🎉 In this guide, we’ll explore how to harness the power of Kubernetes to manage your containerized applications at scale.

You’ll discover how Kubernetes can transform your TypeScript application deployment experience. Whether you’re building microservices 🏗️, managing application scaling 📈, or orchestrating complex workflows 🔄, understanding Kubernetes with TypeScript is essential for modern cloud-native development.

By the end of this tutorial, you’ll feel confident building TypeScript applications that interact with Kubernetes clusters! Let’s dive in! 🏊‍♂️

📚 Understanding Kubernetes

🤔 What is Kubernetes?

Kubernetes is like having a super-smart conductor for your application orchestra! 🎼 Think of it as an automated stage manager that knows exactly when to bring in more musicians (containers), when to replace tired ones, and how to keep the whole performance running smoothly.

In TypeScript terms, Kubernetes provides a powerful API that you can interact with programmatically 🔧. This means you can:

✨ Deploy applications automatically
🚀 Scale services based on demand
🛡️ Ensure high availability and fault tolerance
🔄 Manage rolling updates seamlessly

💡 Why Use Kubernetes with TypeScript?

Here’s why developers love this combination:

Type Safety 🔒: TypeScript client ensures API interactions are type-safe
Better IDE Support 💻: Autocomplete for Kubernetes resources
Infrastructure as Code 📖: Define deployments in strongly-typed code
Automation Power 🔧: Build custom operators and controllers

Real-world example: Imagine deploying a microservices shopping platform 🛒. With Kubernetes and TypeScript, you can automatically scale your payment service during peak shopping hours while keeping everything type-safe!

🔧 Basic Syntax and Usage

📝 Setting Up the Kubernetes Client

Let’s start with installing the official Kubernetes client:

# 📦 Install the Kubernetes JavaScript client
pnpm add @kubernetes/client-node
pnpm add -D @types/node

// 👋 Hello, Kubernetes with TypeScript!
import * as k8s from '@kubernetes/client-node';

// 🎨 Create a Kubernetes configuration
const kc = new k8s.KubeConfig();
kc.loadFromDefault(); // 🏠 Load from ~/.kube/config

// 🚀 Create API clients
const k8sApi = kc.makeApiClient(k8s.CoreV1Api);
const appsApi = kc.makeApiClient(k8s.AppsV1Api);

console.log('🎉 Kubernetes client ready!');

💡 Explanation: The KubeConfig loads your cluster credentials, and we create typed API clients for different Kubernetes resources!

🎯 Common Kubernetes Operations

Here are patterns you’ll use daily:

// 🏗️ Pattern 1: Listing pods
const listPods = async (): Promise<void> => {
  try {
    const response = await k8sApi.listNamespacedPod('default');
    console.log('🏃‍♂️ Active pods:');
    response.body.items.forEach(pod => {
      console.log(`  🐳 ${pod.metadata?.name}: ${pod.status?.phase}`);
    });
  } catch (error) {
    console.error('❌ Error listing pods:', error);
  }
};

// 🎨 Pattern 2: Creating a service
const createService = async (name: string, port: number): Promise<void> => {
  const service: k8s.V1Service = {
    metadata: {
      name: name,
      labels: { app: name, emoji: '🚀' }
    },
    spec: {
      selector: { app: name },
      ports: [{
        protocol: 'TCP',
        port: port,
        targetPort: port
      }],
      type: 'ClusterIP'
    }
  };

  try {
    await k8sApi.createNamespacedService('default', service);
    console.log(`✅ Service ${name} created on port ${port}!`);
  } catch (error) {
    console.error('❌ Error creating service:', error);
  }
};

// 🔄 Pattern 3: Watching for changes
const watchPods = (): void => {
  const watch = new k8s.Watch(kc);
  watch.watch('/api/v1/namespaces/default/pods',
    {},
    (type, apiObj) => {
      const pod = apiObj as k8s.V1Pod;
      console.log(`🔍 Pod ${pod.metadata?.name} was ${type.toLowerCase()}`);
    },
    (err) => {
      console.error('⚠️ Watch error:', err);
    }
  );
};

💡 Practical Examples

🛒 Example 1: E-commerce Microservice Deployer

Let’s build a TypeScript tool to deploy our shopping platform:

// 🛍️ Define our application types
interface MicroserviceConfig {
  name: string;
  image: string;
  port: number;
  replicas: number;
  emoji: string;
  env?: Record<string, string>;
}

// 🏗️ Microservice deployment manager
class MicroserviceDeployer {
  private k8sApi: k8s.CoreV1Api;
  private appsApi: k8s.AppsV1Api;

  constructor(kubeConfig: k8s.KubeConfig) {
    this.k8sApi = kubeConfig.makeApiClient(k8s.CoreV1Api);
    this.appsApi = kubeConfig.makeApiClient(k8s.AppsV1Api);
  }

  // 🚀 Deploy a microservice
  async deployMicroservice(config: MicroserviceConfig): Promise<void> {
    console.log(`🚀 Deploying ${config.emoji} ${config.name}...`);

    // 📦 Create deployment
    const deployment: k8s.V1Deployment = {
      metadata: {
        name: config.name,
        labels: { app: config.name, type: 'microservice' }
      },
      spec: {
        replicas: config.replicas,
        selector: {
          matchLabels: { app: config.name }
        },
        template: {
          metadata: {
            labels: { app: config.name }
          },
          spec: {
            containers: [{
              name: config.name,
              image: config.image,
              ports: [{ containerPort: config.port }],
              env: config.env ? Object.entries(config.env).map(([key, value]) => ({
                name: key,
                value: value
              })) : []
            }]
          }
        }
      }
    };

    try {
      await this.appsApi.createNamespacedDeployment('default', deployment);
      await this.createService(config.name, config.port);
      console.log(`✅ ${config.emoji} ${config.name} deployed successfully!`);
    } catch (error) {
      console.error(`❌ Failed to deploy ${config.name}:`, error);
    }
  }

  // 🌐 Create service for the deployment
  private async createService(name: string, port: number): Promise<void> {
    const service: k8s.V1Service = {
      metadata: {
        name: `${name}-service`,
        labels: { app: name }
      },
      spec: {
        selector: { app: name },
        ports: [{ port: port, targetPort: port }],
        type: 'ClusterIP'
      }
    };

    await this.k8sApi.createNamespacedService('default', service);
  }

  // 📊 Get deployment status
  async getDeploymentStatus(name: string): Promise<void> {
    try {
      const response = await this.appsApi.readNamespacedDeployment(name, 'default');
      const deployment = response.body;
      const available = deployment.status?.availableReplicas || 0;
      const desired = deployment.spec?.replicas || 0;

      console.log(`📊 ${name} Status:`);
      console.log(`  🎯 Desired: ${desired} replicas`);
      console.log(`  ✅ Available: ${available} replicas`);
      console.log(`  🚀 Ready: ${available === desired ? 'Yes' : 'No'}`);
    } catch (error) {
      console.error(`❌ Error getting status for ${name}:`, error);
    }
  }
}

// 🎮 Let's use it!
const deployer = new MicroserviceDeployer(kc);

// 🛒 Deploy our shopping platform services
const services: MicroserviceConfig[] = [
  {
    name: 'user-service',
    image: 'myapp/user-service:latest',
    port: 3001,
    replicas: 2,
    emoji: '👤',
    env: { NODE_ENV: 'production', DB_HOST: 'postgres-service' }
  },
  {
    name: 'product-service',
    image: 'myapp/product-service:latest',
    port: 3002,
    replicas: 3,
    emoji: '📦',
    env: { NODE_ENV: 'production', REDIS_URL: 'redis-service:6379' }
  },
  {
    name: 'payment-service',
    image: 'myapp/payment-service:latest',
    port: 3003,
    replicas: 2,
    emoji: '💳',
    env: { NODE_ENV: 'production', STRIPE_KEY: 'sk_...' }
  }
];

// 🚀 Deploy all services
services.forEach(service => deployer.deployMicroservice(service));

🎯 Try it yourself: Add a scaleService method that can automatically scale services based on CPU usage!

🎮 Example 2: Game Server Orchestrator

Let’s create a fun game server manager:

// 🏆 Game server configuration
interface GameServerConfig {
  gameType: 'battle-royale' | 'racing' | 'puzzle';
  maxPlayers: number;
  region: string;
  emoji: string;
}

class GameServerOrchestrator {
  private k8sApi: k8s.CoreV1Api;
  private appsApi: k8s.AppsV1Api;
  private gameServers: Map<string, GameServerConfig> = new Map();

  constructor(kubeConfig: k8s.KubeConfig) {
    this.k8sApi = kubeConfig.makeApiClient(k8s.CoreV1Api);
    this.appsApi = kubeConfig.makeApiClient(k8s.AppsV1Api);
  }

  // 🎮 Spawn a new game server
  async spawnGameServer(config: GameServerConfig): Promise<string> {
    const serverId = `game-${config.gameType}-${Date.now()}`;
    console.log(`🎮 Spawning ${config.emoji} ${config.gameType} server...`);

    const deployment: k8s.V1Deployment = {
      metadata: {
        name: serverId,
        labels: {
          app: 'game-server',
          gameType: config.gameType,
          region: config.region
        }
      },
      spec: {
        replicas: 1,
        selector: { matchLabels: { app: serverId } },
        template: {
          metadata: { labels: { app: serverId } },
          spec: {
            containers: [{
              name: 'game-server',
              image: `game-servers/${config.gameType}:latest`,
              ports: [{ containerPort: 7777 }],
              env: [
                { name: 'MAX_PLAYERS', value: config.maxPlayers.toString() },
                { name: 'REGION', value: config.region },
                { name: 'GAME_TYPE', value: config.gameType }
              ],
              resources: {
                requests: { cpu: '500m', memory: '1Gi' },
                limits: { cpu: '1000m', memory: '2Gi' }
              }
            }]
          }
        }
      }
    };

    try {
      await this.appsApi.createNamespacedDeployment('game-servers', deployment);
      this.gameServers.set(serverId, config);
      console.log(`✅ ${config.emoji} Game server ${serverId} spawned!`);
      return serverId;
    } catch (error) {
      console.error(`❌ Failed to spawn game server:`, error);
      throw error;
    }
  }

  // 🔥 Terminate idle servers
  async cleanupIdleServers(): Promise<void> {
    console.log('🧹 Cleaning up idle game servers...');
    
    try {
      const response = await this.appsApi.listNamespacedDeployment('game-servers');
      const deployments = response.body.items;

      for (const deployment of deployments) {
        const name = deployment.metadata?.name;
        if (name && await this.isServerIdle(name)) {
          await this.appsApi.deleteNamespacedDeployment(name, 'game-servers');
          console.log(`🗑️ Removed idle server: ${name}`);
        }
      }
    } catch (error) {
      console.error('❌ Error during cleanup:', error);
    }
  }

  // 📊 Check if server is idle
  private async isServerIdle(serverName: string): Promise<boolean> {
    // 🎯 In a real implementation, you'd check player count or CPU usage
    return Math.random() > 0.7; // 📝 Simulate 30% chance of being idle
  }

  // 🌍 Scale servers by region
  async scaleByRegion(region: string, targetCount: number): Promise<void> {
    console.log(`🌍 Scaling ${region} servers to ${targetCount}...`);
    
    const currentServers = Array.from(this.gameServers.entries())
      .filter(([_, config]) => config.region === region);

    if (currentServers.length < targetCount) {
      // 📈 Scale up
      const serversToAdd = targetCount - currentServers.length;
      for (let i = 0; i < serversToAdd; i++) {
        await this.spawnGameServer({
          gameType: 'battle-royale', // 🎯 Default type
          maxPlayers: 100,
          region: region,
          emoji: '⚔️'
        });
      }
    }
    
    console.log(`🎯 Region ${region} scaled to ${targetCount} servers!`);
  }
}

// 🎮 Let's set up our game servers!
const gameOrchestrator = new GameServerOrchestrator(kc);

// 🌍 Deploy servers across regions
const gameConfigs: GameServerConfig[] = [
  { gameType: 'battle-royale', maxPlayers: 100, region: 'us-east', emoji: '⚔️' },
  { gameType: 'racing', maxPlayers: 12, region: 'eu-west', emoji: '🏎️' },
  { gameType: 'puzzle', maxPlayers: 4, region: 'asia-pacific', emoji: '🧩' }
];

gameConfigs.forEach(config => gameOrchestrator.spawnGameServer(config));

🚀 Advanced Concepts

🧙‍♂️ Advanced Topic 1: Custom Resource Definitions (CRDs)

When you’re ready to level up, create your own Kubernetes resources:

// 🎯 Define a custom TypeScript application resource
interface TypeScriptApp {
  apiVersion: 'apps.mycompany.com/v1';
  kind: 'TypeScriptApp';
  metadata: {
    name: string;
    namespace?: string;
  };
  spec: {
    image: string;
    replicas: number;
    nodeVersion: string;
    buildCommand: string;
    startCommand: string;
    emoji: string;
  };
  status?: {
    phase: 'Building' | 'Running' | 'Failed';
    buildTime?: string;
    readyReplicas?: number;
  };
}

// 🪄 TypeScript App Controller
class TypeScriptAppController {
  private customApi: k8s.CustomObjectsApi;

  constructor(kubeConfig: k8s.KubeConfig) {
    this.customApi = kubeConfig.makeApiClient(k8s.CustomObjectsApi);
  }

  // 🎨 Create a TypeScript application
  async createTypeScriptApp(app: TypeScriptApp): Promise<void> {
    console.log(`🚀 Creating TypeScript app: ${app.spec.emoji} ${app.metadata.name}`);
    
    try {
      await this.customApi.createNamespacedCustomObject(
        'apps.mycompany.com',
        'v1',
        app.metadata.namespace || 'default',
        'typescriptapps',
        app
      );
      console.log(`✅ TypeScript app ${app.metadata.name} created!`);
    } catch (error) {
      console.error('❌ Error creating TypeScript app:', error);
    }
  }

  // 📊 Watch for TypeScript app changes
  watchTypeScriptApps(): void {
    const watch = new k8s.Watch(this.customApi.kubeConfig);
    
    watch.watch(
      '/apis/apps.mycompany.com/v1/namespaces/default/typescriptapps',
      {},
      (type, obj) => {
        const app = obj as TypeScriptApp;
        console.log(`🔍 TypeScript app ${app.metadata.name} was ${type.toLowerCase()}`);
        
        if (type === 'ADDED') {
          this.processNewApp(app);
        }
      },
      (err) => console.error('⚠️ Watch error:', err)
    );
  }

  // 🏗️ Process new TypeScript applications
  private async processNewApp(app: TypeScriptApp): Promise<void> {
    console.log(`🔨 Building ${app.spec.emoji} ${app.metadata.name}...`);
    
    // 🎯 Create build job, then deployment
    // This would trigger your CI/CD pipeline!
    
    console.log(`🎉 ${app.metadata.name} is now running with ${app.spec.replicas} replicas!`);
  }
}

🏗️ Advanced Topic 2: Health Monitoring & Auto-Healing

For the brave developers who want bulletproof systems:

// 🩺 Health monitoring system
interface HealthCheck {
  name: string;
  endpoint: string;
  expectedStatus: number;
  timeout: number;
  emoji: string;
}

class KubernetesHealthMonitor {
  private k8sApi: k8s.CoreV1Api;
  private appsApi: k8s.AppsV1Api;
  private healthChecks: Map<string, HealthCheck> = new Map();

  constructor(kubeConfig: k8s.KubeConfig) {
    this.k8sApi = kubeConfig.makeApiClient(k8s.CoreV1Api);
    this.appsApi = kubeConfig.makeApiClient(k8s.AppsV1Api);
  }

  // 🔍 Monitor application health
  async monitorHealth(): Promise<void> {
    console.log('🩺 Starting health monitoring...');
    
    setInterval(async () => {
      for (const [serviceName, healthCheck] of this.healthChecks) {
        const isHealthy = await this.checkServiceHealth(healthCheck);
        
        if (!isHealthy) {
          console.log(`⚠️ ${healthCheck.emoji} ${serviceName} is unhealthy!`);
          await this.healService(serviceName);
        } else {
          console.log(`✅ ${healthCheck.emoji} ${serviceName} is healthy`);
        }
      }
    }, 30000); // 🕐 Check every 30 seconds
  }

  // 🔧 Auto-heal unhealthy services
  private async healService(serviceName: string): Promise<void> {
    console.log(`😷 Healing service: ${serviceName}`);
    
    try {
      // 🔄 Restart deployment by updating annotation
      const patch = {
        spec: {
          template: {
            metadata: {
              annotations: {
                'kubectl.kubernetes.io/restartedAt': new Date().toISOString()
              }
            }
          }
        }
      };

      await this.appsApi.patchNamespacedDeployment(
        serviceName,
        'default',
        patch,
        undefined,
        undefined,
        undefined,
        undefined,
        { headers: { 'Content-Type': 'application/merge-patch+json' } }
      );

      console.log(`🚀 Service ${serviceName} restarted for healing!`);
    } catch (error) {
      console.error(`❌ Failed to heal ${serviceName}:`, error);
    }
  }

  // 🩺 Check individual service health
  private async checkServiceHealth(healthCheck: HealthCheck): Promise<boolean> {
    try {
      // 🌐 In real implementation, make HTTP request to health endpoint
      return Math.random() > 0.2; // 📝 Simulate 80% uptime
    } catch (error) {
      return false;
    }
  }

  // 📝 Register health check
  registerHealthCheck(serviceName: string, healthCheck: HealthCheck): void {
    this.healthChecks.set(serviceName, healthCheck);
    console.log(`📋 Registered health check for ${healthCheck.emoji} ${serviceName}`);
  }
}

// 🎮 Set up health monitoring
const healthMonitor = new KubernetesHealthMonitor(kc);

healthMonitor.registerHealthCheck('user-service', {
  name: 'user-service',
  endpoint: '/health',
  expectedStatus: 200,
  timeout: 5000,
  emoji: '👤'
});

healthMonitor.monitorHealth();

⚠️ Common Pitfalls and Solutions

😱 Pitfall 1: Ignoring Resource Limits

// ❌ Wrong way - no resource limits!
const badDeployment: k8s.V1Deployment = {
  metadata: { name: 'memory-hog' },
  spec: {
    template: {
      spec: {
        containers: [{
          name: 'app',
          image: 'myapp:latest'
          // 💥 No resource limits = potential cluster crash!
        }]
      }
    }
  }
};

// ✅ Correct way - always set resource limits!
const goodDeployment: k8s.V1Deployment = {
  metadata: { name: 'well-behaved-app' },
  spec: {
    template: {
      spec: {
        containers: [{
          name: 'app',
          image: 'myapp:latest',
          resources: {
            requests: { // 🎯 Minimum resources needed
              cpu: '100m',
              memory: '128Mi'
            },
            limits: { // 🛡️ Maximum resources allowed
              cpu: '500m',
              memory: '512Mi'
            }
          }
        }]
      }
    }
  }
};

🤯 Pitfall 2: Not Handling API Errors Properly

// ❌ Dangerous - no error handling!
const badPodCreation = async (): Promise<void> => {
  const pod = { /* pod definition */ };
  await k8sApi.createNamespacedPod('default', pod); // 💥 Might throw!
  console.log('Pod created!'); // 🚫 This might never run!
};

// ✅ Safe - proper error handling!
const goodPodCreation = async (): Promise<void> => {
  try {
    const pod: k8s.V1Pod = {
      metadata: { name: 'safe-pod' },
      spec: {
        containers: [{
          name: 'app',
          image: 'nginx:latest'
        }]
      }
    };

    const response = await k8sApi.createNamespacedPod('default', pod);
    console.log(`✅ Pod created: ${response.body.metadata?.name}`);
  } catch (error) {
    if (error instanceof k8s.HttpError) {
      console.error(`❌ Kubernetes API error: ${error.statusCode} - ${error.body?.message}`);
    } else {
      console.error('❌ Unexpected error:', error);
    }
  }
};

🚨 Pitfall 3: Forgetting Cleanup

// ❌ Memory leak - watching without cleanup!
const badWatcher = (): void => {
  const watch = new k8s.Watch(kc);
  watch.watch('/api/v1/pods', {}, (type, obj) => {
    console.log('Pod event:', type);
  });
  // 💥 Watch never stops!
};

// ✅ Proper cleanup with AbortController!
const goodWatcher = (): void => {
  const watch = new k8s.Watch(kc);
  const abortController = new AbortController();

  watch.watch('/api/v1/pods', 
    { signal: abortController.signal },
    (type, obj) => {
      console.log('Pod event:', type);
    },
    (err) => {
      if (err.name !== 'AbortError') {
        console.error('Watch error:', err);
      }
    }
  );

  // 🧹 Clean up after 5 minutes
  setTimeout(() => {
    abortController.abort();
    console.log('🛑 Watch stopped');
  }, 5 * 60 * 1000);
};

🛠️ Best Practices

🎯 Use TypeScript Interfaces: Define clear types for your Kubernetes resources
📝 Resource Limits: Always set CPU and memory limits
🛡️ Error Handling: Wrap API calls in try-catch blocks
🔄 Graceful Cleanup: Use AbortController for watches
✨ Namespace Organization: Use namespaces to organize resources
📊 Monitoring: Implement health checks and logging
🔒 Security: Use RBAC and service accounts properly

🧪 Hands-On Exercise

🎯 Challenge: Build a TypeScript Microservice Auto-Scaler

Create a smart auto-scaling system for your TypeScript microservices:

📋 Requirements:

✅ Monitor CPU and memory usage of deployments
🏷️ Scale up when usage > 70% for 2 minutes
📉 Scale down when usage < 30% for 5 minutes
👤 Support min/max replica limits
🎨 Add fun emojis and logging throughout!

🚀 Bonus Points:

Add custom metrics (request rate, queue length)
Implement predictive scaling based on time patterns
Create a dashboard showing scaling events
Add Slack/Discord notifications for scaling events

💡 Solution

🔍 Click to see solution

// 🎯 Our TypeScript microservice auto-scaler!
interface ScalingConfig {
  deploymentName: string;
  namespace: string;
  minReplicas: number;
  maxReplicas: number;
  targetCpuPercent: number;
  targetMemoryPercent: number;
  scaleUpThreshold: number;
  scaleDownThreshold: number;
  emoji: string;
}

interface MetricPoint {
  timestamp: number;
  cpuPercent: number;
  memoryPercent: number;
}

class TypeScriptAutoScaler {
  private k8sApi: k8s.CoreV1Api;
  private appsApi: k8s.AppsV1Api;
  private metricsApi: k8s.Metrics;
  private scalingConfigs: Map<string, ScalingConfig> = new Map();
  private metricsHistory: Map<string, MetricPoint[]> = new Map();

  constructor(kubeConfig: k8s.KubeConfig) {
    this.k8sApi = kubeConfig.makeApiClient(k8s.CoreV1Api);
    this.appsApi = kubeConfig.makeApiClient(k8s.AppsV1Api);
    this.metricsApi = kubeConfig.makeApiClient(k8s.Metrics);
  }

  // 📝 Register a deployment for auto-scaling
  registerDeployment(config: ScalingConfig): void {
    this.scalingConfigs.set(config.deploymentName, config);
    this.metricsHistory.set(config.deploymentName, []);
    console.log(`📋 Registered ${config.emoji} ${config.deploymentName} for auto-scaling`);
  }

  // 🚀 Start the auto-scaling loop
  startAutoScaling(): void {
    console.log('🎯 Starting TypeScript Auto-Scaler!');
    
    setInterval(async () => {
      for (const [deploymentName, config] of this.scalingConfigs) {
        await this.checkAndScale(deploymentName, config);
      }
    }, 30000); // 🕐 Check every 30 seconds
  }

  // 🔍 Check metrics and scale if needed
  private async checkAndScale(deploymentName: string, config: ScalingConfig): Promise<void> {
    try {
      const metrics = await this.getDeploymentMetrics(deploymentName, config.namespace);
      
      if (!metrics) {
        console.log(`⚠️ No metrics available for ${config.emoji} ${deploymentName}`);
        return;
      }

      // 📊 Store metrics history
      const history = this.metricsHistory.get(deploymentName) || [];
      history.push({
        timestamp: Date.now(),
        cpuPercent: metrics.cpuPercent,
        memoryPercent: metrics.memoryPercent
      });

      // 🧹 Keep only last 10 minutes of data
      const cutoff = Date.now() - (10 * 60 * 1000);
      const recentHistory = history.filter(point => point.timestamp > cutoff);
      this.metricsHistory.set(deploymentName, recentHistory);

      // 🎯 Make scaling decision
      await this.makeScalingDecision(deploymentName, config, metrics, recentHistory);

    } catch (error) {
      console.error(`❌ Error checking metrics for ${deploymentName}:`, error);
    }
  }

  // 📊 Get current deployment metrics
  private async getDeploymentMetrics(deploymentName: string, namespace: string): Promise<{cpuPercent: number, memoryPercent: number} | null> {
    try {
      // 🎯 In a real implementation, you'd get metrics from Prometheus or metrics-server
      // For this example, we'll simulate metrics
      const cpuPercent = Math.random() * 100;
      const memoryPercent = Math.random() * 100;
      
      console.log(`📊 ${deploymentName} - CPU: ${cpuPercent.toFixed(1)}%, Memory: ${memoryPercent.toFixed(1)}%`);
      
      return { cpuPercent, memoryPercent };
    } catch (error) {
      console.error(`❌ Error getting metrics for ${deploymentName}:`, error);
      return null;
    }
  }

  // 🎯 Make scaling decision based on metrics
  private async makeScalingDecision(
    deploymentName: string, 
    config: ScalingConfig, 
    currentMetrics: {cpuPercent: number, memoryPercent: number},
    history: MetricPoint[]
  ): Promise<void> {
    const currentReplicas = await this.getCurrentReplicas(deploymentName, config.namespace);
    if (currentReplicas === null) return;

    const avgCpu = currentMetrics.cpuPercent;
    const avgMemory = currentMetrics.memoryPercent;

    // 📈 Scale up conditions
    if ((avgCpu > config.scaleUpThreshold || avgMemory > config.scaleUpThreshold) && 
        currentReplicas < config.maxReplicas) {
      
      const newReplicas = Math.min(currentReplicas + 1, config.maxReplicas);
      await this.scaleDeployment(deploymentName, config.namespace, newReplicas);
      console.log(`📈 ${config.emoji} ${deploymentName} scaled UP to ${newReplicas} replicas (CPU: ${avgCpu.toFixed(1)}%, Memory: ${avgMemory.toFixed(1)}%)`);
    }
    
    // 📉 Scale down conditions
    else if ((avgCpu < config.scaleDownThreshold && avgMemory < config.scaleDownThreshold) && 
             currentReplicas > config.minReplicas) {
      
      // 🕐 Only scale down if consistently low for 5 minutes
      const fiveMinutesAgo = Date.now() - (5 * 60 * 1000);
      const recentLowUsage = history
        .filter(point => point.timestamp > fiveMinutesAgo)
        .every(point => point.cpuPercent < config.scaleDownThreshold && point.memoryPercent < config.scaleDownThreshold);

      if (recentLowUsage && history.length >= 10) {
        const newReplicas = Math.max(currentReplicas - 1, config.minReplicas);
        await this.scaleDeployment(deploymentName, config.namespace, newReplicas);
        console.log(`📉 ${config.emoji} ${deploymentName} scaled DOWN to ${newReplicas} replicas (consistently low usage)`);
      }
    }
  }

  // 🔢 Get current replica count
  private async getCurrentReplicas(deploymentName: string, namespace: string): Promise<number | null> {
    try {
      const response = await this.appsApi.readNamespacedDeployment(deploymentName, namespace);
      return response.body.spec?.replicas || 0;
    } catch (error) {
      console.error(`❌ Error getting replica count for ${deploymentName}:`, error);
      return null;
    }
  }

  // ⚖️ Scale the deployment
  private async scaleDeployment(deploymentName: string, namespace: string, replicas: number): Promise<void> {
    try {
      const patch = {
        spec: {
          replicas: replicas
        }
      };

      await this.appsApi.patchNamespacedDeployment(
        deploymentName,
        namespace,
        patch,
        undefined,
        undefined,
        undefined,
        undefined,
        { headers: { 'Content-Type': 'application/merge-patch+json' } }
      );

      console.log(`✅ Successfully scaled ${deploymentName} to ${replicas} replicas`);
    } catch (error) {
      console.error(`❌ Error scaling ${deploymentName}:`, error);
    }
  }

  // 📊 Get scaling statistics
  getScalingStats(): void {
    console.log('📊 Auto-Scaling Statistics:');
    for (const [deploymentName, config] of this.scalingConfigs) {
      const history = this.metricsHistory.get(deploymentName) || [];
      const recent = history.slice(-5);
      const avgCpu = recent.reduce((sum, p) => sum + p.cpuPercent, 0) / recent.length;
      const avgMemory = recent.reduce((sum, p) => sum + p.memoryPercent, 0) / recent.length;
      
      console.log(`  ${config.emoji} ${deploymentName}:`);
      console.log(`    🎯 Target: ${config.targetCpuPercent}% CPU, ${config.targetMemoryPercent}% Memory`);
      console.log(`    📈 Current: ${avgCpu.toFixed(1)}% CPU, ${avgMemory.toFixed(1)}% Memory`);
      console.log(`    📊 Range: ${config.minReplicas}-${config.maxReplicas} replicas`);
    }
  }
}

// 🎮 Set up our auto-scaler!
const autoScaler = new TypeScriptAutoScaler(kc);

// 📝 Register our microservices
const scalingConfigs: ScalingConfig[] = [
  {
    deploymentName: 'user-service',
    namespace: 'default',
    minReplicas: 2,
    maxReplicas: 10,
    targetCpuPercent: 50,
    targetMemoryPercent: 60,
    scaleUpThreshold: 70,
    scaleDownThreshold: 30,
    emoji: '👤'
  },
  {
    deploymentName: 'payment-service',
    namespace: 'default',
    minReplicas: 3,
    maxReplicas: 15,
    targetCpuPercent: 60,
    targetMemoryPercent: 70,
    scaleUpThreshold: 80,
    scaleDownThreshold: 20,
    emoji: '💳'
  }
];

scalingConfigs.forEach(config => autoScaler.registerDeployment(config));

// 🚀 Start auto-scaling!
autoScaler.startAutoScaling();

// 📊 Show stats every 2 minutes
setInterval(() => autoScaler.getScalingStats(), 2 * 60 * 1000);

🎓 Key Takeaways

You’ve learned so much about Kubernetes orchestration with TypeScript! Here’s what you can now do:

✅ Deploy containerized applications with confidence 💪
✅ Manage Kubernetes resources programmatically 🛡️
✅ Scale applications automatically based on metrics 🎯
✅ Build custom controllers and operators 🐛
✅ Monitor and heal your applications 🚀

Remember: Kubernetes is your orchestration partner, not your enemy! It’s here to help you run resilient, scalable applications. 🤝

🤝 Next Steps

Congratulations! 🎉 You’ve mastered Kubernetes container orchestration with TypeScript!

Here’s what to do next:

💻 Practice with the auto-scaler exercise above
🏗️ Build a small microservice and deploy it with your TypeScript tools
📚 Move on to our next tutorial: Serverless Functions with TypeScript
🌟 Share your Kubernetes journey with the community!

Remember: Every Kubernetes expert was once a beginner. Keep experimenting, keep learning, and most importantly, have fun orchestrating your applications! 🚀

Happy orchestrating! 🎉🚀✨

Prerequisites

What you'll learn