Strangler-Fig-Muster: ein Service aus dem Monolithen herausgelöst, am Beispiel

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

VorherNachher
Clients sprechen mitdem Monolitheneinem Gateway (YARP)
ProduktkatalogMonolith, Tabelle ProductsKatalogservice mit eigener Datenbank
Bestellungen und BestandMonolithMonolith, für Clients dieselbe Adresse
Bestellungen brauchen Produktdatenlesen die Tabelle Products direktfragen ein Interface, das den Katalogservice aufruft
Umschalten des Katalogsnicht möglicheine Routing-Änderung, kein Neustart
Bestandene Vertragsprüfungen19 von 1919 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 verlangtDie erste Version des neuen Service lieferte
Preise mit zwei Nachkommastellen: 89.5089.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 Kleinschreibungeine 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üfungErgebnis
Vertrag gegen den Monolithen19 / 19
Vertrag durch das Gateway, alles an den Monolithen geleitet19 / 19
Vertrag durch das Gateway, Katalog aus dem neuen Service19 / 19
Tests zum Herauslösen: Routing, Datenkopie, Ausfall, Routing zurück und wieder vor5 / 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.

Eugene begann seine Karriere bei Chudovo im Jahr 2015. Der Experte ist für Beratungsleistungen verantwortlich, die unter anderem eine enge Kommunikation mit den Kunden, die Analyse ihrer Bedürfnisse, die Entwicklung maßgeschneiderter Softwarestrategien usw. umfassen. Während seiner Tätigkeit bei Chudovo nahm ein IT-Berater an über 17 Projekten teil, die ein breites Spektrum an Kundendienstleistungen abdeckten und Kundenprobleme aus geschäftlicher Sicht lösten. Dank Eugenes Beteiligung konnten die Kunden eine effiziente Strategie für das Geschäftswachstum sowie eine langfristige Technologie-Roadmap entwickeln. Eugene nimmt in der Rolle des IT-Beraters aktiv an Softwareentwicklungsprojekten teil und erstellt Vorschläge für die Kunden.