Using Resource Types

Resource Types can be used to extend the functionality of your pipeline and provide deeper integrations. This example uses one to trigger a job whenever a new Dinosaur Comic is out.

- name: rss
  type: docker-image
    repository: suhlig/concourse-rss-resource
    tag: latest

- name: booklit-releases
  type: rss
    url: http://www.qwantz.com/rssfeed.php

- name: announce
  - get: booklit-releases
    trigger: true

1.6 Resource Types

Each resource in a pipeline has a type. The resource's type determines what versions are detected, the bits that are fetched when used for a get step, and the side effect that occurs when used for a put step.

Out of the box, Concourse comes with a few resource types to cover common CI use cases like dealing with Git repositories and S3 buckets. These are called the "core" resource types. These are packaged with the worker, and can be listed via fly workers -d.

Beyond these core types, each pipeline can configure its own resource types by specifying resource_types at the top level. Each resource type is itself defined as a resource that provides the container image for the pipeline resource type (see Implementing a Resource Type). You will almost always be using the registry-image resource when doing this.

A somewhat exhaustive list of all available resource types - both from the Concourse core project and from external contributors - is available in the Resource Types wiki page.

Similar to Resources, each configured resource type consists of the following attributes:

name: string

Required. The name of the new resource type. This should be short and simple. This name will be referenced by resources defined within the same pipeline, and image_resources used by tasks running in the pipeline.

Pipeline-provided resource types can override the core resource types by specifying the same name.

type: string

Required. The type of the resource used to provide the resource type's container image. Yes, this is a bit meta. Usually this will be docker-image, as the resource type must result in a container image, though there may be other image formats (possibly themselves defined as pipeline resource types!).

A resource type's type can refer to other resource types, and can also use the core type that it's overriding. This is useful for bringing in a newer or forked registry-image resource.

source: object

Optional. The location of the resource type's resource. This varies by resource type, and is a black box to Concourse; it is blindly passed to the resource at runtime.

To use docker-image as an example, the source would contain something like repository: username/reponame. See the Docker Image resource (or whatever resource type your resource type uses) for more information.

privileged: boolean

Optional. Default false. If set to true, the resource's containers will be run with full capabilities, as determined by the Garden backend the task runs on. For Linux-based backends it typically determines whether or not the container will run in a separate user namespace, and whether the root user is "actual" root (if set to true) or a user namespaced root (if set to false, the default).

This is a gaping security hole; only configure it if the resource type needs it (which should be called out in its documentation). This is not up to the resource type to decide dynamically, so as to prevent privilege escalation via third-party resource type exploits.

params: object

Optional. Arbitrary params to pass when fetching the resource.

check_every: string

Optional. Default 1m. The interval on which to check for new versions of the resource type. Acceptable interval options are defined by the time.ParseDuration function.

tags: [string]

Optional. Default []. A list of tags to determine which workers the checks will be performed on. You'll want to specify this if the source is internal to a worker's network, for example. See also tags step modifier.

Optional. Default false. Only relevant when Global Resources is enabled. When set to true, resources using this resource type will have a version history that is unique to the resource, rather than sharing a global version history.