home / skills / markus41 / claude / harness-cd

This skill helps you orchestrate Kubernetes, Helm, Terraform and serverless deployments with GitOps, approvals, and multi-environment promotion.

npx playbooks add skill markus41/claude --skill harness-cd

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
6.0 KB
---
name: harness-cd
description: Harness CD (Continuous Delivery) for Kubernetes, Helm, Terraform, ECS, and serverless deployments with GitOps, approval gates, rollback strategies, and multi-environment promotion
allowed-tools:
  - Bash
  - Read
  - Write
  - Edit
  - Glob
  - Grep
  - Task
  - WebFetch
  - WebSearch
dependencies:
  - harness-platform
  - harness-mcp
triggers:
  - harness cd
  - harness deploy
  - harness deployment
  - harness rollback
  - harness canary
  - harness blue green
  - harness rolling
  - harness gitops
  - harness environment
  - harness infrastructure
  - harness service
  - harness artifact
  - harness approval
  - deployment strategy
  - kubernetes deployment
  - helm deployment
  - terraform deployment
---

# Harness CD Skill

Deployment orchestration for Kubernetes, Helm, Terraform, ECS, serverless with GitOps.

## Use For
- CD pipelines, strategies (Canary/Blue-Green/Rolling), environments
- Approval gates, GitOps, rollback, multi-environment promotion

## Basic Deployment Pipeline

```yaml
pipeline:
  name: Deploy Pipeline
  stages:
    - stage:
        name: Deploy Dev
        type: Deployment
        spec:
          service:
            serviceRef: my_service
          environment:
            environmentRef: development
          execution:
            steps:
              - step:
                  name: Rolling Deploy
                  type: K8sRollingDeploy
                  timeout: 10m
            rollbackSteps:
              - step:
                  name: Rollback
                  type: K8sRollingRollback
```

## Deployment Strategies

### Rolling (gradual replacement)
```yaml
- step:
    type: K8sRollingDeploy
    spec:
      skipDryRun: false
```

### Canary (progressive traffic shift)
```yaml
- step:
    type: K8sCanaryDeploy
    spec:
      instanceSelection:
        type: Count
        spec:
          count: 1
```

### Blue-Green (zero-downtime cutover)
```yaml
- step:
    type: K8sBGStageDeployment
- step:
    type: K8sBGSwapServices
```

## Service Configuration

### Kubernetes
```yaml
serviceDefinition:
  type: Kubernetes
  spec:
    manifests:
      - manifest:
          type: K8sManifest
          spec:
            store:
              type: Git
              spec:
                connectorRef: github_connector
                branch: main
    artifacts:
      primary:
        sources:
          - type: DockerRegistry
            spec:
              imagePath: myorg/myapp
```

### Helm
```yaml
serviceDefinition:
  type: NativeHelm
  spec:
    chartName: my-app
    helmVersion: V3
```

### Terraform
```yaml
serviceDefinition:
  type: CustomDeployment
  spec:
    customDeploymentRef:
      templateRef: terraform_template
```

## Environment & Infrastructure

```yaml
environment:
  name: Production
  type: Production
infrastructureDefinition:
  type: KubernetesDirect
  spec:
    connectorRef: k8s_connector
    namespace: my-namespace
```

## Approval Gates

```yaml
- step:
    type: HarnessApproval
    spec:
      approvers:
        userGroups:
          - account.ProductionApprovers
# Jira: type: JiraApproval, issueKey: <+pipeline.variables.jiraIssueKey>
# ServiceNow: type: ServiceNowApproval, ticketNumber: <+pipeline.variables.changeRequest>
```

## GitOps Deployments

### Argo CD
```yaml
- step:
    type: GitOpsUpdateReleaseRepo
    spec:
      variables:
        - name: image_tag
          value: <+artifact.tag>
- step:
    type: GitOpsSync
    spec:
      prune: true
```

### PR-Based GitOps
```yaml
- step:
    type: CreatePR
    spec:
      updates:
        - path: environments/<+env.name>/values.yaml
          key: image.tag
          value: <+artifact.tag>
```

## Deployment Verification & Rollback

```yaml
- step:
    type: Verify
    spec:
      type: Canary
      sensitivity: MEDIUM
- step:
    type: Http
    spec:
      url: <+infra.variables.serviceUrl>/health
failureStrategies:
  - onFailure:
      errors:
        - AllErrors
      action:
        type: StageRollback
```

## Multi-Environment Promotion

