How to define Codefresh pipelines in a declarative manner
Codefresh offers its own built-in format for creating pipelines. The pipeline specification is based on the YAML syntax allowing you to describe your pipelines in a completely declarative manner.
Using Codefresh yaml is the recommended way to create pipelines.
Simple example for codefresh.yml
Here is a very minimal example:
It contains two steps, one named build_image that creates a docker image, and another one called perform_tests that runs unit test with
If you want to know more about how steps work in Codefresh make sure to read the introduction to Pipelines first, before moving on.
Basic skeleton of a codefresh.yml file.
You can customize your build environment (pipeline) by using the Codefresh YAML file,
codefresh.yml. Codefresh uses the build specifications in the
codefresh.yml file to execute your build. The
codefresh.yml can be basic, or include intricate build specifications.
A YAML file is comprised of a series of steps that are executed in the order in which they are specified.
You must define a step type for each step. Each step uses Docker images and containers as facilitators for execution. For example, the Freestyle step spins up a container and executes the specified shell commands from the YAML file.
The step names should be unique within the same pipeline. This mainly affects the visualization of the pipeline when it runs.
Each step produces a resource, which you can reference in other steps, and are executed in real-time. For example, a Freestyle step can reference an image that was produced by a Build step. This allows you to chain steps together, and create highly-customized builds.
Steps chaining and referencing is possible due to implementation of variables in yml file - read more on relevant section
|Build||Builds a Docker image.|
|Push||Pushes a Docker image to a Docker registry.|
|Git Clone||That step not required and added automatically|
|Composition||Start a finite Docker Composition.|
|Launch Composition||Start a long term Docker composition|
|Freestyle||Execute one or more shell commands.|
To build your pipeline using a
codefresh.yml file, in the General Settings section, toggle the
Use YML build option to the ON position.
If you are editing Codefresh yaml within the Codefresh GUI, the editor will automatically highlight errors as they happen.
This allows you to make quick edits (and possibly run some builds) straight from the GUI. Once you are happy with your pipeline you should commit it to your repository as
codefresh.yml (pipeline as code).
For more information on where the YAML file can be stored see the creating pipelines page.
By default Codefresh will execute all steps in the yaml file and instantly fail the build, if any step
presents an error. To change this behavior add the
fail_fast:false property in any step that you wish to be ignored
in case of errors.
For example, if you have a freestyle step that runs integration tests, and you don’t want the whole pipeline
to fail if any of the tests fail, add the
fail_fast line to that step:
Now the pipeline will continue to run even if the step
Notice also that by default Codefresh pipelines run in sequential mode. All steps will be executed one after
the other and in the same order as included in the
If you wish to use parallel steps in your pipelines, see the parallel steps page.
Retrying a step
Sometimes you want to retry a step that has a problem. Network hiccups, transient failures and flaky test environments are common problems that prevent pipelines from working in a predictable manner.
Codefresh allows you to retry any of your steps with the built-in syntax:
retry: block has the following parameters:
maxAttemptsdefines how many times this step will run again if there are execution errors. Default is 1.
delayis the number of seconds to wait before each attempt. Default is 5 seconds
exponentialFactordefines how many times the delay should be multiplied by itself after each attempt. default is 1
All parameters are optional. The exponentialFactor works like this:
- exponentialFactor=1, delay=5 => each time wait 5 seconds before trying again, no matter the number of attempts
- exponentialFactor=2, delay=5 => first retry will have a delay of 25 seconds, third will have 125 and so on
Here is a full example:
Notice that Codefresh also provides the following variables that allow you change your script/applications according to the retry attempts:
CF_CURRENT_ATTEMPTcontains the number of current retry attempt
CF_MAX_ATTEMPTScontains all the number of total attempts defined
The retry mechanism is available for all kinds of steps.
Grouping steps with pipeline stages
By default all pipeline steps are shown one after the other.
This view works ok for small pipelines, but for a big number of steps it is better to group them into pipeline stages like shown below:
The number of stages (i.e columns) and their titles is completely configurable.
To enable this view you need to make two modifications at the
Here is the skeleton:
As you can see the modifications needed are:
- List all the stage names at the root of the pipeline file
- Use the
stageproperty on each step to assign it to a stage.
This updated pipeline view is only a nice way to visualize the pipeline. It does not affect the order of step execution. Steps will still execute in the same order listed in the
codefresh.ymlfile. If you wish to use parallel execution and advanced workflows see the parallel steps page.
Here is a more concrete example that you can use as a starting point:
If you run the pipeline you will see this view
Remember that the assignment of a step to a stage is happening only for graphical grouping purposes. It does
not affect the way your steps run. All steps will still run in the same order mentioned in the
Also notice if you enable this view a stage called default will show all build steps that are not explicitly assigned to a stage.
Using YAML anchors to avoid repetition
Codefresh also supports yaml anchors, references and extends. These allow you to keep your pipeline DRY.
For example, let’s say that you have two freestyle steps:
- The first one fills a MySQL server with data
- The second one runs integration tests that use the MySQL server
Here is the respective pipeline:
Instead of repeating the same environment variables in both steps, we can create them once and then just reference them in the second step with the
You also extend steps like below:
Here we deploy to two kubernetes clusters. The first step defines the staging deployment. For the second step, we extend the first one and only change the name of the cluster to point to production. Everything else (i.e. namespace and service ) are exactly the same.