kubernetes-deployment

name	kubernetes-deployment
description	Kubernetes is a container orchestration platform that automates deployment, Use when this capability is needed.
metadata	{"author":"AmnadTaowsoam"}

Kubernetes Deployment

Skill Profile

(Select at least one profile to enable specific modules)

• DevOps
• Backend
• Frontend
• AI-RAG
• Security Critical

Overview

Kubernetes is a container orchestration platform that automates deployment, scaling, and management of containerized applications. This skill covers K8s concepts, resources, and best practices for deploying applications in production environments.

Why This Matters

Kubernetes has become the de facto standard for container orchestration, enabling organizations to:

• Scale applications automatically based on resource usage
• Achieve high availability through self-healing and replication
• Implement zero-downtime deployments with rolling updates
• Manage complex multi-service architectures efficiently
• Standardize deployment patterns across teams
• Reduce infrastructure costs through efficient resource utilization

---

Core Concepts & Rules

1. Core Principles

• Follow established patterns and conventions
• Maintain consistency across codebase
• Document decisions and trade-offs

2. Implementation Guidelines

• Start with the simplest viable solution
• Iterate based on feedback and requirements
• Test thoroughly before deployment

Inputs / Outputs / Contracts

Skill Composition

• Depends on: git-workflow
• Compatible with: None
• Conflicts with: None
• Related Skills: docker, kubernetes

Quick Start / Implementation Example

1. Review requirements and constraints
2. Set up development environment
3. Implement core functionality following patterns
4. Write tests for critical paths
5. Run tests and fix issues
6. Document any deviations or decisions

# Example implementation following best practices
def example_function():
    # Your implementation here
    pass

Assumptions

• Kubernetes cluster is already provisioned and accessible
• kubectl CLI is installed and configured
• Container images are available in a registry
• Application exposes health check endpoints
• Storage class is available if persistent storage is needed

Compatibility & Prerequisites

• Supported Versions:
  • Python 3.8+
  • Node.js 16+
  • Modern browsers (Chrome, Firefox, Safari, Edge)
• Required AI Tools:
  • Code editor (VS Code recommended)
  • Testing framework appropriate for language
  • Version control (Git)
• Dependencies:
  • Language-specific package manager
  • Build tools
  • Testing libraries
• Environment Setup:
  • .env.example keys: API_KEY, DATABASE_URL (no values)

Test Scenario Matrix (QA Strategy)

Type	Focus Area	Required Scenarios / Mocks
Unit	Core Logic	Must cover primary logic and at least 3 edge/error cases. Target minimum 80% coverage
Integration	DB / API	All external API calls or database connections must be mocked during unit tests
E2E	User Journey	Critical user flows to test
Performance	Latency / Load	Benchmark requirements
Security	Vuln / Auth	SAST/DAST or dependency audit
Frontend	UX / A11y	Accessibility checklist (WCAG), Performance Budget (Lighthouse score)

Technical Guardrails & Security Threat Model

1. Security & Privacy (Threat Model)

• Top Threats: Injection attacks, authentication bypass, data exposure

• Data Handling: Sanitize all user inputs to prevent Injection attacks. Never log raw PII
• Secrets Management: No hardcoded API keys. Use Env Vars/Secrets Manager
• Authorization: Validate user permissions before state changes

2. Performance & Resources

• Execution Efficiency: Consider time complexity for algorithms
• Memory Management: Use streams/pagination for large data
• Resource Cleanup: Close DB connections/file handlers in finally blocks

3. Architecture & Scalability

• Design Pattern: Follow SOLID principles, use Dependency Injection
• Modularity: Decouple logic from UI/Frameworks

4. Observability & Reliability

• Logging Standards: Structured JSON, include trace IDs request_id
• Metrics: Track error_rate, latency, queue_depth
• Error Handling: Standardized error codes, no bare except
• Observability Artifacts:
  • Log Fields: timestamp, level, message, request_id
  • Metrics: request_count, error_count, response_time
  • Dashboards/Alerts: High Error Rate > 5%

Agent Directives

When deploying to Kubernetes:

1. Always validate resources before applying
2. Check resource availability before scaling
3. Monitor rollout status after deployment
4. Verify health checks are passing
5. Review logs if pods fail to start
6. Use dry-run for testing changes

Definition of Done (DoD) Checklist

• Tests passed + coverage met
• Lint/Typecheck passed
• Logging/Metrics/Trace implemented
• Security checks passed
• Documentation/Changelog updated
• Accessibility/Performance requirements met (if frontend)

Anti-patterns

1. Running as root: Avoid running containers as root user
2. Hardcoded values: Don't hardcode environment-specific values
3. Ignoring limits: Never deploy without resource limits
4. Latest tag: Avoid using :latest image tag
5. Monolithic pods: Don't run multiple processes in one container
6. Ignoring health checks: Always implement health checks

Reference Links & Examples

• Internal documentation and examples
• Official documentation and best practices
• Community resources and discussions

Versioning & Changelog

• Version: 1.0.0
• Changelog:
  • 2026-02-22: Initial version with complete template structure

---

Source: AmnadTaowsoam/CerebraSkills — distributed by TomeVault.