kubernetes

name	kubernetes
description	Kubernetes orchestration for container deployment, scaling, and management
license	MIT
compatibility	opencode
metadata	{"audience":"devops-engineers","category":"systems-administration"}

What I do

• Create Kubernetes manifests and Helm charts
• Deploy and manage applications on Kubernetes
• Configure pods, deployments, and services
• Implement networking policies and ingress
• Manage secrets and configmaps
• Set up horizontal pod autoscaling
• Configure persistent storage
• Implement RBAC and security policies
• Perform rolling updates and rollbacks
• Debug and troubleshoot cluster issues

When to use me

When deploying applications to Kubernetes clusters, creating deployment manifests, or managing Kubernetes resources.

Core Concepts

• Pods, Deployments, StatefulSets, DaemonSets
• Services (ClusterIP, NodePort, LoadBalancer, Ingress)
• ConfigMaps and Secrets
• PersistentVolumes and PersistentVolumeClaims
• Horizontal Pod Autoscaler (HPA)
• Network Policies
• RBAC and ServiceAccounts
• Helm package management
• Operators and Custom Resource Definitions
• Kubernetes networking (CNI, Service mesh)

Code Examples

Kubernetes Manifests

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: api-server
  labels:
    app: api-server
    version: v1
    tier: backend
spec:
  replicas: 3
  revisionHistoryLimit: 5
  selector:
    matchLabels:
      app: api-server
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 25%
      maxUnavailable: 0
  template:
    metadata:
      labels:
        app: api-server
        version: v1
        tier: backend
      annotations:
        prometheus.io/scrape: "true"
        prometheus.io/port: "8080"
    spec:
      serviceAccountName: api-server
      securityContext:
        runAsNonRoot: true
        runAsUser: 1000
         
      
          
           
           
          
              
               
               
              
               
               
          
             
                 
             
                 
          
              
              
                
                   
              
              
                
                   
          
            
               
               
               
            
               
               
               
          
            
               
               
             
             
             
             
          
            
               
               
             
             
             
             
          
            
               
               
             
             
          
              
               
              
               
               
      
          
           {}
          
          
             
      
        
          
              
              
                
                  
                     
                 
      
          
           
           
          
            
               

# service.yaml
apiVersion: v1
kind: Service
metadata:
  name: api-server
  labels:
    app: api-server
spec:
  type: ClusterIP
  selector:
    app: api-server
  ports:
    - name: http
      port: 80
      targetPort: http
      protocol: TCP
    - name: grpc
      port: 9090
      targetPort: grpc
      protocol: TCP
  sessionAffinity: ClientIP
  sessionAffinityConfig:
    clientIP:
      timeoutSeconds: 3600

# ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: api-ingress
  annotations:
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
    nginx.ingress.kubernetes.io/proxy-body-size: "10m"
    nginx.ingress.kubernetes.io/proxy-read-timeout: "300"
    nginx.ingress.kubernetes.io/proxy-send-timeout: "300"
    nginx.ingress.kubernetes.io/proxy-connect-timeout: "60"
    nginx.ingress.kubernetes.io/limit-rps: "100"
    nginx.ingress.kubernetes.io/limit-connections: "50"
    cert-manager.io/cluster-issuer: letsencrypt-prod
spec:
  ingressClassName: nginx
  tls:
    - hosts:
        - api.example.com
      secretName: api-tls
  rules:
    - host: api.example.com
      http:
        paths:
          - path: /api/v1
            pathType: Prefix
            backend:
              service:
                name: api-server
                
                   

Helm Chart Structure

# Chart.yaml
apiVersion: v2
name: api-server
description: A Helm chart for API Server deployment
version: 1.2.3
appVersion: "1.2.3"
kubeVersion: ">=1.20.0-0"
dependencies:
  - name: redis
    version: "17.x"
    repository: "https://charts.bitnami.com/bitnami"
    condition: redis.enabled
  - name: postgresql
    version: "11.x"
    repository: "https://charts.bitnami.com/bitnami"
    condition: postgresql.enabled

# values.yaml
replicaCount: 3

image:
  repository: registry.example.com/api-server
  tag: v1.2.3
  pullPolicy: IfNotPresent

imagePullSecrets:
  - name: registry-secret

service:
  type: 
   


   
   
  
      
      
          
           
  
      
    
       


  
     
     
  
     
     


   
   
   
   
   

 {}

 []

 {}



   
  
    
       
       
    
       
       
  
     
     

kubectl Commands

#!/bin/bash

# Kubernetes management utilities
k8s_deploy() {
    local manifest="$1"
    kubectl apply -f "$manifest" --record
    echo "Deployed: $manifest"
}

k8s_rollback() {
    local deployment="$1"
    local revision="${2:---previous}"
    kubectl rollout undo deployment/"$deployment" --to-revision="$revision"
    kubectl rollout status deployment/"$deployment"
}

k8s_debug_pod() {
    local pod="$1"
    kubectl debug -it "$pod" --image=busybox --target="$pod"
}

k8s_get_resources() {
    echo "=== Cluster Resources ==="
    echo "Nodes:"
    kubectl get nodes -o wide
    
    echo ""
    echo "Pods (All namespaces):"
    kubectl get pods -A -o wide --sort-by='.metadata.namespace'
    
    echo ""
    echo "Top Nodes:"
    kubectl top nodes
    
    echo 
     
    kubectl top pods -A
}

() {
     pod=
    kubectl  -it  -- netstat -ant
    kubectl  -it  -- ss -tunapl
}

() {
     deployment=
     local_port=
     remote_port=
    kubectl port-forward deployment/ :
}


() {
     namespace=
     serviceaccount=
    
     token=$(kubectl get secret -n  \
        -o jsonpath= \
        |  -d)
    
     ca=$(kubectl get secret -n  \
        -o jsonpath= \
        |  -d)
    
     context=$(kubectl config current-context)
     cluster=$(kubectl config view -o jsonpath=)
     server=$(kubectl config view -o jsonpath=)
    
     >  <<
}

Best Practices

• Use namespaces to isolate environments and teams
• Implement proper resource requests and limits for all containers
• Use liveness and readiness probes for proper health checking
• Avoid running containers as root
• Use network policies to restrict traffic between pods
• Implement pod anti-affinity for high availability
• Use Helm for templating and managing releases
• Store sensitive data in Secrets (encrypted at rest)
• Use ConfigMaps for configuration, avoid hardcoding
• Implement proper logging and monitoring from the start