Service-to-Service Trust: mTLS in the Chassis
Convey's certificate middleware authenticates machines instead of users - a forwarded-cert header, a subject ACL, and two defaults that look like security and aren't.
Archive
Every article
Newest first, grouped by year. Search or filter by topic.
- 556 articles
- 203 matching
All
.NET
AI Engineering
Architecture
Azure & DevOps
Data Warehousing
Engineering Practice
Microservices
Web APIs
The Logger You Configure Once
Convey's logging package turns a config section into a fully enriched Serilog pipeline - console, file, Seq, ELK and Loki sinks, a live log-level switch, and one middleware with a typo in its name.
JWTs and the Blacklist Problem
Convey's auth packages in two acts - a JWT layer that turns one config section into token issuing and validation, and the uncomfortable question every stateless system meets on logout day.
Secrets Before Configuration: Convey and Vault
How Convey's Vault package loads secrets into IConfiguration before the container exists, turns dynamic database credentials into ordinary config keys, and renews leases in the background - plus the secret-zero problem it cannot solve.
Discovery and Load Balancing Before the Mesh
How Convey wires Consul registration, health-gated deregistration and client-side balancing - and why Fabio exists to take the balancing decision back out of your process.
Typed Clients Over One HTTP Door
Convey's HTTP story in two layers - a hardened IHttpClient with retries, masking and correlation headers, and RestEase interfaces on top that turn a service name in config into a typed client.
Persistence as a Registration: Mongo and Redis
What you get when a chassis reduces MongoDB to one builder call and a named collection - a generic repository, paging, camelCase conventions, a seeding hook - and the transactions and indexes it deliberately leaves on your desk.
Commands and Events on the Wire
Convey's broker-CQRS bridge is seventy lines of code that make the same handler serve local dispatch and RabbitMQ delivery — one line per subscription, correlation context riding along for free.
The Outbox That Keeps Your Events Honest
Save the order, publish the event, crash in between - the dual-write problem, and how Convey's outbox and inbox turn at-least-once messaging into something you can build a business on.
Retries, Dead Letters, and the Plugin Chain
What Convey's RabbitMQ subscriber actually does when your handler throws - fixed-interval retries, an exception-to-message escape hatch, a dlx- safety net, and one plugin that can quietly defeat all of it.
A Message Broker Behind an Interface
Convey's messaging abstraction is two interfaces and an attribute - and the naming conventions underneath them quietly turn your C# class names into a public wire contract.
RabbitMQ by Convention
How Convey's RabbitMQ package turns a class name into an exchange, a routing key and a queue - two eager connections, a channel per thread, and a topology you never declare by hand.
Documenting an API That Has No Controllers
Delete your controllers and Swashbuckle goes blind. Convey rebuilds the OpenAPI document by hand from its endpoint registry - a document filter, a naming convention, and a few spec violations it hopes you won't notice.
From Route to Handler with No Controller in Between
Convey.WebApi.CQRS wires HTTP verbs straight to command and query dispatchers - one line per endpoint - and publishes your message catalog at /_contracts. A source read of the thinnest HTTP layer I've shipped to production.
Minimal APIs Before Minimal APIs Existed
Convey.WebApi threw away controllers, replaced every MVC formatter with its own, and bound route values into immutable commands by writing to compiler-generated backing fields. A source read of a routing layer built years before .NET shipped the same idea.
The Decorator Seam: Logging Handlers You Didn't Write
How Convey wraps every command and event handler with template-driven logging using one attribute, a Scrutor decoration — and a reflection trick against Scrutor itself that I admire and would never ship.
One Builder, Thirty Packages: Inside IConveyBuilder
The hundred lines of code that let an entire microservices toolkit compose from one fluent chain — a named registry, a list of build actions, and two hard lessons about doing work at startup.
Three Marker Interfaces and a Service Scope
Convey's CQRS layer is small enough to read in one sitting — commands, queries and events as empty interfaces, Scrutor scans to find handlers, and a scope-per-dispatch decision with consequences worth knowing before production.
The Microservices Chassis You Were Going to Write Anyway
Every team's fifth microservice ships with the same four hundred lines of bootstrap code as the first four. Opening a deep-dive series on Convey, the open-source .NET toolkit that turned that boilerplate into thirty composable packages.
Reading the Redis and Mongo Providers
Chronicle ships two persistence integrations, and reading them against the contract is a masterclass in provider sharp edges: a Redis key built from Type.GetHashCode() that changes on every restart, a Mongo delete-then-insert, and messages that may not survive the round trip.
When a Saga Library Is Overkill
Eight parts of source-reading later, the honest retrospective. What Chronicle gets right, the timeout-shaped hole at its centre, how it stacks up against MassTransit and NServiceBus and durable execution - and the cases where a status column beats every saga framework ever written.
Where a Saga Keeps Its Memory
Chronicle's persistence surface is two interfaces - a state repository and an append-only log - and the defaults behind AddChronicle() are two Lists. What the contracts really demand, why the in-memory implementations are sharper than they look, and how to write a provider that holds up.
Compensation Is a Replay in Reverse
When a Chronicle saga rejects, the saga log is replayed backwards and every handled message gets its CompensateAsync called. Tracing both rejection paths through the source reveals a surprise - only one of them actually compensates - plus a ForEach that never awaits.
Four Small Classes Run Every Saga
Seeker, initializer, processor, post-processor - Chronicle's whole runtime is four internal classes you can read in ten minutes. A source walk through the pipeline, including the gate that drops messages, the finally block that always persists, and the state that isn't as final as it looks.
One Message, Many Sagas
services.AddChronicle() registers sagas you never mentioned, and one ProcessAsync call can run five of them in parallel. Inside Chronicle's Scrutor scan, the seeker's dedupe trick, and the ref-counted lock that serializes each saga id.