# CI/CD Pipeline Configuration for usekaneo/kaneo: Full GitHub Actions Breakdown

> Explore the CI/CD pipeline configuration for usekaneo/kaneo. This GitHub Actions breakdown details linting, testing, building, and Docker image validation in five coordinated jobs.

- Repository: [kaneo.app/kaneo](https://github.com/usekaneo/kaneo)
- Tags: how-to-guide
- Published: 2026-08-04

---

**The usekaneo/kaneo repository uses GitHub Actions to implement a comprehensive CI/CD pipeline that covers linting, unit testing, building, integration testing, and Docker image validation through five coordinated jobs defined in [`.github/workflows/ci.yml`](https://github.com/usekaneo/kaneo/blob/main/.github/workflows/ci.yml).**

The Kaneo project, a Kubernetes-native workflow orchestration tool, relies entirely on GitHub Actions for its software delivery lifecycle. Understanding the **CI/CD pipeline configuration for usekaneo/kaneo** reveals how a modern TypeScript monorepo achieves reliable, reproducible deployments from code commit to production container.

## Core CI Pipeline: The Main Workflow

The heart of Kaneo's automation lives in [`.github/workflows/ci.yml`](https://github.com/usekaneo/kaneo/blob/main/.github/workflows/ci.yml). This workflow triggers on every push and pull request to the repository, executing five sequential verification jobs on `ubuntu-24.04` runners.

### 1. Lint Job: Code Quality Enforcement

The **lint** job ensures code consistency using Biome, a fast Rust-based toolchain. As implemented in `usekaneo/kaneo`, this job runs:

```bash
pnpm exec biome ci .

```

The job definition spans lines 11-33 of the workflow file and follows a standardized setup pattern: checkout, pnpm v10.32.1 installation, Node.js 20.20.2 setup with caching, frozen lockfile dependency installation, then the lint command itself.

### 2. Unit Job: Fast Feedback on Logic

The **unit** job (lines 34-55) reuses the identical environment preparation, then executes:

```bash
pnpm test

```

This runs the monorepo's unit test suite across all packages without external dependencies.

### 3. Build Job: Compilation Verification

The **build** job (lines 57-78) confirms the entire TypeScript monorepo compiles cleanly:

```bash
pnpm build

```

This catches type errors and build-time failures that unit tests might miss.

### 4. Integration Job: Database-Backed Testing

The **integration** job (lines 80-123) represents the most complex verification stage. It spins up a real **PostgreSQL 16** service container with health checks, injects test environment variables including a test-only `AUTH_SECRET`, then runs:

```bash
pnpm test:integration

```

This validates API behavior against an actual database rather than mocks, catching migration issues and query regressions.

### 5. Docker-Build Job: Image Smoke Test

The final CI job (lines 124-141) validates the containerization layer without publishing:

```bash
docker buildx build -f Dockerfile.kaneo --cache-from type=gha --cache-to type=gha

```

This uses **Docker Buildx** with GitHub Actions cache mounts to speed up subsequent runs.

## CD Workflows: Release and Deployment Automation

Beyond continuous integration, the **CI/CD pipeline configuration for usekaneo/kaneo** includes five dedicated deployment workflows triggered by releases:

### release.yml: Version and Artifact Publishing

The [`release.yml`](https://github.com/usekaneo/kaneo/blob/main/release.yml) workflow orchestrates semantic versioning. It publishes new npm package versions to the registry, creates annotated GitHub releases with changelogs, and attaches built artifacts for distribution.

### publish-mcp.yml: Multi-Container Image Build

The **publish-mcp.yml** workflow specifically handles the MCP (multi-container package) Docker image. This triggers after a successful release, building optimized production images and pushing to the configured container registry.

### docker.yml: Tagged Release Images

The [`docker.yml`](https://github.com/usekaneo/kaneo/blob/main/docker.yml) workflow provides an additional Docker build path specifically for git tags, ensuring every versioned release has a corresponding immutable container image.

### helm-chart.yml: Kubernetes Packaging

For operators deploying to Kubernetes, [`helm-chart.yml`](https://github.com/usekaneo/kaneo/blob/main/helm-chart.yml) lints the Helm chart definition, packages it, and publishes to the chart repository. This enables `helm install kaneo` workflows for end users.

### deploy-site.yml: Documentation Automation

The [`deploy-site.yml`](https://github.com/usekaneo/kaneo/blob/main/deploy-site.yml) workflow completes the CD picture by building and deploying the static documentation site to **GitHub Pages** on each release, ensuring docs stay synchronized with code.

## Local CI Simulation

Developers can reproduce the entire CI pipeline locally using the exact tool versions locked in the workflow:

```bash

# Match CI's pnpm version exactly

npm i -g pnpm@10.32.1

# Reproduce the frozen installation

pnpm install --frozen-lockfile

# Execute each CI stage locally

pnpm exec biome ci .          # lint

pnpm test                     # unit

pnpm build                    # build check

pnpm test:integration         # requires local Postgres

docker build -f Dockerfile.kaneo -t kaneo:local .

```

## Triggering a Full Release

To initiate the CD pipeline:

```bash
npm version patch -m "Release %s"
git push origin main --tags

```

This tag push triggers [`release.yml`](https://github.com/usekaneo/kaneo/blob/main/release.yml), which then chains into [`publish-mcp.yml`](https://github.com/usekaneo/kaneo/blob/main/publish-mcp.yml), [`helm-chart.yml`](https://github.com/usekaneo/kaneo/blob/main/helm-chart.yml), and [`deploy-site.yml`](https://github.com/usekaneo/kaneo/blob/main/deploy-site.yml) through workflow dependencies or repository dispatch events.

## Key Configuration Files

| File | Purpose |
|------|---------|
| [`.github/workflows/ci.yml`](https://github.com/usekaneo/kaneo/blob/main/.github/workflows/ci.yml) | Five-job CI pipeline with lint, unit, build, integration, and Docker validation |
| [`.github/workflows/release.yml`](https://github.com/usekaneo/kaneo/blob/main/.github/workflows/release.yml) | Version bumping, npm publishing, and GitHub release creation |
| [`.github/workflows/publish-mcp.yml`](https://github.com/usekaneo/kaneo/blob/main/.github/workflows/publish-mcp.yml) | Production Docker image build and registry push |
| [`.github/workflows/docker.yml`](https://github.com/usekaneo/kaneo/blob/main/.github/workflows/docker.yml) | Tag-triggered Docker image builds |
| [`.github/workflows/helm-chart.yml`](https://github.com/usekaneo/kaneo/blob/main/.github/workflows/helm-chart.yml) | Kubernetes Helm chart linting and packaging |
| [`.github/workflows/deploy-site.yml`](https://github.com/usekaneo/kaneo/blob/main/.github/workflows/deploy-site.yml) | Documentation site deployment to GitHub Pages |
| `Dockerfile.kaneo` | Multi-stage container definition for the Kaneo application |
| [`package.json`](https://github.com/usekaneo/kaneo/blob/main/package.json) | Monorepo script definitions (`test`, `build`, `test:integration`) |

## Summary

- The **CI/CD pipeline configuration for usekaneo/kaneo** centers on [`.github/workflows/ci.yml`](https://github.com/usekaneo/kaneo/blob/main/.github/workflows/ci.yml) with five verification jobs running on `ubuntu-24.04`
- Every job uses **pnpm v10.32.1** and **Node.js 20.20.2** with frozen lockfiles for reproducible builds
- Integration testing requires a real **PostgreSQL 16** service with health-checked startup
- Docker smoke tests use **Buildx** with GitHub Actions cache without pushing images
- Five separate CD workflows handle releases, container publishing, Helm packaging, and documentation deployment
- The entire pipeline can be simulated locally using the exact tool versions specified in the workflow files

## Frequently Asked Questions

### Where is the main CI workflow defined in usekaneo/kaneo?

The primary CI workflow lives in [`.github/workflows/ci.yml`](https://github.com/usekaneo/kaneo/blob/main/.github/workflows/ci.yml). It contains five jobs—lint, unit, build, integration, and docker-build—that execute on every push and pull request.

### What database does Kaneo use for integration testing?

The integration job spins up a **PostgreSQL 16** service container with health checks. Tests run via `pnpm test:integration` against this real database instance rather than mocks or SQLite.

### How can I run the CI checks locally before pushing?

Install `pnpm@10.32.1`, run `pnpm install --frozen-lockfile`, then execute the same commands as CI: `pnpm exec biome ci .`, `pnpm test`, `pnpm build`, and `pnpm test:integration` (requires local Postgres).

### What triggers the release and deployment workflows?

Pushing a git tag triggers [`release.yml`](https://github.com/usekaneo/kaneo/blob/main/release.yml), which publishes npm packages and creates GitHub releases. This cascades into [`publish-mcp.yml`](https://github.com/usekaneo/kaneo/blob/main/publish-mcp.yml) (Docker images), [`helm-chart.yml`](https://github.com/usekaneo/kaneo/blob/main/helm-chart.yml) (Kubernetes charts), and [`deploy-site.yml`](https://github.com/usekaneo/kaneo/blob/main/deploy-site.yml) (documentation).

### Does Kaneo use Docker Hub for container images?

Yes. The [`docker.yml`](https://github.com/usekaneo/kaneo/blob/main/docker.yml) and [`publish-mcp.yml`](https://github.com/usekaneo/kaneo/blob/main/publish-mcp.yml) workflows build and push images to Docker Hub or the configured registry when tags are created or releases are published.