🌠
Main concepts
🛰
Platforms
Approval policy
The approval policy allows organizations to create sophisticated run review and approval flows that reflect their preferred workflow, security goals, and business objectives. Without an explicit approval policy, anyone with write access to a stack can create a run (or a task). An approval policy can make this way more granular and contextual.
Runs can be reviewed when they enter one of the two states - queued or unconfirmed. When a queued run needs approval, it will not be scheduled before that approval is received, and if it is of a blocking type, it will block newer runs from scheduling, too. A queued run that's pending approval can be canceled at any point.
Here's an example of a queued run waiting for a human review - note how the last approval policy evaluation returned an Undecided decision. There's also a review button next to the cancelation one:
Review can be positive (approve) or negative (reject):
With a positive review, the approval policy could evaluate to Approve thus unblocking the run:
When an unconfirmed run needs approval, you will not be able to confirm it until that approval is received. The run can however be discarded at any point:
In principle, the run review and approval process are very similar to GitHub's Pull Request review, the only exception being that it's the Rego policy (rather than a set of checkboxes and dropdowns) that defines the exact conditions to approve the run.
If separate run approval and confirmation steps sound confusing, don't worry. Just think about how GitHub's Pull Requests work - you can approve a PR before merging it in a separate step. A PR approval means "I'm OK with this being merged". A run approval means "I'm OK with that action being executed".
Rules
Your approval policy can define the following boolean rules:
- approve: the run is approved and no longer requires (or allows) review;
- reject: the run fails immediately;
It's also perfectly acceptable for any given policy evaluation to return 'false' on both 'approve' and 'reject' rules. This only means that the result is yet 'undecided' and more reviews will be necessary to reach the conclusion. A perfect example would be a policy that requires 2 approvals for a given job - the first review is not yet supposed to set the 'approve' value to 'true'.
How it works
When a user reviews the run, Spacelift persists their review and passes it to the approval policy, along with other reviews, plus some information about the run and its stack. The same user can review the same run as many times as they want, but only their newest review will be presented to the approval policy. This mechanism allows you to change your mind, very similar to Pull Request reviews.
Data input
This is the schema of the data input that each policy request will receive:
1
{
2
"reviews": { // run reviews
3
"current": { // reviews for the current state
4
"approvals": [{ // positive reviews
5
"author": "string - reviewer username",
6
"request": { // request data of the review
7
"remote_ip": "string - user IP",
8
"timestamp_ns": "number - review creation Unix timestamp in nanoseconds",
9
},
10
"session": { // session data of the review
11
"login": "string - username of the reviewer",
12
"name": "string - full name of the reviewer",
13
"teams": ["string - names of teams the reviewer was a member of"]
14
},
15
"state": "string - the state of the run at the time of the approval",
16
}],
17
"rejections": [/* negative reviews, see "approvals" for schema */]
18
},
19
"older": [/* reviews for previous state(s), see "current" for schema */]
20
},
21
"run": { // the run metadata
22
"based_on_local_workspace": "boolean - whether the run stems from a local preview",
23
"command": "string or null, set when the run type is TASK",
24
"created_at": "number - creation Unix timestamp in nanoseconds",
25
"runtime_config": {
26
"before_init": ["string - command to run before run initialization"],
27
"project_root": "string - root of the Terraform project",
28
"runner_image": "string - Docker image used to execute the run",
29
"terraform_version": "string - Terraform version used to for the run"
30
},
31
"triggered_by": "string or null - user or trigger policy who triggered the run, if applicable",
32
"type": "string - type of the run",
33
"updated_at": "number - last update Unix timestamp in nanoseconds"
34
"user_provided_metadata": ["string - blobs of metadata provided using spacectl or the API when interacting with this run"]
35
},
36
"stack": { // the stack metadata
37
"administrative": "boolean - is the stack administrative",
38
"autodeploy": "boolean - is the stack currently set to autodeploy",
39
"branch": "string - tracked branch of the stack",
40
"labels": ["string - list of arbitrary, user-defined selectors"],
41
"locked_by": "optional string - if the stack is locked, this is the name of the user who did it",
42
"name": "string - name of the stack",
43
"namespace": "string - repository namespace, only relevant to GitLab repositories",
44
"project_root": "optional string - project root as set on the Stack, if any",
45
"repository": "string - name of the source GitHub repository",
46
"state": "string - current state of the stack",
47
"terraform_version": "string or null - last Terraform version used to apply changes"
48
},
49
}
Copied!
Examples
Two approvals and no rejections to approve an Unconfirmed run
In this example, each Unconfirmed run will require two approvals - including proposed runs triggered by Git events. Additionally, the run should have no rejections. Anyone who rejects the run will need to change their mind in order for the run to go through.
We suggest requiring more than one review because one approval should come from the run/commit author to indicate that they're aware of what they're doing, especially if their VCS handle is different than their IdP handle. This is something we practice internally at Spacelift.
1
package spacelift
2
3
approve { input.run.state != "UNCONFIRMED" }
4
5
approve {
6
count(input.reviews.current.approvals) > 1
7
count(input.reviews.current.rejections) == 0
8
}
Copied!
Two to approve, two to reject
This is a variation of the above policy, but one that will automatically fail any run that receives more than one rejection.
1
package spacelift
2
3
approve { input.run.state != "UNCONFIRMED" }
4
approve { count(input.reviews.current.approvals) > 1 }
5
reject { count(input.reviews.current.rejections) > 1 }
Copied!
Require approval for a task command not on the allowlist
1
package spacelift
2
3
allowlist := ["ps", "ls", "rm -rf /"]
4
5
# Approve when not a task.
6
approve { input.run.type != "TASK" }
7
8
# Approve when allowlisted.
9
approve { input.run.command == allowlist[_] }
10
11
# Approve with two or more approvals.
12
approve { count(input.reviews.current.approvals) > 1 }
Copied!
Combining multiple rules
Usually, you will want to apply different rules to different types of jobs. Since approval policies are attached to stacks, you will want to be smart about how you combine different rules. Here's how you can do that in a readable way, combining two of the above approval flows as an example:
1
package spacelift
2
3
# First, let's define all conditions that require explicit
4
# user approval.
5
requires_approval { input.run.state == "UNCONFIRMED" }
6
requires_approval { input.run.type == "TASK" }
7
8
# Then, let's automatically approve all other jobs.
9
approve { not requires_approval }
10
11
# Autoapprove some task commands. Note how we don't check for run type
12
# because only tasks will the have "command" field set.
13
task_allowlist := ["ps", "ls", "rm -rf /"]
14
approve { input.run.command == task_allowlist[_] }
15
16
# Two approvals and no rejections to approve.
17
approve {
18
count(input.reviews.current.approvals) > 1
19
count(input.reviews.current.rejections) == 0
20
}
Copied!
Role-based approval
Sometimes you want to give certain roles but not others the power to approve certain workloads. The policy below approves an unconfirmed run or a task when either a Director approves it, or both DevOps and Security roles approve it:
1
package spacelift
2
3
# First, let's define all conditions that require explicit
4
# user approval.
5
requires_approval { input.run.state == "UNCONFIRMED" }
6
requires_approval { input.run.type == "TASK" }
7
approve { not requires_approval }
8
9
approvals := input.reviews.current.approvals
10
11
# Let's define what it means to be approved by a director, DevOps amd Security.
12
director_approval { approvals[_].session.teams[_] == "Director" }
13
devops_approval { approvals[_].session.teams[_] == "DevOps" }
14
security_approval { approvals[_].session.teams[_] == "Security" }
15
16
# Approve when a single director approves:
17
approve { director_approval }
18
19
# Approve when both DevOps and Security approve:
20
approve { devops_approval; security_approval }
Copied!
Last modified 9d ago