Tutorial: Build a Distribution

In this tutorial you build a Distribution: one System where a single extractor publishes messages to a Topic and several loaders subscribe, each delivering to its own destination. The scenario is order notifications: an ERP emits them, and both a warehouse system and a web shop need every one.

You build it in two passes. First an extractor and a single loader, assembled into a System and run end to end. Then you scaffold a second loader and wire it into the System by hand, editing the topology declaration yourself instead of regenerating it. The second pass is the core lesson: the System is a small piece of C# you own, and growing it is an edit, not a rebuild.

Unlike the transactional integration tutorial, you write no pipeline code here. The scaffolds ship with working sample logic, and the work happens one level up: composing Components into a System.

Before you begin

• Tools installed: .NET SDK 10, Docker Desktop, Dapr CLI 1.16+ (initialized with dapr init), Task
• The Intropy CLI installed and on your PATH (intropy --help prints the verbs)
• A scratch directory you don’t mind throwing away; every command runs from its root unless a chapter says otherwise

Template release

The trees, code, and outputs on these pages were captured from template release v0.4.1, and every create command pins it with --template-version v0.4.1 so what you see matches the text. Chapter 2 carries one known package-version correction for this release.

What you’ll build

FIG D1The Distribution you finish with: one extractor publishing order notifications, two loaders subscribing, each delivering to its own destination. Locally, all three external systems are folders.

Your code External touchpoint Infrastructure, not your code

The three external systems are reached through Ports, and locally every Port resolves to a folder under the host’s test/ directory. In production the WMS Port might become an SFTP binding and the web shop’s an HTTP one; that is deployment configuration, not code, which is why the diagram doesn’t name a transport. Build, connect, deploy covers the boundary after the local run has made it visible.

What you learn

• How scaffold records let intropy sys create assemble a System.
• How a Topic becomes the shared contract between Components.
• How Ports name external touchpoints without choosing adapters.
• How the topology grows when a second destination is added.

The chapters

Each chapter introduces one thing and ends in a runnable command. You can stop after any of them.

1. Scaffold the components — render the extractor and the first loader, sharing one topic and one contract
2. Create the System and run it — assemble the scaffolds into a system host and watch an order travel end to end
3. Add a second loader by hand — scaffold the web loader and wire it into the topology declaration yourself
4. Run the fan-out — one published message, two deliveries, two destination folders