Das Strangler-Fig-Muster ist schnell beschrieben: eine Fassade vor das Altsystem stellen, dahinter Funktion für Funktion in neue Services verlagern und das Altsystem abschalten, wenn nichts mehr übrig ist. Schaubilder dazu gibt es überall. Was sie auslassen: Woher wissen Sie bei jedem Schritt, dass die Clients noch genau das bekommen, was sie vorher bekamen?
Dieses Fallbeispiel geht einen vollständigen Schritt mit lauffähigem Code durch: ein kleiner Shop als Monolith, ein Gateway davor und der Produktkatalog als eigener Service. Der Code liegt auf GitHub: chudovo/application-modernization, Case 06. Code und Kommentare sind auf Englisch.
Auf einen Blick
| Vorher | Nachher | |
|---|---|---|
| Clients sprechen mit | dem Monolithen | einem Gateway (YARP) |
| Produktkatalog | Monolith, Tabelle Products | Katalogservice mit eigener Datenbank |
| Bestellungen und Bestand | Monolith | Monolith, für Clients dieselbe Adresse |
| Bestellungen brauchen Produktdaten | lesen die Tabelle Products direkt | fragen ein Interface, das den Katalogservice aufruft |
| Umschalten des Katalogs | nicht möglich | eine Routing-Änderung, kein Neustart |
| Bestandene Vertragsprüfungen | 19 von 19 | 19 von 19 in beiden Routing-Zuständen |
Die Reihenfolge der Arbeit
- Einen Vertrag gegen den Monolithen schreiben, so wie er ist.
- Das Gateway davorsetzen und alles an den Monolithen leiten.
- Im Monolithen eine Nahtstelle schneiden, wo anderer Code in den Teil greift, der gehen soll.
- Den neuen Service bauen und denselben Vertrag durch das Gateway dagegen laufen lassen.
- Die Daten kopieren und die Route umschalten.
Jeder Schritt ist klein und lässt sich einzeln ausliefern. Der Vertrag läuft nach jedem davon.
Schritt 1: der Vertrag
Der Vertrag besteht aus 19 Prüfungen, die nur HTTP kennen: Statuscodes, Header und Antworttexte, als Text verglichen. Er weiß nichts darüber, was hinter der Adresse steht. Deshalb läuft dieselbe Datei gegen den Monolithen, gegen das Gateway mit allem noch im Monolithen und gegen das Gateway mit dem Katalog aus dem neuen Service.
[Fact]
public async Task New_product_is_created_with_a_location_the_client_can_follow()
{
var response = await Http.PostAsync("/api/products", Json("""{"sku":"RUG-11","name":"Wool rug","price":210.00}"""));
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
Assert.Equal("""{"sku":"RUG-11","name":"Wool rug","price":210.00,"isActive":true}""", await Body(response));
// Clients follow this header as it is, so it must point at the address they talk to.
Assert.Equal(new Uri(Http.BaseAddress!, "/api/products/RUG-11"), response.Headers.Location);
}
Der Textvergleich ist absichtlich streng. Clients eines zehn Jahre alten Systems hängen an Details, die niemand aufgeschrieben hat: an einem Preis mit zwei Nachkommastellen, an einer Fehlermeldung, die dem Nutzer unverändert angezeigt wird.
Schritt 2: das Gateway, noch ohne herausgelösten Service
Das Gateway ist YARP, die Reverse-Proxy-Bibliothek von Microsoft, mit zwei Routen. Die Katalogpfade haben einen Besitzer, der sich im laufenden Betrieb ändern lässt, alles andere geht an den Monolithen:
private RouteConfig[] Routes() =>
[
// The extracted slice: everything under /api/products.
new RouteConfig
{
RouteId = "catalog",
ClusterId = CatalogOwner == Owner.CatalogService ? "catalog-service" : "monolith",
Match = new RouteMatch { Path = "/api/products/{**rest}" },
},
// Everything else still belongs to the monolith.
new RouteConfig { RouteId = "everything-else", ClusterId = "monolith", Match = new RouteMatch { Path = "/{**rest}" } },
];
/// Moves the catalog paths to the other system. Takes effect for the next request, no restart.
public void RouteCatalogTo(Owner owner)
{
CatalogOwner = owner;
Provider.Update(Routes(), Clusters());
}
An dieser Stelle führen beide Routen zum Monolithen, und es soll sich nichts ändern. Der Vertrag sah das anders: 2 von 19 Prüfungen schlugen fehl.
Expected: http://127.0.0.1:39703/api/products/RUG-11 (the gateway, which the client talked to)
Actual: http://127.0.0.1:36103/api/products/RUG-11 (the monolith behind it)
Legt der Monolith ein Produkt oder eine Bestellung an, liefert er die Adresse der neuen Ressource zurück, gebildet aus der Adresse, unter der er aufgerufen wurde. Hinter einem Gateway ist das seine interne Adresse, die Clients nicht erreichen. Der Proxy schickt den ursprünglichen Host in Headern mit, aber die Anwendung muss angewiesen werden, sie zu verwenden:
// Behind the gateway the request arrives at an internal address. The gateway says which address the client used,
// and links such as the Location header are built from that. Name the proxy you trust; do not trust everyone.
app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedHost | ForwardedHeaders.XForwardedProto,
});
Auch der Schritt, der nichts ändern soll, ändert also etwas. Besser, man erfährt das, bevor der erste Service umgezogen ist.
Schritt 3: die Nahtstelle
Im Monolithen las der Bestellcode die Katalogtabelle, wann immer er einen Namen oder einen Preis brauchte. Dieser direkte Zugriff macht einen Monolithen schwer teilbar, und er muss verschwinden, bevor der Katalog gehen kann:
// Before: the order code reads the catalog table itself. Nothing in a monolith stops it.
var product = await db.Products.FindAsync(line.Sku);
// After: it asks an interface. Configuration decides who answers.
public interface ICatalog
{
Task<CatalogProduct?> FindAsync(string sku);
}
CatalogProduct? product;
try { product = await catalog.FindAsync(line.Sku); }
catch (CatalogUnavailableException)
{
// What used to be a method call can now fail on its own.
return StatusCode(503, new { error = "Orders cannot be placed right now: the catalog is unavailable." });
}
Zunächst wird das Interface aus der lokalen Tabelle bedient, und der Monolith verhält sich wie zuvor. Die Nahtstelle zeigt auch, wie breit die Abhängigkeit wirklich ist. Hier braucht der Bestellcode vier Felder eines Produkts und sonst nichts.
Schritt 4: der neue Service und was der Vertrag gefunden hat
Der Katalogservice wurde zuerst so geschrieben, wie man heute einen neuen ASP.NET-Core-Service schreibt, ohne auf die Antworten des Monolithen zu schauen. Durch das Gateway schlugen 10 von 19 Vertragsprüfungen fehl:
| Der Vertrag verlangt | Die erste Version des neuen Service lieferte |
|---|---|
| Preise mit zwei Nachkommastellen: 89.50 | 89.5 |
| Jeder Fehler hat einen Text: {„error“:“…“} | leere Antworten bei 401, 404 und 409, ein Validierungsdokument bei 400 |
| Location ist eine absolute Adresse | /api/products/RUG-11 |
| Die Suche ignoriert Groß- und Kleinschreibung | eine Suche, die Groß- und Kleinschreibung unterscheidet |
Für sich genommen ist nichts davon ein Fehler des neuen Service. Jedes ist eine Voreinstellung, die vom Verhalten des Altsystems abweicht, und jedes ist mit einer Zeile behoben, sobald es bekannt ist. Ohne den Vertrag hätten die Clients sie im Betrieb gefunden, eine nach der anderen.
Schritt 5: Daten kopieren und umschalten
Der neue Service erhält eine eigene Datenbank. Ein kleiner Kopierlauf liest jedes Produkt über die API des Monolithen und speichert es. Er lässt sich wiederholen, und der zweite Lauf übernimmt Änderungen aus der Zwischenzeit. Danach werden zwei Schalter umgelegt: Das Gateway leitet die Katalogpfade an den neuen Service, und der Bestellcode des Monolithen fragt den Service statt der eigenen Tabelle.
Was das Herauslösen mit sich bringt, das der Monolith nie hatte
Der Vertrag belegt, dass sich für Clients nichts geändert hat. Das Herauslösen schafft aber auch Situationen, die es vorher nicht gab, und die brauchen eigene Tests.
Eine Abhängigkeit, die ausfallen kann. Ist der Katalogservice gestoppt, lassen sich Bestellungen weiter lesen und Bestände abfragen. Eine neue Bestellung wird mit 503 und einer klaren Meldung abgelehnt und reserviert keinen Bestand. Die Katalogpfade liefern 502 vom Gateway. Vor der Trennung war keiner dieser Zustände möglich.
Das Routing lässt sich sofort zurückschalten. Die Daten nicht. Das Muster wird oft mit dem Versprechen verkauft, man könne jederzeit zurück. Für die Route stimmt das:
[Fact]
public async Task Routing_back_to_the_monolith_is_immediate_but_data_written_since_the_cutover_stays_behind()
{
await _shop.Client.PostAsync("/api/products", Json(NewRug));
await _shop.Client.PutAsync("/api/products/CHAIR-01/price", Json("""{"price":95.00}"""));
_shop.Routing.RouteCatalogTo(Owner.Monolith);
// The very next request is answered by the monolith again, without a restart.
Assert.Equal(HttpStatusCode.OK, (await _shop.Client.GetAsync("/api/products/DESK-02")).StatusCode);
// But the monolith's table stopped at the cutover: the new product and the new price are not there.
Assert.Equal(HttpStatusCode.NotFound, (await _shop.Client.GetAsync("/api/products/RUG-11")).StatusCode);
}
Ein nach der Umschaltung angelegtes Produkt existiert nur im neuen Service, und der Monolith hat noch die alten Preise. Es gibt eine zweite Falle: Die Route im Gateway und die Einstellung im Monolithen sind getrennte Schalter. Wird nur das Routing zurückgestellt, sehen Clients den Katalog des Monolithen mit 89.50, während eine neue Bestellung weiterhin vom Service mit 95.00 bepreist wird. Auch das prüft der Test. Ein Rollback-Plan muss festlegen, wie Daten zurückfließen und in welcher Reihenfolge die Schalter wechseln.
Was geprüft ist und was nicht
| Prüfung | Ergebnis |
|---|---|
| Vertrag gegen den Monolithen | 19 / 19 |
| Vertrag durch das Gateway, alles an den Monolithen geleitet | 19 / 19 |
| Vertrag durch das Gateway, Katalog aus dem neuen Service | 19 / 19 |
| Tests zum Herauslösen: Routing, Datenkopie, Ausfall, Routing zurück und wieder vor | 5 / 5 |
- Last und Latenz wurden nicht gemessen. Jede Katalogabfrage während einer Bestellung ist jetzt ein Netzwerkaufruf. Cache, Wiederholungen oder Circuit Breaker gibt es hier nicht.
- Schreibzugriffe während der Umschaltung sind nicht behandelt. Ein Produkt, das zwischen der letzten Kopie und dem Umschalten im Monolithen geändert wird, geht verloren. Eine echte Umschaltung braucht eine kurze Schreibsperre oder Change Data Capture.
- Kein Deployment. Die Teile laufen in einem Testprozess auf lokalen Ports mit In-Memory-Datenbanken. Keine Container, keine Service Discovery, keine Verschlüsselung zwischen den Services.
- Nur der einfache Schnitt. Bestand und Bestellungen teilen sich eine Transaktion und bleiben zusammen. Sie zu trennen ist ein schwierigeres Problem, für das es andere Muster gibt.
Selbst ausführen
Benötigt wird nur das .NET 10 SDK. Die Tests starten jedes Teil auf einem freien lokalen Port:
dotnet test before/tests/Shop.Contract # the contract against the monolith
dotnet test after/tests/Shop.Contract # the contract through the gateway, twice, plus the extraction tests
Warum der Katalog zuerst ging
Er wird weit häufiger gelesen als geschrieben, nur ein anderer Teil des Systems hängt von ihm ab, und er teilt mit nichts eine Transaktion. Das ist das Profil eines guten ersten Kandidaten. Wie sich ein solcher Schnitt in einem echten System finden lässt, was mit der gemeinsamen Datenbank geschieht und wann man gar nicht teilen sollte, behandelt der Leitfaden zur Migration von Monolithen zu Microservices.
Wenn Sie für eine solche Migration ein Team suchen, finden Sie hier unseren Vergleich der Top-Unternehmen für .NET-Modernisierung.