Skip to main content

Sea Trial

Fix the broken integration points in the delivery pipeline so that commissioning a vessel in Backstage results in a running deployment.

Mission Objective

  • A commissioned vessel is fully delivered: its code and deployment repositories exist, its delivery workflow has completed, its Argo CD Application is synced, and its service is running in the cluster
  • See the vessel's live deployment status on its page in Backstage
  • The vessel's service is reachable directly and reports itself seaworthy

Key Learnings

Best Suited For

Platform and DevOps engineers who have met these tools before and want to see how they fit together. You should be comfortable with Kubernetes, YAML, and reading a tool's logs and UI. Prior exposure to Backstage, Gitea, and the Argo projects helps, but the focus here is the integration between them, not any one tool.

The Story

The commission office is back in business: manifests are filed, repositories are created, and every new vessel is entered into the fleet registry. Yet the captains keep coming back with the same complaint. Their vessels are commissioned on paper, but they never actually sail.

Between the commission office and open water lies a chain of yards, each meant to pick up where the last left off: a push to the archives should summon the shipyard, the shipyard should build the hull from the plans and hand it to the harbor master, and the harbor master should bring the finished vessel into formation. Somewhere along that chain the handoffs are misconfigured, and every vessel stalls before it reaches the water.

Your mission: trace a single commission from the office all the way to open water, find every point where the chain is broken, and repair the integrations so that commissioning a vessel results in a running ship you can reach directly.

Architecture
Left-to-right delivery pipeline: Backstage creates the repositories, Argo Events triggers the CI build, Argo Workflows builds the image and updates the tag, Argo CD syncs the deployment, and the vessel's app is up and running.

Commissioning a vessel kicks off a delivery pipeline that spans several tools. Backstage files two repositories in Gitea (the vessel's code and its deployment manifests). A push to the code repository fires a Gitea webhook into Argo Events, whose Sensor submits an Argo Workflow. That workflow clones the code, builds a container image and pushes it to Gitea's registry, then stamps the new image tag onto the deployment repository. Argo CD discovers the deployment repository and syncs it into the cluster as a running Deployment and Service. The diagram below shows the full chain.

Each vessel's page in Backstage is your cockpit: it shows the vessel's live Argo CD sync and health and its delivery workflows, so you can watch a commission progress and spot where it stalls. Alongside it, use each tool's own view: Gitea's repositories and a webhook's Recent Deliveries, the Argo Workflows UI (port 30113), and the Argo CD UI (port 30100).

You edit two things: the delivery pipeline manifests under platform/ (argo-events/, argo-workflows/, argocd/) and the vessel commissioning template under backstage/templates/vessel-commissioning-template/.

This level runs a real container build on a Kubernetes cluster. It works on the default Codespace, but if you hit resource problems or the pipeline feels sluggish, upgrade to a larger (4-core / 16 GB) machine. Either way, give the pipeline a few minutes after commissioning: the first build pulls its base images before an image ever reaches the cluster.

A quick translation from the story to the tools: a vessel is a small service you deploy, made up of its code repository, its deployment manifests, and the running Deployment and Service in the cluster. The commission office is Backstage, the archives are Gitea, the shipyard is Argo Workflows, and the harbor master is Argo CD; Argo Events is the lookout that summons the shipyard when new code is filed. A vessel "reaching open water" just means a commissioned service made it all the way to a running, reachable deployment.

Ready to start?

Launch in a preconfigured devcontainer

Open in Codespaces (opens in new tab)

Free GitHub account required

Walkthrough
  1. Open in GitHub Codespaces. The devcontainer is pre-configured and starts automatically. When you push from Codespaces, GitHub forks the repository to your account automatically.

    Prefer working locally? Clone the repo and open it in any editor that supports the Dev Containers specification (VS Code, JetBrains IDEs, and others). The devcontainer config will be detected automatically.

  2. Start Backstage with make backstage. The first run compiles for ~30-60s; once it's up, the commission office is available in your browser on port 3000. Leave it running in that terminal; restart any time with Ctrl-C then make backstage.

    The rest of the platform (Gitea, Argo Events, Argo Workflows, Argo CD) is already running in the cluster.

  3. Open the Ports tab and navigate to each service:

    • Port 3000: Backstage. The commission office and your cockpit. Start it with make backstage, then commission vessels and watch each one's page. Signs in as a guest, no credentials needed.
    • Port 30112: Gitea (admin / a-super-secure-password). The archives: each vessel's code and deployment repositories, the org webhook (Recent Deliveries), and the container registry.
    • Port 30113: Argo Workflows. The shipyard: the delivery workflow runs, step by step, with per-step logs. No sign-in required.
    • Port 30100: Argo CD (readonly / a-super-secure-password). The harbor master: each vessel's Application, sync status, and health.
  4. In Backstage, go to Create and run the Commission a Vessel template. It will commission cleanly, but the vessel won't sail. That's expected: your job is to find out why.

    Open the new vessel's page in the catalog. It's your cockpit: it shows the vessel's Argo CD deployment status and its delivery workflows. From there, follow the chain outward and see how far each commission gets:

    • Gitea (port 30112): were both repositories created? Did the push reach the pipeline (check a webhook's Recent Deliveries)?
    • Argo Workflows (port 30113): did a build run for this vessel, and if it failed, what does the failing step report?
    • Argo CD (port 30100): is there an Application for the vessel, and is it synced and healthy?

    Each tool shows you one handoff. Follow the data from one to the next until you find where it stalls.

  5. The breaks live in the delivery pipeline manifests and the commissioning template:

    platform/argo-events/
    platform/argo-workflows/
    platform/argocd/
    backstage/templates/vessel-commissioning-template/
    

    Read the relevant file top to bottom and compare it against what you observed. After editing a platform/ manifest, re-apply it with make apply. Because the pipeline is triggered by a push, test a fix by commissioning a fresh vessel (or redelivering the push from Gitea's Recent Deliveries). Changes to the template take effect on the next vessel you commission.

    When you think a vessel can sail end to end, check your work. make verify grades the most recently commissioned vessel stage by stage and reports the first place the pipeline runs aground:

    make verify
    

Complete Your Challenge

  • When you push from Codespaces, GitHub forks the repository to your account automatically. If you are working locally, fork the repository on GitHub before pushing.
  • Verify your solution:
    make verify
    If it passes, it generates a Certificate of Completion you can paste into the discussion.
  • Share your solutions in the challenge thread (opens in new tab) on community.offon.dev.

Completed the challenge? Share your achievement on LinkedIn (opens in new tab)

Toolbox

  • Backstage (opens in new tab) - The commission office and your cockpit (port 3000). Commission a vessel from Create, then watch its page for the vessel's Argo CD status and delivery workflows.
  • Gitea (opens in new tab) - The archives (port 30112). Holds each vessel's code and deployment repositories, the org webhook, and the container registry. A webhook's Recent Deliveries shows whether a push was delivered.
  • Argo Workflows (opens in new tab) - The shipyard (port 30113). Runs the multi-step build-and-deliver workflow; its UI shows each run, step by step, and why a step failed.
  • Argo CD (opens in new tab) - The harbor master (port 30100). Discovers deployment repositories and reconciles them into the cluster; its UI shows each vessel's sync and health.
Know someone who'd enjoy this?