Steps

Steps are the deployment actions that run in each stage. They define what happens during a deployment -- synthesizing infrastructure, deploying containers, running scripts, waiting for approval, and more.

Step Configuration

steps:
  - name: Deploy API
    id: api_deploy
    type: DEVRAMPS:ECS:DEPLOY
    goes_after: ["Synthesize Infrastructure"]
    params:
      cluster_name: ${{ steps.infra.ecs_cluster_name }}
      service_name: ${{ steps.infra.ecs_service_name }}
      reference_task_definition: ${{ steps.infra.task_definition }}
      image_url: ${{ stage.artifacts["API Image"].image_url }}

Step fields

Field	Required	Description
name	Yes	Display name for the step. Must be unique within the pipeline.
type	Yes	The step type identifier (e.g., DEVRAMPS:ECS:DEPLOY). See Step Reference.
id	No	Short alias for referencing this step's outputs in expressions.
params	Yes	Step-specific parameters. Varies by step type.
goes_after	No	Array of step names or IDs that must complete before this step starts.

Step Ordering

By default, steps execute sequentially in the order they appear in the YAML. Each step waits for the previous step to complete.

steps:
  # Step 1 runs first
  - name: Synthesize Infrastructure
    type: DEVRAMPS:TERRAFORM:SYNTHESIZE
    params: { ... }

  # Step 2 runs after Step 1 (implicit ordering)
  - name: Deploy API
    type: DEVRAMPS:ECS:DEPLOY
    params: { ... }

  # Step 3 runs after Step 2 (implicit ordering)
  - name: Bake Period
    type: DEVRAMPS:APPROVAL:BAKE
    params: { ... }

Parallel steps

Use goes_after to run steps in parallel. A step with goes_after starts as soon as all the specified dependencies finish -- not when the previous step in the list finishes.

steps:
  - name: Synthesize Infrastructure
    id: infra
    type: DEVRAMPS:TERRAFORM:SYNTHESIZE
    params: { ... }

  # These two steps run in parallel after infra completes
  - name: Deploy API
    type: DEVRAMPS:ECS:DEPLOY
    goes_after: ["Synthesize Infrastructure"]
    params: { ... }

  - name: Run Migrations
    type: DEVRAMPS:DATABASE:MIGRATE
    goes_after: ["Synthesize Infrastructure"]
    params: { ... }

  # This step waits for both parallel steps to finish
  - name: Bake Period
    type: DEVRAMPS:APPROVAL:BAKE
    goes_after: ["Deploy API", "Run Migrations"]
    params: { ... }

Parallel step failure behavior

If one parallel step fails, other parallel steps that are already running will continue to completion (they are not cancelled). However, any steps that depend on the failed step will not start. The overall stage will be marked as failed.

This creates the following execution graph:

Synthesize Infrastructure
        │
    ┌───┴───┐
    ▼       ▼
Deploy   Migrations
  API
    └───┬───┘
        ▼
   Bake Period

Step IDs

The id field gives a step a short alias for use in expressions. This is useful when a step's name contains spaces or special characters.

steps:
  - name: Synthesize Infrastructure
    id: infra
    type: DEVRAMPS:TERRAFORM:SYNTHESIZE
    params: { ... }

  - name: Deploy API
    type: DEVRAMPS:ECS:DEPLOY
    params:
      # With id: use dot notation
      cluster_name: ${{ steps.infra.ecs_cluster_name }}
      # Without id: use bracket notation with the full name
      cluster_name: ${{ steps["Synthesize Infrastructure"].ecs_cluster_name }}

Step Outputs

Many step types produce outputs that can be referenced by subsequent steps using expressions. For example, the Terraform Synthesize step outputs all of your Terraform output values, which you can then use in deploy steps:

# Terraform outputs become step outputs automatically
cluster_name: ${{ steps.infra.ecs_cluster_name }}

The available outputs depend on the step type:

Step Type	Output Behavior
Terraform Synthesize	All Terraform output values become step outputs automatically.
ECS Deploy	Outputs deployment status and service details.
EKS Deploy / Helm	Outputs rollout status.
Script Execute	Outputs are determined by the script's exit behavior.
Custom Steps	Outputs are defined by the custom step's success() call.

Use steps.step_id.output_name (dot notation) or steps["Step Name"].output_name (bracket notation) to reference outputs.

Built-In Step Types

DevRamps provides step types for common deployment patterns. See the Step Reference for detailed documentation of each type.

Infrastructure

Type	Description
DEVRAMPS:TERRAFORM:SYNTHESIZE	Run Terraform to provision and update infrastructure.

Deploy

Type	Description
DEVRAMPS:ECS:DEPLOY	Deploy a container image to Amazon ECS with rolling updates.
DEVRAMPS:EKS:DEPLOY	Update container images on an EKS Kubernetes Deployment.
DEVRAMPS:EKS:HELM	Deploy to EKS using Helm charts.
DEVRAMPS:CODEDEPLOY:DEPLOY	Deploy to EC2 Auto Scaling Groups via AWS CodeDeploy.
DEVRAMPS:EC2:DEPLOY	Deploy to a single EC2 instance via SSH or SSM.

Script & Database

Type	Description
DEVRAMPS:SCRIPT:EXECUTE	Run an arbitrary script from your repository.
DEVRAMPS:DATABASE:MIGRATE	Run database migrations (Flyway, Liquibase, or custom).

Approval

Type	Description
DEVRAMPS:APPROVAL:BAKE	Wait for a specified duration (soak test).
DEVRAMPS:APPROVAL:TEST	Run automated tests; proceed on pass, block on fail.

Custom

Type	Description
CUSTOM:*	User-defined steps built with the DevRamps SDK.

VM-Based Steps

Some steps execute inside an isolated virtual machine (EC2 instance) with your repository cloned. These steps support additional configuration:

Field	Default	Description
host_size	"small"	VM size: "small", "medium", or "large".
architecture	"linux/amd64"	CPU architecture: "linux/amd64" or "linux/arm64".
dependencies	[]	System dependencies to install (e.g., ["node.24"]).

VM sizes

Size	vCPUs	Memory
small	2	4 GB
medium	4	8 GB
large	8	16 GB

Available dependencies

Dependency	Description
node.24	Node.js 24.x
node.22	Node.js 22.x
node.20	Node.js 20.x
node.18	Node.js 18.x
python.3	Python 3.x
go.1	Go 1.x
java.21	Java 21 (Corretto)
java.17	Java 17 (Corretto)

Docker is available on all build VMs by default.

Which steps run in VMs?

VM-based step types include: EKS Deploy, EKS Helm, Script Execute, Database Migrate, and all custom steps. These steps clone your repository and execute in an isolated EC2 instance.

Non-VM steps (ECS Deploy, CodeDeploy Deploy, EC2 Deploy, Terraform Synthesize, approval steps) are orchestrated by DevRamps directly and interact with AWS APIs without needing a build VM.

- name: Run Custom Script
  type: DEVRAMPS:SCRIPT:EXECUTE
  params:
    script_path: /scripts/deploy.sh
    timeout: 30