deployer

Deployer is a relatively simple, yet powerful localhost CI/CD instrument.

Features

1. Local and remote pipeline execution.
2. Two pipeline drivers: standard (Deployer) and pure shell.
3. Auto-generate Docker/Podman and Ansible configs and run pipelines inside images or at remote hosts.
4. Export pipelines to shell scripts, GitHub Actions & GitLab CI configurations, and systemd services.
5. Resolve variables for actions with .env-files, any shell command or even HashiCorp Vault KV2 storage.
6. Move build & run caches away of your project's directory. Only artifacts and .depl/config.yaml file.
7. Watch and rebuild your project automatically via depl watch.
8. Use internal versioned content storage and autopatching system on pipeline runs.

Usability features

1. YAML configuration format, but you may use only your terminal with Deployer's TUI.
2. Global localhost action and pipeline registries.
3. Built-in documentation via depl docs.
4. Automatic checks of actions requirements before pipeline execution.
5. Automatic artifacts delivery to ./artifacts folder.
6. Wide selection of settings and launch options.

Migration guide

If you encounter problems after updating Deployer, especially after moving from 1.x to 2.x, please read Migration Guide.

Documentation

For Deployer config specification, proceed to DOCS.md or run depl docs.

This repository also have content examples, see README.md.

Build

Well, the building process is very easy. You need to install Rust first:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

After installation, execute this:

cargo install depl

That's it! Now you have /home/username/.cargo/bin/depl binary. Modify the PATH variable, if you need to.

Usage

Let's assume that you need to make a pipeline to build and compress your Rust project.

First of all, let's create a simple action.

depl new action

For example, let's name it UPX Compress. The short name will be upx, the version - 0.1.0.

The full YAML is:

info: upx@0.1.0
requirements:
  - type: exists_any
    paths:
      - /bin/upx
      - /usr/bin/upx
      - ~/.local/bin/upx
action:
  type: staged
  stage: build
  cmd: upx %af%
  placeholders:
    - "%af%"

If you're not familiar with UPX, consider visiting it's home page.

So, let's create a pipeline that will build the binary from the Rust code with preinstalled cargo-release@0.1.0 action and then compress this binary with upx@0.1.0.

depl new pipeline

The full YAML is:

title: pack
info: pack@0.1.0
default: true
artifacts:
  - from: target/release/my-app
    to: my-app
actions:
  - title: Build my app in release mode
    used: cargo-release@0.1.0
  - title: Compress my app
    used: upx@0.1.0

Note that you can change the inner content of actions inside pipelines, and also can change the inner content of pipelines and their actions if these pipelines assigned to your project. The changes will not affect actions and pipelines from Deployer's Registries.

You can view your actions and pipelines and get it in YAML by simple commands:

depl ls actions
depl ls pipelines

depl cat action upx@0.1.0
depl cat pipeline pack@0.1.0

And, of course, load actions and pipelines from YAML files by:

depl new action -f {your-action.yaml}

The next step is to init the project.

cd my-rust-project
depl init
depl edit .

You should add some actions and specify project variables that you'll use. For our example, add simple variable with target/release/my-app value. Also add cargo-release@0.1.0 and upx@0.1.0 actions from actions Registry. And not forget to add Cargo.lock file and target folder to cache files to prevent syncing project folder cache with run folder cache (without specifying this; see depl run --help for more).

After all you will get this .depl/config.yaml:

project_name: my-app
version: 8
ignore_files:
  - .git
cache_files:
  - Cargo.lock
  - target
variables:
  my-var:
    value:
      type: plain
      value: target/release/my-app
actions:
  - info: cargo-release@0.1.0
    tags:
      - rust
      - cargo
    requirements:
      - type: exists_any
        paths:
          - /bin/cargo
          - ~/.cargo/bin/cargo
    action:
      type: staged
      stage: build
      cmd: cargo build --release
  - info: upx@0.1.0
    requirements:
      - type: exists_any
        paths:
          - /bin/upx
          - /usr/bin/upx
          - ~/.local/bin/upx
    action:
      type: staged
      stage: build
      cmd: upx %af%
      placeholders:
        - "%af%"
pipelines:
  - title: pack
    desc: Got from `pack`.
    info: pack@0.1.0
    default: true
    artifacts:
      - from: target/release/my-app
        to: my-app
    actions:
      - title: Build my app in release mode
        used: cargo-release@0.1.0
      - title: Compress my app
        used: upx@0.1.0
        with:
          "%af%": my-var

Having only .depl/config.yaml inside your project's root, you can completely share your build/deploy configurations.

At the end, let's build the project!

depl run

# see the run options: you can share cache files and folders by symlinking or copying
depl run --help
depl run -fc

# or explicitly specify the project pipeline's short name - `build-and-compress`
depl run pack

# create pipeline with `Observe` action and start development server with auto-rebuild
depl watch build-and-deploy-devel

For other options, check:

depl run -h