Files
place-b-2/.gitea/workflows/deploy.yml
Scaffolder 7805eb8b79 initial commit
Change-Id: I62f6c7dc8ccc1a7462b6d40a210fd6f8a81de1c2
2026-10-12 18:53:23 +00:00

280 lines
14 KiB
YAML

name: Deploy to Orchestrator
on:
workflow_run:
workflows: ["Build and Push to ACR"]
types: [completed]
# Must list the branches the build actually runs on. Without standard branching
# the build runs on main, and a list of dev/staging/prod would silently match
# nothing -- the deploy would never fire and the build would look successful.
branches: [ "dev", "staging", "prod" ]
# The rollback path. Editing .platform/release.yaml is how a release is chosen, and
# build-push.yml deliberately ignores .platform/, so nothing else would trigger a
# deploy for it. This is what turns an approved rollback pull request into a running
# rollback the moment it merges.
push:
branches: [ "dev", "staging", "prod" ]
paths:
- '.platform/release.yaml'
workflow_dispatch:
inputs:
environment:
description: 'Target environment'
required: true
default: 'dev'
type: choice
options:
- dev
- staging
- prod
env:
PO_API_URL: https://api.dev.orchestrator.crucible.kyndemo.live
PO_ORG_ID: crucible
PO_AUTH_TOKEN: ${{ secrets.PO_AUTH_TOKEN }}
# ONE ORCHESTRATOR PROJECT PER APPLICATION.
#
# This used to be the shared `apps-cluster` project with one environment per app, which
# made every app a peer of every other: the Orchestrator tab on any component listed the
# entire estate, and an app had exactly one environment named after itself, so there was
# nowhere for dev/staging/prod to live.
#
# That shape existed to avoid a Terraform pull request against config/projects.tf for every
# scaffolded app. That constraint turned out not to be real -- `octl create project`,
# `octl create runner-rule` and `octl create environment` are all runtime operations, so
# the workflow below builds the whole thing on first deploy and needs no repository change.
PROJECT_ID: place-b-2
# The runner now comes from .platform/placement.yaml, through the guard job -- see "Read the placement decision".
# The runner a project's workloads execute on. This is NOT cosmetic: the Kubernetes and
# Helm providers are ambient, so a workload lands in whichever cluster its runner lives in,
# and Terraform state is keyed per runner. A project bound to the wrong runner deploys to
# the wrong cluster, and repointing it afterwards orphans the state it already owns.
OCTL_VERSION: 1.0.0
jobs:
guard:
name: Placement guard
runs-on: ubuntu-latest
outputs:
ready: ${{ steps.check.outputs.ready }}
runner: ${{ steps.placement.outputs.runner }}
steps:
- uses: actions/checkout@v4
with:
# The exact commit the deploy job ships, not a branch name. On a workflow_run the
# default checkout is the DEFAULT branch, and a branch name can move between this job
# and the deploy job -- the guard must judge the very commit the deploy will ship.
ref: ${{ github.event.workflow_run.head_sha || github.sha }}
- name: Check platform initialized
id: check
run: |
if [ -f ".platform/initialized.md" ]; then
echo "ready=true" >> $GITHUB_OUTPUT
else
echo "ready=false" >> $GITHUB_OUTPUT
echo "Skipping: .platform/initialized.md not found"
fi
# The placement decision is enforced HERE, on every deploy, not only by the form that
# wrote it. Missing, refused or unreadable: this job fails, the deploy job that needs it
# never starts, and nothing reaches the orchestrator. REFUSED lines are plain echo as
# well as ::error:: because Gitea's log view may not render the annotation.
- name: Read the placement decision
id: placement
if: steps.check.outputs.ready == 'true'
run: |
set -euo pipefail
RECORD=.platform/placement.yaml
# Top-level keys, one line each -- the same contract release.yaml keeps.
field() { sed -n "s/^$1:[[:space:]]*//p" "$RECORD" | head -1 | sed -e 's/^"//' -e 's/"$//'; }
if [ ! -f "$RECORD" ]; then
echo "REFUSED: no placement decision. $RECORD is missing, and nothing deploys without an approved record."
echo "::error::No placement decision: $RECORD is missing."
exit 1
fi
DECISION=$(field decision)
REASON=$(field reason)
RUNNER=$(field runner)
ZONE=$(field landing_zone_name)
case "$DECISION" in
placed) ;;
refused)
echo "REFUSED: $REASON"
echo "::error::Placement refused: $REASON"
exit 1 ;;
*)
echo "REFUSED: $RECORD has decision '$DECISION'; expected placed or refused."
echo "::error::Unreadable placement decision '$DECISION'."
exit 1 ;;
esac
case "$RUNNER" in
''|none)
echo "REFUSED: $RECORD is placed but names no runner."
echo "::error::Placed record names no runner."
exit 1 ;;
esac
echo "PLACED: $ZONE -- runner $RUNNER"
echo "runner=$RUNNER" >> "$GITHUB_OUTPUT"
deploy:
name: Deploy to Orchestrator
needs: guard
# Every trigger needs a runner from the placement record. workflow_dispatch used to skip
# the guard's verdict; an empty runner now means the guard did not place this workload.
if: >-
needs.guard.outputs.runner != '' && (
(github.event_name == 'workflow_run' && github.event.workflow_run.conclusion == 'success') ||
github.event_name == 'push' ||
github.event_name == 'workflow_dispatch')
runs-on: ubuntu-latest
steps:
- name: Checkout code
uses: actions/checkout@v4
with:
# The built commit, not a branch name (see the guard). On a workflow_run the default
# checkout is the DEFAULT branch, not the one that was built. That did not matter while
# the image tag came from an event field; it matters now that the tag is read out of a file in this checkout.
ref: ${{ github.event.workflow_run.head_sha || github.sha }}
- name: Install octl
run: |
set -euo pipefail
curl -fsSLo /tmp/octl.tar.gz \
"https://github.com/stellwerk-labs/platform-orchestrator-cli/releases/download/v${OCTL_VERSION}/platform-orchestrator-cli_${OCTL_VERSION}_linux_amd64.tar.gz"
tar xzf /tmp/octl.tar.gz -C /tmp
install -m 755 /tmp/octl /usr/local/bin/octl
octl --version
- name: Derive environment
run: |
# The environment is now a STAGE of this application -- dev, staging, prod -- because
# the project is the application. It used to be the component id, which was the only
# option while every app shared one project and had to be distinguishable inside it.
DISPATCH_ENV="${{ github.event.inputs.environment }}"
if [ -n "$DISPATCH_ENV" ]; then
ENV_ID="$DISPATCH_ENV"
else
# On a workflow_run the branch is the triggering run's, not this job's checkout.
BRANCH="${{ github.event.workflow_run.head_branch }}"
BRANCH="${BRANCH:-${GITHUB_REF_NAME}}"
case "$BRANCH" in
staging) ENV_ID=staging ;;
prod|main|master) ENV_ID=prod ;;
*) ENV_ID=dev ;;
esac
echo "Branch '$BRANCH' maps to environment '$ENV_ID'"
fi
echo "ENV_ID=$ENV_ID" >> $GITHUB_ENV
echo "Deploying $PROJECT_ID to environment: $ENV_ID"
- name: Ensure the project and its runner binding exist
env:
# From the placement record, through the guard -- never a literal in this file.
PO_RUNNER_ID: ${{ needs.guard.outputs.runner }}
run: |
set -euo pipefail
if [ -z "$PO_RUNNER_ID" ]; then
echo "::error::No runner from the placement guard; refusing to bind."
echo "REFUSED: No runner from the placement guard."
exit 1
fi
# Created on first deploy rather than by a pull request against config/projects.tf.
# None of this needs a repository change: project, runner rule and environment are
# all runtime objects.
#
# Neither create is idempotent, so both fall through to a read on the second run.
octl create project "$PROJECT_ID" \
--set display_name='place-b-2' || \
octl get project "$PROJECT_ID"
# The runner rule routes this project's deployments. A project already bound to a
# DIFFERENT runner is refused, never repointed: Terraform state is keyed per runner,
# so rebinding orphans what it owns. A failing read is a failure, not "no rule" --
# guessing "absent" is how a second rule gets created.
RULES=$(octl get runner-rules -o json)
# Several rules for one project, or a rule with no runner, is a binding nobody can
# vouch for: refuse it by name rather than pick the first. unique + join stays jq 1.6-safe.
if ! BOUND=$(printf '%s' "$RULES" | jq -r --arg p "$PROJECT_ID" '[.. | objects | select(.project_id? == $p) | (.runner_id // "<none>")] | unique | if length > 1 then error("bound to several runners: \(join(", "))") else (.[0] // empty) end' 2>&1); then
echo "REFUSED: project '$PROJECT_ID' has an ambiguous runner binding: $BOUND"
echo "::error::Runner binding is ambiguous; refusing to continue."
exit 1
fi
if [ -z "$BOUND" ]; then
octl create runner-rule \
--set project_id="$PROJECT_ID" \
--set runner_id="$PO_RUNNER_ID" \
--no-prompt
elif [ "$BOUND" != "$PO_RUNNER_ID" ]; then
echo "REFUSED: project '$PROJECT_ID' is bound to runner '$BOUND', but its placement record names '$PO_RUNNER_ID'."
echo "::error::Runner binding disagrees with the placement record; refusing to repoint."
exit 1
else
echo "Runner rule for '$PROJECT_ID' already binds '$BOUND', as the record says."
fi
- name: Ensure the environment exists
run: |
set -euo pipefail
# Project and environment ids are POSITIONAL; only env_type_id and display_name go
# through --set. `dev` and `stable` are the only environment TYPES that exist, so
# staging rides on the dev type -- the type governs policy, the id governs identity.
case "$ENV_ID" in
prod) ENV_TYPE=stable ;;
*) ENV_TYPE=dev ;;
esac
octl create environment "$PROJECT_ID" "$ENV_ID" \
--set env_type_id="$ENV_TYPE" \
--set display_name="$ENV_ID" || \
octl get environment "$PROJECT_ID" "$ENV_ID"
- name: Deploy the Score workload
run: |
set -euo pipefail
# `octl score deploy` is ADDITIVE — it adds or updates a workload in the manifest and
# never removes one. That is the opposite of `octl deploy`, where omission is
# deletion. Do not substitute one for the other.
# No --show-logs: octl 1.0.0 has no such flag and exits 1 with `unknown flag`
# BEFORE contacting the orchestrator, so the whole deploy dies on an argument
# typo. Its nearest relatives are --runner-logs-level (default `info`, already
# what we want) and --skip-logs (which suppresses storage). Neither streams the
# runner's logs into this job, so there is nothing to substitute -- the runner
# logs are read from the orchestrator, not from here.
# The image comes from .platform/release.yaml, the one place a deployable tag
# is written down. It used to be derived from the triggering commit, which made
# "what is running" a question you answered by reading event metadata -- and
# left a rollback with no file to edit and no way to name an older image.
RELEASE_FILE=.platform/release.yaml
if [ ! -f "$RELEASE_FILE" ]; then
echo "::error::$RELEASE_FILE is missing -- there is nothing to deploy."
exit 1
fi
IMAGE_REF=$(sed -n 's/^image:[[:space:]]*//p' "$RELEASE_FILE" | head -1 | tr -d "\"' ")
case "$IMAGE_REF" in
*/*:*) ;;
*) echo "::error::$RELEASE_FILE must set image to <registry>/<repository>:<tag>, found '$IMAGE_REF'."; exit 1 ;;
esac
echo "IMAGE_REF=$IMAGE_REF" >> $GITHUB_ENV
echo "Deploying $IMAGE_REF"
octl score deploy "$PROJECT_ID" "$ENV_ID" score.yaml \
--default-image "$IMAGE_REF" \
--no-prompt
- name: Deployment summary
if: always()
run: |
# IMAGE_REF is unset when the deploy step failed before reading the release
# file, and this step runs on failure too.
DEPLOYED_IMAGE="${IMAGE_REF:-unresolved}"
SHORT_SHA="${{ github.event.workflow_run.head_sha || github.sha }}"
SHORT_SHA="${SHORT_SHA:0:7}"
echo "## Deployment Result" >> $GITHUB_STEP_SUMMARY
echo "| Field | Value |" >> $GITHUB_STEP_SUMMARY
echo "|---|---|" >> $GITHUB_STEP_SUMMARY
echo "| Project | \`$PROJECT_ID\` |" >> $GITHUB_STEP_SUMMARY
echo "| Environment | \`$ENV_ID\` |" >> $GITHUB_STEP_SUMMARY
echo "| Image | \`$DEPLOYED_IMAGE\` |" >> $GITHUB_STEP_SUMMARY
echo "| Triggering commit | \`$SHORT_SHA\` |" >> $GITHUB_STEP_SUMMARY
echo "[View in Orchestrator Console](https://console.dev.orchestrator.crucible.kyndemo.live/orgs/$PO_ORG_ID/projects/$PROJECT_ID/environments/$ENV_ID)" >> $GITHUB_STEP_SUMMARY