Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Kubernetes Manifest Generator

    1

    Generates production-grade, security-hardened Kubernetes manifests, Helm charts, and Kustomize overlays.

    $1

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Kubernetes Manifest Generator

    Kubernetes Manifest Generator

    Example session with this skill installed

    Generate a production k8s deployment for 'auth-srv' using image 'ghcr.io/acme/auth:v2', port 3000, 3 replicas, and host 'auth.acme.com'. I need HPA and Kustomize overlays.

    • Read your context and instructions
    • Compiled the kubernetes manifest generator

    I have generated a production-ready Kustomize structure for auth-srv. This includes a hardened Deployment, Service, Ingress, HPA, and PDB.

    Generated Kubernetes Manifests

    
    # base/deployment.yaml
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: auth-srv
    spec:
      replicas: 3
      selector:
        matchLabels:
          app: auth-srv
      template:
        metadata:
          labels:
            app: auth-srv
        spec:
          securityContext:
            runAsNonRoot: true
            runAsUser: 1000
            fsGroup: 2000
          containers:
          - name: auth-srv
            image: ghcr.io/acme/auth:v2
            ports:
            - containerPort: 3000
            resources:
              requests:
                cpu: 100m
                memory: 128Mi
              limits:
                cpu: 500m
                memory: 512Mi
            readinessProbe:
              httpGet:
                path: /healthz
                port: 3000
            securityContext:
              readOnlyRootFilesystem: true
              allowPrivilegeEscalation: false
            volumeMounts:
            - name: tmp
              mountPath: /tmp
          volumes:
          - name: tmp
            emptyDir: {}
    ---
    
    # base/hpa.yaml
    apiVersion: autoscaling/v2
    kind: HorizontalPodAutoscaler
    metadata:
      name: auth-srv
    spec:
      scaleTargetRef:
        apiVersion: apps/v1
        kind: Deployment
        name: auth-srv
      minReplicas: 3
      maxReplicas: 10
      metrics:
      - type: Resource
        resource:
          name: cpu
          target:
            type: Utilization
            averageUtilization: 70
    

    Next steps

    1. Verify the /healthz endpoint exists in your application for the readiness probe.
    2. Update overlays/prod/kustomization.yaml with your production secrets and config refs.
    3. Run kubectl apply -k overlays/prod to deploy to your cluster.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Writing Kubernetes manifests by hand is error-prone and tedious. This skill generates production-ready YAML and Helm skeletons that follow best practices for security and availability without the manual boilerplate.

    What it does

    • Standardized Deployments generates manifests with resource limits, liveness/readiness probes, and rolling update strategies.
    • Hardened Security configures non-root execution, read-only root filesystems, and tmpfs mounts by default.
    • Traffic Management creates Services, Ingress with TLS/cert-manager support, and NetworkPolicies.
    • High Availability includes HorizontalPodAutoscalers (HPA) and PodDisruptionBudgets (PDB).
    • Environment Management outputs Kustomize overlays for dev/prod or minimal Helm charts.

    How it works

    1. Define Core Attributes provide the service name, container image, and port.
    2. Specify Workload Type choose between a standard Deployment or a scheduled CronJob.
    3. Set Scaling & Traffic define replica counts, hostnames, and autoscaling thresholds.
    4. Output Format generate a structured directory with Kustomize bases or a Helm chart layout.

    Frameworks & tools

    Kubernetes, Kustomize, Helm, and kubectl.

    Why this beats prompting it yourself

    Generic prompts often forget critical production fields like podAntiAffinity or securityContext. This skill enforces a consistent, hardened baseline across every service, ensuring you do not miss resource requests or essential probes.

    Use cases

    • Service Scaffolding to create a full suite of manifests for a new microservice.
    • Security Hardening to wrap an existing image in a restricted, non-root security context.
    • CronJob Automation to generate scheduled tasks with proper resource tracking.
    • Environment Parity to set up Kustomize overlays for consistent dev and prod deployments.

    Known limitations

    Requires manual review of specific probe paths and resource sizing for each application. It does not provide managed cloud provider specific annotations (e.g., EKS/GKE) beyond standard Ingress.

    Requires manual review of probe paths and resource sizing. Does not include cloud-specific (EKS/GKE) LoadBalancer annotations.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    Permissions

    Terminal / Shell
    Listed1 month ago
    Updated13 days ago

    What's inside

    Frequently Asked Questions

    This skill generates hardened Kubernetes manifests, Helm charts, and Kustomize overlays, automating the creation of secure, production-grade YAML that includes resource limits, security contexts, and scaling policies.

    Unlike generic AI prompts, this skill enforces a strict baseline of production best practices, ensuring you never forget critical fields like podAntiAffinity, non-root security contexts, or proper health probes.

    This skill is compatible with any AI agent or platform that supports structured text generation and can be integrated into CI/CD pipelines or local developer environments.

    You receive the full skill logic capable of generating Deployments, CronJobs, Services, Ingress, HPAs, and environment-specific Kustomize or Helm structures.

    The skill outputs standard Kubernetes YAML compatible with all CNCF-certified distributions, though you may need to add specific cloud-provider annotations (like those for EKS or GKE) manually.

    Connect your AI agent to Agensi through MCP, then ask it to use Kubernetes Manifest Generator on your task. Your agent loads the latest approved version each time. Paid skills require a purchase or active subscription. Skill files are not available for download; your licence does not allow you to save, copy or export any part of a skill.

    New in DevOps & Cloud