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: demo-a-3 # 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='demo-a-3' || \ 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 // "")] | 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 /:, 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