Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    release fleet

    2

    Deterministic containerization, Kubernetes orchestration, and hardened CI/CD pipelines with a reliability ledger.

    $19.90

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    release fleet

    release fleet

    Example session with this skill installed

    I need to containerize my 'auth-service' and set up a hardened CI pipeline with a release checklist.

    • Read your context and instructions
    • Compiled the release fleet

    I have generated the production-ready Docker configuration, Kubernetes manifests, and the GitHub Actions pipeline for auth-service. All containers are configured to run as non-root with pinned base image digests.

    Release Fleet Artifacts

    
    # Dockerfile
    FROM python:3.11-slim@sha256:83c510... AS builder
    WORKDIR /app
    COPY requirements.txt .
    RUN pip install --user --no-cache-dir -r requirements.txt
    
    FROM python:3.11-slim@sha256:83c510...
    RUN groupadd -g 999 harbor && useradd -r -u 999 -g harbor harbor
    USER harbor
    WORKDIR /app
    COPY --from=builder /home/harbor/.local /home/harbor/.local
    COPY . .
    HEALTHCHECK --interval=30s --timeout=3s CMD curl -f http://localhost:8080/health || exit 1
    ENTRYPOINT ["python", "main.py"]
    
    
    # .github/workflows/harbor.yml
    name: harbor-release
    on: [push]
    permissions:
      contents: read
    jobs:
      check:
        runs-name: Release Checklist
        runs-on: ubuntu-latest
        steps:
          - uses: actions/checkout@v4
          - name: Harbor Secrets Scan
            run: harbor scan --path .
          - name: Go/No-Go Checklist
            run: harbor release auth-service --check-only
    

    The reliability ledger has been initialized at warroom/ledger.jsonl. Your initial reliability score is recorded.

    Next steps

    1. Run harbor chart auth-service to generate the Kubernetes deployment manifests.
    2. Update the HEALTHCHECK path in the Dockerfile if your app uses a different endpoint.
    3. Perform your first harbor drill auth-service to record a successful rollback rehearsal in the ledger.

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

    About this skill

    Manual deployment and infrastructure configuration often lead to inconsistent environments, security holes, and failed releases. This skill automates the generation of production-ready container and orchestration artifacts using a deterministic fleet of specialized agent roles.

    What it does

    • Reproducible Dockerization generates multi-stage Dockerfiles with pinned bases, healthchecks, and non-root user enforcement.
    • Orchestration Scaffolding creates Kubernetes manifests including liveness/readiness probes, resource budgets, and rolling update strategies.
    • Pipeline Hardening builds GitHub Actions workflows with minimal permission scopes, secrets gating, and dependency caching.
    • Release Governance executes a mandatory go/no-go checklist ensuring git hygiene, changelog presence, and passing tests before deployment.
    • Reliability Ledger maintains a monotonic reliability score and records rollback drills and blameless postmortems in a persistent log.

    How it works

    1. Dock run harbor dock <app> to generate the core container files and entrypoints.
    2. Chart execute harbor chart <app> to produce cloud-agnostic Kubernetes Deployment and Service YAMLs.
    3. Pipeline use harbor pipeline <app> to output security-hardened CI/CD workflow configurations.
    4. Release & Drill invoke harbor release for pre-flight checks and harbor drill to rehearse and record recovery procedures.

    Frameworks & tools

    The skill generates standard YAML and HCL compatible with any cloud provider. It requires Python 3.10+ for the local fleet tooling and integrates with Docker and Git.

    Why this beats prompting it yourself

    Generic prompts often ignore security best practices like runAsNonRoot or pinned image digests. This skill enforces operational discipline via a deterministic ledger, ensuring your reliability score never falls and rollback drills are never forgotten.

    Use cases

    • Containerize a legacy Python or Node.js app for production.
    • Generate least-privilege IAM and Kubernetes manifests for a new microservice.
    • Conduct a blameless postmortem and log action items after a production incident.
    • Setup a hardened GitHub Actions pipeline with automated secrets scanning.

    Known limitations

    Requires Python 3.10 or higher. Full functionality depends on a local Git remote and Docker installation to validate artifacts and ledger entries.

    Requires Python 3.10+. Full functionality depends on a local Git remote and Docker installation to validate artifacts and ledger entries.

    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 28 days ago

    Requires

    Python

    Permissions

    Terminal / Shell
    Network Access
    Read Files
    Write Files
    Listed28 days ago

    What's inside

    Frequently Asked Questions

    Unlike generic AI prompts that may omit security headers, this skill enforces strict operational standards such as non-root users, pinned image digests, and least-privilege IAM roles, all verified through a persistent reliability ledger.

    The skill generates standardized YAML, HCL, and Dockerfiles compatible with any cloud provider (AWS, Azure, GCP) or CI/CD platform that supports GitHub Actions and standard Kubernetes clusters.

    You will receive the full 'harbor' CLI toolkit (Python 3.10+ compatible), the agent fleet logic for generating artifacts, and the reliability ledger system for tracking deployment health and rollback drills.

    While it integrates with any LLM-based agent capable of shell execution, the skill requires a local environment with Python 3.10+, Docker, and Git to validate the artifacts and maintain the ledger.

    The 'release fleet' skill includes a built-in update mechanism that pulls the latest hardened templates and security patches for container bases and CI/CD workflows as industry best practices evolve.

    The Reliability Ledger is a persistent log that tracks every deployment's success, mandatory rollback drills, and postmortems, providing a quantitative 'reliability score' to ensure your team maintains operational discipline.

    New in DevOps & Cloud