Concourse is an open-source continuous thing-doer.

Centered around the simple mechanics of resources, tasks, and jobs, Concourse delivers a versatile approach to automation that excels at CI/CD.

Quick Start

Core features

Concourse is engineered to be expressive, versatile, and secure, remaining intuitive even as your project complexity grows.

Code-based configuration

resources:
- name: booklit
  type: git
  source: {uri: "https://github.com/concourse/booklit"}

jobs:
- name: unit
  plan:
  - get: booklit
    trigger: true
  - task: test
    file: booklit/ci/test.yml

Visual verification

unit
booklit

A Concourse pipeline functions like a distributed, continuous Makefile.

Each job contains a build plan defining the job's input resources and what actions to perform with them when changes occur.

Your pipeline appears visualized in the web UI, requiring just one click to move from a failed job to understanding the cause of failure.

The visualization provides immediate feedback: if it looks wrong, it probably is wrong.

A more complex example...

Jobs can depend on other jobs through passed constraints. The resulting network of jobs and resources creates a dependency graph that continuously advances your project forward, from source code to production.

unit rc ship
version
release
version
booklit
booklit
booklit
version
release-notes

This pipeline example can be found in the Booklit repository.

Source-controlled CI

$ fly -t ci set-pipeline -p booklit -c pipeline.yml
$ vim pipeline.yml
$ fly -t ci set-pipeline -p booklit -c pipeline.yml
$ git add pipeline.yml
$ git commit -m "initial pipeline"█

All configuration and management happens through the fly CLI.

The fly set-pipeline command uploads your configuration to Concourse. Once finalized, you can commit the file to source control, making it easy to recover your project if you migrate to a new Concourse server.

Reproducible, debuggable builds

$ fly -t ci intercept -j booklit/unit -s unit
root@2c15ff11:/tmp/build/0df9eea0# ps
    PID TTY          TIME CMD
    171 pts/1    00:00:00 bash
   1876 pts/1    00:00:00 ps
root@2c15ff11:/tmp/build/0df9eea0# ls
depspath  gopath
root@2c15ff11:/tmp/build/0df9eea0# █

Everything executes in containers, ensuring a clean environment for each run.

Every task specifies its own image, providing complete control over its dependencies, instead of managing packages on your workers.

The fly intercept command lets you access a build's containers directly, simplifying troubleshooting of problematic builds.

Efficient local testing

~/booklit $ fly -t ci execute -c ci/test.yml
executing build 1 at http://localhost:8080/builds/1
initializing
booklit: 4.74 MiB/s 0s
running gopath/src/github.com/concourse/booklit/ci/test
fetching dependencies...
installing ginkgo...
running tests...
█

The fly execute command enables you to run builds with local modifications.

These builds execute exactly as they would in your pipeline, eliminating the need to push incomplete commits while debugging.

When a pipeline build fails, you can use fly execute with the -j flag to run a one-off build with the same inputs as the failed build. You can then replace an input with your local changes using -i to test your fix.

Custom integrations

resource_types:
- name: rubygem
  type: registry-image
  source:
    repository: troykinsella/concourse-rubygems-resource

resources:
- name: rspec-gem
  type: rubygem
  source: {gem: rspec}

jobs:
- name: bundle
  plan:
  - get: rspec-gem
    trigger: true
  - # ...

Concourse doesn't rely on a complex plugin system. Instead, it focuses on a single powerful abstraction: resource, which are implemented by resource types.

The pipeline.resources field configures external artifacts that your pipeline will monitor for changes, retrieve, and update.

For instance, a resource with type git refers to a git repository, which will be cloned in a get step and pushed to using a put step. Behind the scenes, Concourse continuously runs git fetch to check for new commits that jobs might want to trigger on.

At its foundation, Concourse has no built-in knowledge of git. It includes a git resource type by default, but you can easily integrate your own into your pipeline through the pipeline.resource_types field.

To discover available resource types, check out the Resource Types catalog!