```yaml
pipeline:
  stages:
    - stage:
        name: Deploy Dev
        spec:
          environment:
            environmentRef: development
    - stage:
        name: Deploy Staging
        spec:
          environment:
            environmentRef: staging
        when:
          condition: <+pipeline.stages.deploy_dev.status> == "SUCCEEDED"
    - stage:
        name: Deploy Production
        spec:
          environment:
            environmentRef: production
```

## Triggers

```yaml
# Artifact
trigger:
  source:
    type: Artifact
    spec:
      type: DockerRegistry
      imagePath: myorg/myapp
# Webhook
trigger:
  source:
    type: Webhook
    spec:
      type: Github
# Scheduled
trigger:
  source:
    type: Scheduled
    spec:
      expression: "0 2 * * *"
```

## CD Expressions

| Expression | Purpose |
|----------|---|
| <+service.name> | Service |
| <+env.name> | Environment |
| <+infra.namespace> | Namespace |
| <+artifact.image>:<+artifact.tag> | Image |
| <+pipeline.stages.X.output.VAR> | Output |

## API Operations

```bash
curl -X POST "https://app.harness.io/pipeline/api/pipeline/execute/${PIPELINE_ID}" -H "x-api-key: ${API_KEY}"
curl -X GET "https://app.harness.io/pipeline/api/pipelines/execution/v2/${EXECUTION_ID}" -H "x-api-key: ${API_KEY}"
curl -X PUT "https://app.harness.io/pipeline/api/pipelines/execution/interrupt/${EXECUTION_ID}" -H "x-api-key: ${API_KEY}"
```

## Common Issues

| Issue | Solution |
|-------|----------|
| Deployment timeout | Increase step timeout |
| Image pull failed | Verify connector credentials |
| Namespace not found | Check infrastructure definition |
| Manifest error | Validate YAML locally |
| Approval timeout | Review approval workflow |
| Rollback failed | Configure rollback steps |

## References

- [Harness CD Docs](https://developer.harness.io/docs/continuous-delivery)
- [Deployment Strategies](https://developer.harness.io/docs/continuous-delivery/manage-deployments/deployment-concepts)
- [GitOps](https://developer.harness.io/docs/continuous-delivery/gitops)

Overview

This skill implements Harness CD continuous delivery patterns for Kubernetes, Helm, Terraform, ECS, and serverless deployments. It provides pipeline building blocks for rolling, canary, and blue-green strategies, GitOps integration, approval gates, rollback handling, and multi-environment promotion. The skill focuses on orchestrating safe, automated promotions across dev, staging, and production.

How this skill works

Define pipelines that compose stages, steps, and rollbackSteps using declarative YAML. Steps include platform-specific deploy actions (K8sRollingDeploy, K8sCanaryDeploy, K8sBGStageDeployment), verification steps, approval steps, and GitOps update/sync steps. Triggers (artifact, webhook, scheduled) start pipelines and API endpoints enable programmatic execution and status checks.

When to use it

  • Deploy microservices to Kubernetes, ECS, or serverless platforms with structured CD pipelines
  • Implement progressive delivery strategies (Canary, Blue-Green, Rolling) and automated rollbacks
  • Manage multi-environment promotions (dev → staging → production) with conditional gates
  • Automate GitOps workflows (Argo CD, PR-based updates) to manage environment manifests
  • Enforce human or system approval gates (Harness, Jira, ServiceNow) before critical releases

Best practices

  • Model environments and infra separately; use environment refs and infrastructureDefinition for portability
  • Use small, focused steps with explicit rollbackSteps and failureStrategies to ensure recoverability
  • Validate manifests and terraform plans locally and in a pre-production environment before promotion
  • Drive deployments via artifact triggers or webhooks and use expressions (<+artifact.tag>, <+env.name>) for dynamic values
  • Add verification steps (health checks, canary analysis) to detect issues early and automate safe rollbacks

Example use cases

  • A Kubernetes service deployed to dev by rolling, promoted to staging on success, then to production after approvals
  • Blue-green deployment of a web app with service swap and instant rollback if verification fails
  • Canary release that shifts traffic incrementally and runs automated verification before full cutover
  • GitOps flow that updates image tags in an environment repo and triggers an Argo CD sync
  • Terraform-based infrastructure changes executed as part of a CD pipeline with approval and rollback

FAQ

How do I trigger a pipeline programmatically?

Use the Harness pipeline execution API with an x-api-key header to POST an execution and poll status via the execution endpoints.

How are rollbacks handled?

Define rollbackSteps per stage and configure failureStrategies to trigger StageRollback or custom rollback actions on detected errors.